clang-format changes

54 files changed, 5013 insertions, 6069 deletions

diff --git a/tmk_core/protocol/arm_atsam/adc.c b/tmk_core/protocol/arm_atsam/adc.c
index cb5c349b7..1ef1b11d5 100644
--- a/tmk_core/protocol/arm_atsam/adc.c
+++ b/tmk_core/protocol/arm_atsam/adc.c
@@ -24,76 +24,92 @@ uint16_t v_con_2;
 uint16_t v_con_1_boot;
 uint16_t v_con_2_boot;
 
-void ADC0_clock_init(void)
-{
+void ADC0_clock_init(void) {
     DBGC(DC_ADC0_CLOCK_INIT_BEGIN);
 
-    MCLK->APBDMASK.bit.ADC0_ = 1;                        //ADC0 Clock Enable
+    MCLK->APBDMASK.bit.ADC0_ = 1;  // ADC0 Clock Enable
 
-    GCLK->PCHCTRL[ADC0_GCLK_ID].bit.GEN = GEN_OSC0;      //Select generator clock
-    GCLK->PCHCTRL[ADC0_GCLK_ID].bit.CHEN = 1;            //Enable peripheral clock
+    GCLK->PCHCTRL[ADC0_GCLK_ID].bit.GEN  = GEN_OSC0;  // Select generator clock
+    GCLK->PCHCTRL[ADC0_GCLK_ID].bit.CHEN = 1;         // Enable peripheral clock
 
     DBGC(DC_ADC0_CLOCK_INIT_COMPLETE);
 }
 
-void ADC0_init(void)
-{
+void ADC0_init(void) {
     DBGC(DC_ADC0_INIT_BEGIN);
 
-    //MCU
-    PORT->Group[1].DIRCLR.reg = 1 << 0;                   //PB00 as input 5V
-    PORT->Group[1].DIRCLR.reg = 1 << 1;                   //PB01 as input CON2
-    PORT->Group[1].DIRCLR.reg = 1 << 2;                   //PB02 as input CON1
-    PORT->Group[1].PMUX[0].bit.PMUXE = 1;                 //PB00 mux select B ADC 5V
-    PORT->Group[1].PMUX[0].bit.PMUXO = 1;                 //PB01 mux select B ADC CON2
-    PORT->Group[1].PMUX[1].bit.PMUXE = 1;                 //PB02 mux select B ADC CON1
-    PORT->Group[1].PINCFG[0].bit.PMUXEN = 1;              //PB01 mux ADC Enable 5V
-    PORT->Group[1].PINCFG[1].bit.PMUXEN = 1;              //PB01 mux ADC Enable CON2
-    PORT->Group[1].PINCFG[2].bit.PMUXEN = 1;              //PB02 mux ADC Enable CON1
-
-    //ADC
+    // MCU
+    PORT->Group[1].DIRCLR.reg           = 1 << 0;  // PB00 as input 5V
+    PORT->Group[1].DIRCLR.reg           = 1 << 1;  // PB01 as input CON2
+    PORT->Group[1].DIRCLR.reg           = 1 << 2;  // PB02 as input CON1
+    PORT->Group[1].PMUX[0].bit.PMUXE    = 1;       // PB00 mux select B ADC 5V
+    PORT->Group[1].PMUX[0].bit.PMUXO    = 1;       // PB01 mux select B ADC CON2
+    PORT->Group[1].PMUX[1].bit.PMUXE    = 1;       // PB02 mux select B ADC CON1
+    PORT->Group[1].PINCFG[0].bit.PMUXEN = 1;       // PB01 mux ADC Enable 5V
+    PORT->Group[1].PINCFG[1].bit.PMUXEN = 1;       // PB01 mux ADC Enable CON2
+    PORT->Group[1].PINCFG[2].bit.PMUXEN = 1;       // PB02 mux ADC Enable CON1
+
+    // ADC
     ADC0->CTRLA.bit.SWRST = 1;
-    while (ADC0->SYNCBUSY.bit.SWRST) { DBGC(DC_ADC0_SWRST_SYNCING_1); }
-    while (ADC0->CTRLA.bit.SWRST) { DBGC(DC_ADC0_SWRST_SYNCING_2); }
-
-    //Clock divide
+    while (ADC0->SYNCBUSY.bit.SWRST) {
+        DBGC(DC_ADC0_SWRST_SYNCING_1);
+    }
+    while (ADC0->CTRLA.bit.SWRST) {
+        DBGC(DC_ADC0_SWRST_SYNCING_2);
+    }
+
+    // Clock divide
     ADC0->CTRLA.bit.PRESCALER = ADC_CTRLA_PRESCALER_DIV2_Val;
 
-    //Averaging
+    // Averaging
     ADC0->AVGCTRL.bit.SAMPLENUM = ADC_AVGCTRL_SAMPLENUM_4_Val;
-    while (ADC0->SYNCBUSY.bit.AVGCTRL) { DBGC(DC_ADC0_AVGCTRL_SYNCING_1); }
-    if      (ADC0->AVGCTRL.bit.SAMPLENUM == ADC_AVGCTRL_SAMPLENUM_1_Val) ADC0->AVGCTRL.bit.ADJRES = 0;
-    else if (ADC0->AVGCTRL.bit.SAMPLENUM == ADC_AVGCTRL_SAMPLENUM_2_Val) ADC0->AVGCTRL.bit.ADJRES = 1;
-    else if (ADC0->AVGCTRL.bit.SAMPLENUM == ADC_AVGCTRL_SAMPLENUM_4_Val) ADC0->AVGCTRL.bit.ADJRES = 2;
-    else if (ADC0->AVGCTRL.bit.SAMPLENUM == ADC_AVGCTRL_SAMPLENUM_8_Val) ADC0->AVGCTRL.bit.ADJRES = 3;
-    else                                                                 ADC0->AVGCTRL.bit.ADJRES = 4;
-    while (ADC0->SYNCBUSY.bit.AVGCTRL) { DBGC(DC_ADC0_AVGCTRL_SYNCING_2); }
-
-    //Settling
-    ADC0->SAMPCTRL.bit.SAMPLEN = 45;      //Sampling Time Length: 1-63, 1 ADC CLK per
-    while (ADC0->SYNCBUSY.bit.SAMPCTRL) { DBGC(DC_ADC0_SAMPCTRL_SYNCING_1); }
-
-    //Load factory calibration data
-    ADC0->CALIB.bit.BIASCOMP = ((*(uint32_t *)ADC0_FUSES_BIASCOMP_ADDR) & ADC0_FUSES_BIASCOMP_Msk) >> ADC0_FUSES_BIASCOMP_Pos;
-    ADC0->CALIB.bit.BIASR2R = ((*(uint32_t *)ADC0_FUSES_BIASR2R_ADDR) & ADC0_FUSES_BIASR2R_Msk) >> ADC0_FUSES_BIASR2R_Pos;
+    while (ADC0->SYNCBUSY.bit.AVGCTRL) {
+        DBGC(DC_ADC0_AVGCTRL_SYNCING_1);
+    }
+    if (ADC0->AVGCTRL.bit.SAMPLENUM == ADC_AVGCTRL_SAMPLENUM_1_Val)
+        ADC0->AVGCTRL.bit.ADJRES = 0;
+    else if (ADC0->AVGCTRL.bit.SAMPLENUM == ADC_AVGCTRL_SAMPLENUM_2_Val)
+        ADC0->AVGCTRL.bit.ADJRES = 1;
+    else if (ADC0->AVGCTRL.bit.SAMPLENUM == ADC_AVGCTRL_SAMPLENUM_4_Val)
+        ADC0->AVGCTRL.bit.ADJRES = 2;
+    else if (ADC0->AVGCTRL.bit.SAMPLENUM == ADC_AVGCTRL_SAMPLENUM_8_Val)
+        ADC0->AVGCTRL.bit.ADJRES = 3;
+    else
+        ADC0->AVGCTRL.bit.ADJRES = 4;
+    while (ADC0->SYNCBUSY.bit.AVGCTRL) {
+        DBGC(DC_ADC0_AVGCTRL_SYNCING_2);
+    }
+
+    // Settling
+    ADC0->SAMPCTRL.bit.SAMPLEN = 45;  // Sampling Time Length: 1-63, 1 ADC CLK per
+    while (ADC0->SYNCBUSY.bit.SAMPCTRL) {
+        DBGC(DC_ADC0_SAMPCTRL_SYNCING_1);
+    }
+
+    // Load factory calibration data
+    ADC0->CALIB.bit.BIASCOMP   = ((*(uint32_t *)ADC0_FUSES_BIASCOMP_ADDR) & ADC0_FUSES_BIASCOMP_Msk) >> ADC0_FUSES_BIASCOMP_Pos;
+    ADC0->CALIB.bit.BIASR2R    = ((*(uint32_t *)ADC0_FUSES_BIASR2R_ADDR) & ADC0_FUSES_BIASR2R_Msk) >> ADC0_FUSES_BIASR2R_Pos;
     ADC0->CALIB.bit.BIASREFBUF = ((*(uint32_t *)ADC0_FUSES_BIASREFBUF_ADDR) & ADC0_FUSES_BIASREFBUF_Msk) >> ADC0_FUSES_BIASREFBUF_Pos;
 
-    //Enable
+    // Enable
     ADC0->CTRLA.bit.ENABLE = 1;
-    while (ADC0->SYNCBUSY.bit.ENABLE) { DBGC(DC_ADC0_ENABLE_SYNCING_1); }
+    while (ADC0->SYNCBUSY.bit.ENABLE) {
+        DBGC(DC_ADC0_ENABLE_SYNCING_1);
+    }
 
     DBGC(DC_ADC0_INIT_COMPLETE);
 }
 
-uint16_t adc_get(uint8_t muxpos)
-{
+uint16_t adc_get(uint8_t muxpos) {
     ADC0->INPUTCTRL.bit.MUXPOS = muxpos;
-    while (ADC0->SYNCBUSY.bit.INPUTCTRL) {}
+    while (ADC0->SYNCBUSY.bit.INPUTCTRL) {
+    }
 
     ADC0->SWTRIG.bit.START = 1;
-    while (ADC0->SYNCBUSY.bit.SWTRIG) {}
-    while (!ADC0->INTFLAG.bit.RESRDY) {}
+    while (ADC0->SYNCBUSY.bit.SWTRIG) {
+    }
+    while (!ADC0->INTFLAG.bit.RESRDY) {
+    }
 
     return ADC0->RESULT.reg;
 }
-
diff --git a/tmk_core/protocol/arm_atsam/adc.h b/tmk_core/protocol/arm_atsam/adc.h
index 5a90ece3f..9ab653e5a 100644
--- a/tmk_core/protocol/arm_atsam/adc.h
+++ b/tmk_core/protocol/arm_atsam/adc.h
@@ -18,11 +18,11 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #ifndef _ADC_H_
 #define _ADC_H_
 
-#define ADC_5V_START_LEVEL              2365
+#define ADC_5V_START_LEVEL 2365
 
-#define ADC_5V     ADC_INPUTCTRL_MUXPOS_AIN12_Val
-#define ADC_CON1   ADC_INPUTCTRL_MUXPOS_AIN14_Val
-#define ADC_CON2   ADC_INPUTCTRL_MUXPOS_AIN13_Val
+#define ADC_5V ADC_INPUTCTRL_MUXPOS_AIN12_Val
+#define ADC_CON1 ADC_INPUTCTRL_MUXPOS_AIN14_Val
+#define ADC_CON2 ADC_INPUTCTRL_MUXPOS_AIN13_Val
 
 extern uint16_t v_5v;
 extern uint16_t v_5v_avg;
@@ -34,4 +34,4 @@ extern uint16_t v_con_2_boot;
 void ADC0_clock_init(void);
 void ADC0_init(void);
 
-#endif //_ADC_H_
+#endif  //_ADC_H_
diff --git a/tmk_core/protocol/arm_atsam/arm_atsam_protocol.h b/tmk_core/protocol/arm_atsam/arm_atsam_protocol.h
index 88109186a..8cb00b872 100644
--- a/tmk_core/protocol/arm_atsam/arm_atsam_protocol.h
+++ b/tmk_core/protocol/arm_atsam/arm_atsam_protocol.h
@@ -33,17 +33,16 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 #ifndef MD_BOOTLOADER
 
-#include "main_arm_atsam.h"
-#ifdef RGB_MATRIX_ENABLE
-#include "led_matrix.h"
-#include "rgb_matrix.h"
-#endif
-#include "issi3733_driver.h"
-#include "./usb/compiler.h"
-#include "./usb/udc.h"
-#include "./usb/udi_cdc.h"
-
-#endif //MD_BOOTLOADER
-
-#endif //_ARM_ATSAM_PROTOCOL_H_
-
+#    include "main_arm_atsam.h"
+#    ifdef RGB_MATRIX_ENABLE
+#        include "led_matrix.h"
+#        include "rgb_matrix.h"
+#    endif
+#    include "issi3733_driver.h"
+#    include "./usb/compiler.h"
+#    include "./usb/udc.h"
+#    include "./usb/udi_cdc.h"
+
+#endif  // MD_BOOTLOADER
+
+#endif  //_ARM_ATSAM_PROTOCOL_H_
diff --git a/tmk_core/protocol/arm_atsam/clks.c b/tmk_core/protocol/arm_atsam/clks.c
index 1ff318e59..84ed6d83a 100644
--- a/tmk_core/protocol/arm_atsam/clks.c
+++ b/tmk_core/protocol/arm_atsam/clks.c
@@ -19,83 +19,105 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 #include <string.h>
 
-volatile clk_t system_clks;
+volatile clk_t    system_clks;
 volatile uint64_t ms_clk;
-uint32_t usec_delay_mult;
-#define USEC_DELAY_LOOP_CYCLES 3 //Sum of instruction cycles in us delay loop
+uint32_t          usec_delay_mult;
+#define USEC_DELAY_LOOP_CYCLES 3  // Sum of instruction cycles in us delay loop
 
-const uint32_t sercom_apbbase[] = {(uint32_t)SERCOM0,(uint32_t)SERCOM1,(uint32_t)SERCOM2,(uint32_t)SERCOM3,(uint32_t)SERCOM4,(uint32_t)SERCOM5};
-const uint8_t sercom_pchan[] = {7, 8, 23, 24, 34, 35};
+const uint32_t sercom_apbbase[] = {(uint32_t)SERCOM0, (uint32_t)SERCOM1, (uint32_t)SERCOM2, (uint32_t)SERCOM3, (uint32_t)SERCOM4, (uint32_t)SERCOM5};
+const uint8_t  sercom_pchan[]   = {7, 8, 23, 24, 34, 35};
 
-#define USE_DPLL_IND    0
-#define USE_DPLL_DEF    GCLK_SOURCE_DPLL0
+#define USE_DPLL_IND 0
+#define USE_DPLL_DEF GCLK_SOURCE_DPLL0
 
-void CLK_oscctrl_init(void)
-{
+void CLK_oscctrl_init(void) {
     Oscctrl *posctrl = OSCCTRL;
-    Gclk *pgclk = GCLK;
+    Gclk *   pgclk   = GCLK;
 
     DBGC(DC_CLK_OSC_INIT_BEGIN);
 
-    //default setup on por
-    system_clks.freq_dfll = FREQ_DFLL_DEFAULT;
+    // default setup on por
+    system_clks.freq_dfll    = FREQ_DFLL_DEFAULT;
     system_clks.freq_gclk[0] = system_clks.freq_dfll;
 
-    //configure and startup 16MHz xosc0
-    posctrl->XOSCCTRL[0].bit.ENABLE = 0;
-    posctrl->XOSCCTRL[0].bit.STARTUP = 0xD;
-    posctrl->XOSCCTRL[0].bit.ENALC = 1;
-    posctrl->XOSCCTRL[0].bit.IMULT = 5;
-    posctrl->XOSCCTRL[0].bit.IPTAT = 3;
+    // configure and startup 16MHz xosc0
+    posctrl->XOSCCTRL[0].bit.ENABLE   = 0;
+    posctrl->XOSCCTRL[0].bit.STARTUP  = 0xD;
+    posctrl->XOSCCTRL[0].bit.ENALC    = 1;
+    posctrl->XOSCCTRL[0].bit.IMULT    = 5;
+    posctrl->XOSCCTRL[0].bit.IPTAT    = 3;
     posctrl->XOSCCTRL[0].bit.ONDEMAND = 0;
-    posctrl->XOSCCTRL[0].bit.XTALEN = 1;
-    posctrl->XOSCCTRL[0].bit.ENABLE = 1;
-    while (posctrl->STATUS.bit.XOSCRDY0 == 0) { DBGC(DC_CLK_OSC_INIT_XOSC0_SYNC); }
+    posctrl->XOSCCTRL[0].bit.XTALEN   = 1;
+    posctrl->XOSCCTRL[0].bit.ENABLE   = 1;
+    while (posctrl->STATUS.bit.XOSCRDY0 == 0) {
+        DBGC(DC_CLK_OSC_INIT_XOSC0_SYNC);
+    }
     system_clks.freq_xosc0 = FREQ_XOSC0;
 
-    //configure and startup DPLL
+    // configure and startup DPLL
     posctrl->Dpll[USE_DPLL_IND].DPLLCTRLA.bit.ENABLE = 0;
-    while (posctrl->Dpll[USE_DPLL_IND].DPLLSYNCBUSY.bit.ENABLE) { DBGC(DC_CLK_OSC_INIT_DPLL_SYNC_DISABLE); }
-    posctrl->Dpll[USE_DPLL_IND].DPLLCTRLB.bit.REFCLK = 2;              //select XOSC0 (16MHz)
-    posctrl->Dpll[USE_DPLL_IND].DPLLCTRLB.bit.DIV = 7;                 //16 MHz / (2 * (7 + 1)) = 1 MHz
-    posctrl->Dpll[USE_DPLL_IND].DPLLRATIO.bit.LDR = PLL_RATIO;         //1 MHz * (PLL_RATIO(47) + 1) = 48MHz
-    while (posctrl->Dpll[USE_DPLL_IND].DPLLSYNCBUSY.bit.DPLLRATIO) { DBGC(DC_CLK_OSC_INIT_DPLL_SYNC_RATIO); }
+    while (posctrl->Dpll[USE_DPLL_IND].DPLLSYNCBUSY.bit.ENABLE) {
+        DBGC(DC_CLK_OSC_INIT_DPLL_SYNC_DISABLE);
+    }
+    posctrl->Dpll[USE_DPLL_IND].DPLLCTRLB.bit.REFCLK = 2;          // select XOSC0 (16MHz)
+    posctrl->Dpll[USE_DPLL_IND].DPLLCTRLB.bit.DIV    = 7;          // 16 MHz / (2 * (7 + 1)) = 1 MHz
+    posctrl->Dpll[USE_DPLL_IND].DPLLRATIO.bit.LDR    = PLL_RATIO;  // 1 MHz * (PLL_RATIO(47) + 1) = 48MHz
+    while (posctrl->Dpll[USE_DPLL_IND].DPLLSYNCBUSY.bit.DPLLRATIO) {
+        DBGC(DC_CLK_OSC_INIT_DPLL_SYNC_RATIO);
+    }
     posctrl->Dpll[USE_DPLL_IND].DPLLCTRLA.bit.ONDEMAND = 0;
-    posctrl->Dpll[USE_DPLL_IND].DPLLCTRLA.bit.ENABLE = 1;
-    while (posctrl->Dpll[USE_DPLL_IND].DPLLSYNCBUSY.bit.ENABLE) { DBGC(DC_CLK_OSC_INIT_DPLL_SYNC_ENABLE); }
-    while (posctrl->Dpll[USE_DPLL_IND].DPLLSTATUS.bit.LOCK == 0) { DBGC(DC_CLK_OSC_INIT_DPLL_WAIT_LOCK); }
-    while (posctrl->Dpll[USE_DPLL_IND].DPLLSTATUS.bit.CLKRDY == 0) { DBGC(DC_CLK_OSC_INIT_DPLL_WAIT_CLKRDY); }
+    posctrl->Dpll[USE_DPLL_IND].DPLLCTRLA.bit.ENABLE   = 1;
+    while (posctrl->Dpll[USE_DPLL_IND].DPLLSYNCBUSY.bit.ENABLE) {
+        DBGC(DC_CLK_OSC_INIT_DPLL_SYNC_ENABLE);
+    }
+    while (posctrl->Dpll[USE_DPLL_IND].DPLLSTATUS.bit.LOCK == 0) {
+        DBGC(DC_CLK_OSC_INIT_DPLL_WAIT_LOCK);
+    }
+    while (posctrl->Dpll[USE_DPLL_IND].DPLLSTATUS.bit.CLKRDY == 0) {
+        DBGC(DC_CLK_OSC_INIT_DPLL_WAIT_CLKRDY);
+    }
     system_clks.freq_dpll[0] = (system_clks.freq_xosc0 / 2 / (posctrl->Dpll[USE_DPLL_IND].DPLLCTRLB.bit.DIV + 1)) * (posctrl->Dpll[USE_DPLL_IND].DPLLRATIO.bit.LDR + 1);
 
-    //change gclk0 to DPLL
+    // change gclk0 to DPLL
     pgclk->GENCTRL[GEN_DPLL0].bit.SRC = USE_DPLL_DEF;
-    while (pgclk->SYNCBUSY.bit.GENCTRL0) { DBGC(DC_CLK_OSC_INIT_GCLK_SYNC_GENCTRL0); }
+    while (pgclk->SYNCBUSY.bit.GENCTRL0) {
+        DBGC(DC_CLK_OSC_INIT_GCLK_SYNC_GENCTRL0);
+    }
 
     system_clks.freq_gclk[0] = system_clks.freq_dpll[0];
 
     usec_delay_mult = system_clks.freq_gclk[0] / (USEC_DELAY_LOOP_CYCLES * 1000000);
-    if (usec_delay_mult < 1) usec_delay_mult = 1; //Never allow a multiplier of zero
+    if (usec_delay_mult < 1) usec_delay_mult = 1;  // Never allow a multiplier of zero
 
     DBGC(DC_CLK_OSC_INIT_COMPLETE);
 }
 
-//configure for 1MHz (1 usec timebase)
-//call CLK_set_gclk_freq(GEN_TC45, FREQ_TC45_DEFAULT);
-uint32_t CLK_set_gclk_freq(uint8_t gclkn, uint32_t freq)
-{
+// configure for 1MHz (1 usec timebase)
+// call CLK_set_gclk_freq(GEN_TC45, FREQ_TC45_DEFAULT);
+uint32_t CLK_set_gclk_freq(uint8_t gclkn, uint32_t freq) {
     Gclk *pgclk = GCLK;
 
     DBGC(DC_CLK_SET_GCLK_FREQ_BEGIN);
 
-    while (pgclk->SYNCBUSY.vec.GENCTRL) { DBGC(DC_CLK_SET_GCLK_FREQ_SYNC_1); }
+    while (pgclk->SYNCBUSY.vec.GENCTRL) {
+        DBGC(DC_CLK_SET_GCLK_FREQ_SYNC_1);
+    }
     pgclk->GENCTRL[gclkn].bit.SRC = USE_DPLL_DEF;
-    while (pgclk->SYNCBUSY.vec.GENCTRL) { DBGC(DC_CLK_SET_GCLK_FREQ_SYNC_2); }
+    while (pgclk->SYNCBUSY.vec.GENCTRL) {
+        DBGC(DC_CLK_SET_GCLK_FREQ_SYNC_2);
+    }
     pgclk->GENCTRL[gclkn].bit.DIV = (uint8_t)(system_clks.freq_dpll[0] / freq);
-    while (pgclk->SYNCBUSY.vec.GENCTRL) { DBGC(DC_CLK_SET_GCLK_FREQ_SYNC_3); }
+    while (pgclk->SYNCBUSY.vec.GENCTRL) {
+        DBGC(DC_CLK_SET_GCLK_FREQ_SYNC_3);
+    }
     pgclk->GENCTRL[gclkn].bit.DIVSEL = 0;
-    while (pgclk->SYNCBUSY.vec.GENCTRL) { DBGC(DC_CLK_SET_GCLK_FREQ_SYNC_4); }
+    while (pgclk->SYNCBUSY.vec.GENCTRL) {
+        DBGC(DC_CLK_SET_GCLK_FREQ_SYNC_4);
+    }
     pgclk->GENCTRL[gclkn].bit.GENEN = 1;
-    while (pgclk->SYNCBUSY.vec.GENCTRL) { DBGC(DC_CLK_SET_GCLK_FREQ_SYNC_5); }
+    while (pgclk->SYNCBUSY.vec.GENCTRL) {
+        DBGC(DC_CLK_SET_GCLK_FREQ_SYNC_5);
+    }
     system_clks.freq_gclk[gclkn] = system_clks.freq_dpll[0] / pgclk->GENCTRL[gclkn].bit.DIV;
 
     DBGC(DC_CLK_SET_GCLK_FREQ_COMPLETE);
@@ -103,29 +125,37 @@ uint32_t CLK_set_gclk_freq(uint8_t gclkn, uint32_t freq)
     return system_clks.freq_gclk[gclkn];
 }
 
-void CLK_init_osc(void)
-{
+void CLK_init_osc(void) {
     uint8_t gclkn = GEN_OSC0;
-    Gclk *pgclk = GCLK;
+    Gclk *  pgclk = GCLK;
 
     DBGC(DC_CLK_INIT_OSC_BEGIN);
 
-    while (pgclk->SYNCBUSY.vec.GENCTRL) { DBGC(DC_CLK_INIT_OSC_SYNC_1); }
+    while (pgclk->SYNCBUSY.vec.GENCTRL) {
+        DBGC(DC_CLK_INIT_OSC_SYNC_1);
+    }
     pgclk->GENCTRL[gclkn].bit.SRC = GCLK_SOURCE_XOSC0;
-    while (pgclk->SYNCBUSY.vec.GENCTRL) { DBGC(DC_CLK_INIT_OSC_SYNC_2); }
+    while (pgclk->SYNCBUSY.vec.GENCTRL) {
+        DBGC(DC_CLK_INIT_OSC_SYNC_2);
+    }
     pgclk->GENCTRL[gclkn].bit.DIV = 1;
-    while (pgclk->SYNCBUSY.vec.GENCTRL) { DBGC(DC_CLK_INIT_OSC_SYNC_3); }
+    while (pgclk->SYNCBUSY.vec.GENCTRL) {
+        DBGC(DC_CLK_INIT_OSC_SYNC_3);
+    }
     pgclk->GENCTRL[gclkn].bit.DIVSEL = 0;
-    while (pgclk->SYNCBUSY.vec.GENCTRL) { DBGC(DC_CLK_INIT_OSC_SYNC_4); }
+    while (pgclk->SYNCBUSY.vec.GENCTRL) {
+        DBGC(DC_CLK_INIT_OSC_SYNC_4);
+    }
     pgclk->GENCTRL[gclkn].bit.GENEN = 1;
-    while (pgclk->SYNCBUSY.vec.GENCTRL) { DBGC(DC_CLK_INIT_OSC_SYNC_5); }
+    while (pgclk->SYNCBUSY.vec.GENCTRL) {
+        DBGC(DC_CLK_INIT_OSC_SYNC_5);
+    }
     system_clks.freq_gclk[gclkn] = system_clks.freq_xosc0;
 
     DBGC(DC_CLK_INIT_OSC_COMPLETE);
 }
 
-void CLK_reset_time(void)
-{
+void CLK_reset_time(void) {
     Tc *ptc4 = TC4;
     Tc *ptc0 = TC0;
 
@@ -133,72 +163,85 @@ void CLK_reset_time(void)
 
     DBGC(DC_CLK_RESET_TIME_BEGIN);
 
-    //stop counters
+    // stop counters
     ptc4->COUNT16.CTRLA.bit.ENABLE = 0;
-    while (ptc4->COUNT16.SYNCBUSY.bit.ENABLE) {}
+    while (ptc4->COUNT16.SYNCBUSY.bit.ENABLE) {
+    }
     ptc0->COUNT32.CTRLA.bit.ENABLE = 0;
-    while (ptc0->COUNT32.SYNCBUSY.bit.ENABLE) {}
-    //zero counters
+    while (ptc0->COUNT32.SYNCBUSY.bit.ENABLE) {
+    }
+    // zero counters
     ptc4->COUNT16.COUNT.reg = 0;
-    while (ptc4->COUNT16.SYNCBUSY.bit.COUNT) {}
+    while (ptc4->COUNT16.SYNCBUSY.bit.COUNT) {
+    }
     ptc0->COUNT32.COUNT.reg = 0;
-    while (ptc0->COUNT32.SYNCBUSY.bit.COUNT) {}
-    //start counters
+    while (ptc0->COUNT32.SYNCBUSY.bit.COUNT) {
+    }
+    // start counters
     ptc0->COUNT32.CTRLA.bit.ENABLE = 1;
-    while (ptc0->COUNT32.SYNCBUSY.bit.ENABLE) {}
+    while (ptc0->COUNT32.SYNCBUSY.bit.ENABLE) {
+    }
     ptc4->COUNT16.CTRLA.bit.ENABLE = 1;
-    while (ptc4->COUNT16.SYNCBUSY.bit.ENABLE) {}
+    while (ptc4->COUNT16.SYNCBUSY.bit.ENABLE) {
+    }
 
     DBGC(DC_CLK_RESET_TIME_COMPLETE);
 }
 
-void TC4_Handler()
-{
-    if (TC4->COUNT16.INTFLAG.bit.MC0)
-    {
+void TC4_Handler() {
+    if (TC4->COUNT16.INTFLAG.bit.MC0) {
         TC4->COUNT16.INTFLAG.reg = TC_INTENCLR_MC0;
         ms_clk++;
     }
 }
 
-uint32_t CLK_enable_timebase(void)
-{
-    Gclk *pgclk = GCLK;
-    Mclk *pmclk = MCLK;
-    Tc *ptc4 = TC4;
-    Tc *ptc0 = TC0;
+uint32_t CLK_enable_timebase(void) {
+    Gclk * pgclk  = GCLK;
+    Mclk * pmclk  = MCLK;
+    Tc *   ptc4   = TC4;
+    Tc *   ptc0   = TC0;
     Evsys *pevsys = EVSYS;
 
     DBGC(DC_CLK_ENABLE_TIMEBASE_BEGIN);
 
-    //gclk2  highspeed time base
+    // gclk2  highspeed time base
     CLK_set_gclk_freq(GEN_TC45, FREQ_TC45_DEFAULT);
     CLK_init_osc();
 
-    //unmask TC4, sourcegclk2 to TC4
-    pmclk->APBCMASK.bit.TC4_ = 1;
-    pgclk->PCHCTRL[TC4_GCLK_ID].bit.GEN = GEN_TC45;
+    // unmask TC4, sourcegclk2 to TC4
+    pmclk->APBCMASK.bit.TC4_             = 1;
+    pgclk->PCHCTRL[TC4_GCLK_ID].bit.GEN  = GEN_TC45;
     pgclk->PCHCTRL[TC4_GCLK_ID].bit.CHEN = 1;
 
-    //configure TC4
+    // configure TC4
     DBGC(DC_CLK_ENABLE_TIMEBASE_TC4_BEGIN);
     ptc4->COUNT16.CTRLA.bit.ENABLE = 0;
-    while (ptc4->COUNT16.SYNCBUSY.bit.ENABLE) { DBGC(DC_CLK_ENABLE_TIMEBASE_TC4_SYNC_DISABLE); }
+    while (ptc4->COUNT16.SYNCBUSY.bit.ENABLE) {
+        DBGC(DC_CLK_ENABLE_TIMEBASE_TC4_SYNC_DISABLE);
+    }
     ptc4->COUNT16.CTRLA.bit.SWRST = 1;
-    while (ptc4->COUNT16.SYNCBUSY.bit.SWRST) { DBGC(DC_CLK_ENABLE_TIMEBASE_TC4_SYNC_SWRST_1); }
-    while (ptc4->COUNT16.CTRLA.bit.SWRST) { DBGC(DC_CLK_ENABLE_TIMEBASE_TC4_SYNC_SWRST_2); }
+    while (ptc4->COUNT16.SYNCBUSY.bit.SWRST) {
+        DBGC(DC_CLK_ENABLE_TIMEBASE_TC4_SYNC_SWRST_1);
+    }
+    while (ptc4->COUNT16.CTRLA.bit.SWRST) {
+        DBGC(DC_CLK_ENABLE_TIMEBASE_TC4_SYNC_SWRST_2);
+    }
 
-    //CTRLA defaults
-    //CTRLB as default, counting up
+    // CTRLA defaults
+    // CTRLB as default, counting up
     ptc4->COUNT16.CTRLBCLR.reg = 5;
-    while (ptc4->COUNT16.SYNCBUSY.bit.CTRLB) { DBGC(DC_CLK_ENABLE_TIMEBASE_TC4_SYNC_CLTRB); }
+    while (ptc4->COUNT16.SYNCBUSY.bit.CTRLB) {
+        DBGC(DC_CLK_ENABLE_TIMEBASE_TC4_SYNC_CLTRB);
+    }
     ptc4->COUNT16.CC[0].reg = 999;
-    while (ptc4->COUNT16.SYNCBUSY.bit.CC0) { DBGC(DC_CLK_ENABLE_TIMEBASE_TC4_SYNC_CC0); }
-    //ptc4->COUNT16.DBGCTRL.bit.DBGRUN = 1;
+    while (ptc4->COUNT16.SYNCBUSY.bit.CC0) {
+        DBGC(DC_CLK_ENABLE_TIMEBASE_TC4_SYNC_CC0);
+    }
+    // ptc4->COUNT16.DBGCTRL.bit.DBGRUN = 1;
 
-    //wave mode
-    ptc4->COUNT16.WAVE.bit.WAVEGEN = 1; //MFRQ match frequency mode, toggle each CC match
-    //generate event for next stage
+    // wave mode
+    ptc4->COUNT16.WAVE.bit.WAVEGEN = 1;  // MFRQ match frequency mode, toggle each CC match
+    // generate event for next stage
     ptc4->COUNT16.EVCTRL.bit.MCEO0 = 1;
 
     NVIC_EnableIRQ(TC4_IRQn);
@@ -206,39 +249,45 @@ uint32_t CLK_enable_timebase(void)
 
     DBGC(DC_CLK_ENABLE_TIMEBASE_TC4_COMPLETE);
 
-    //unmask TC0,1, sourcegclk2 to TC0,1
-    pmclk->APBAMASK.bit.TC0_ = 1;
-    pgclk->PCHCTRL[TC0_GCLK_ID].bit.GEN = GEN_TC45;
+    // unmask TC0,1, sourcegclk2 to TC0,1
+    pmclk->APBAMASK.bit.TC0_             = 1;
+    pgclk->PCHCTRL[TC0_GCLK_ID].bit.GEN  = GEN_TC45;
     pgclk->PCHCTRL[TC0_GCLK_ID].bit.CHEN = 1;
 
-    pmclk->APBAMASK.bit.TC1_ = 1;
-    pgclk->PCHCTRL[TC1_GCLK_ID].bit.GEN = GEN_TC45;
+    pmclk->APBAMASK.bit.TC1_             = 1;
+    pgclk->PCHCTRL[TC1_GCLK_ID].bit.GEN  = GEN_TC45;
     pgclk->PCHCTRL[TC1_GCLK_ID].bit.CHEN = 1;
 
-    //configure TC0
+    // configure TC0
     DBGC(DC_CLK_ENABLE_TIMEBASE_TC0_BEGIN);
     ptc0->COUNT32.CTRLA.bit.ENABLE = 0;
-    while (ptc0->COUNT32.SYNCBUSY.bit.ENABLE) { DBGC(DC_CLK_ENABLE_TIMEBASE_TC0_SYNC_DISABLE); }
+    while (ptc0->COUNT32.SYNCBUSY.bit.ENABLE) {
+        DBGC(DC_CLK_ENABLE_TIMEBASE_TC0_SYNC_DISABLE);
+    }
     ptc0->COUNT32.CTRLA.bit.SWRST = 1;
-    while (ptc0->COUNT32.SYNCBUSY.bit.SWRST) { DBGC(DC_CLK_ENABLE_TIMEBASE_TC0_SYNC_SWRST_1); }
-    while (ptc0->COUNT32.CTRLA.bit.SWRST) { DBGC(DC_CLK_ENABLE_TIMEBASE_TC0_SYNC_SWRST_2); }
-    //CTRLA as default
-    ptc0->COUNT32.CTRLA.bit.MODE = 2; //32 bit mode
-    ptc0->COUNT32.EVCTRL.bit.TCEI = 1; //enable incoming events
-    ptc0->COUNT32.EVCTRL.bit.EVACT = 2 ; //count events
+    while (ptc0->COUNT32.SYNCBUSY.bit.SWRST) {
+        DBGC(DC_CLK_ENABLE_TIMEBASE_TC0_SYNC_SWRST_1);
+    }
+    while (ptc0->COUNT32.CTRLA.bit.SWRST) {
+        DBGC(DC_CLK_ENABLE_TIMEBASE_TC0_SYNC_SWRST_2);
+    }
+    // CTRLA as default
+    ptc0->COUNT32.CTRLA.bit.MODE   = 2;  // 32 bit mode
+    ptc0->COUNT32.EVCTRL.bit.TCEI  = 1;  // enable incoming events
+    ptc0->COUNT32.EVCTRL.bit.EVACT = 2;  // count events
 
     DBGC(DC_CLK_ENABLE_TIMEBASE_TC0_COMPLETE);
 
     DBGC(DC_CLK_ENABLE_TIMEBASE_EVSYS_BEGIN);
 
-    //configure event system
-    pmclk->APBBMASK.bit.EVSYS_ = 1;
-    pgclk->PCHCTRL[EVSYS_GCLK_ID_0].bit.GEN = GEN_TC45;
+    // configure event system
+    pmclk->APBBMASK.bit.EVSYS_               = 1;
+    pgclk->PCHCTRL[EVSYS_GCLK_ID_0].bit.GEN  = GEN_TC45;
     pgclk->PCHCTRL[EVSYS_GCLK_ID_0].bit.CHEN = 1;
-    pevsys->USER[44].reg = EVSYS_ID_USER_PORT_EV_0;                               //TC0 will get event channel 0
-    pevsys->Channel[0].CHANNEL.bit.EDGSEL = EVSYS_CHANNEL_EDGSEL_RISING_EDGE_Val; //Rising edge
-    pevsys->Channel[0].CHANNEL.bit.PATH = EVSYS_CHANNEL_PATH_SYNCHRONOUS_Val;     //Synchronous
-    pevsys->Channel[0].CHANNEL.bit.EVGEN = EVSYS_ID_GEN_TC4_MCX_0;                //TC4 MC0
+    pevsys->USER[44].reg                     = EVSYS_ID_USER_PORT_EV_0;               // TC0 will get event channel 0
+    pevsys->Channel[0].CHANNEL.bit.EDGSEL    = EVSYS_CHANNEL_EDGSEL_RISING_EDGE_Val;  // Rising edge
+    pevsys->Channel[0].CHANNEL.bit.PATH      = EVSYS_CHANNEL_PATH_SYNCHRONOUS_Val;    // Synchronous
+    pevsys->Channel[0].CHANNEL.bit.EVGEN     = EVSYS_ID_GEN_TC4_MCX_0;                // TC4 MC0
 
     DBGC(DC_CLK_ENABLE_TIMEBASE_EVSYS_COMPLETE);
 
@@ -251,34 +300,29 @@ uint32_t CLK_enable_timebase(void)
     return 0;
 }
 
-void CLK_delay_us(uint32_t usec)
-{
-    asm (
-        "CBZ R0, return\n\t"        //If usec == 0, branch to return label
+void CLK_delay_us(uint32_t usec) {
+    asm("CBZ R0, return\n\t"  // If usec == 0, branch to return label
     );
-    asm (
-        "MULS R0, %0\n\t"           //Multiply R0(usec) by usec_delay_mult and store in R0
-        ".balign 16\n\t"            //Ensure loop is aligned for fastest performance
-        "loop: SUBS R0, #1\n\t"     //Subtract 1 from R0 and update flags (1 cycle)
-        "BNE loop\n\t"              //Branch if non-zero to loop label (2 cycles)  NOTE: USEC_DELAY_LOOP_CYCLES is the sum of loop cycles
-        "return:\n\t"               //Return label
-        : //No output registers
-        : "r" (usec_delay_mult)     //For %0
+    asm("MULS R0, %0\n\t"        // Multiply R0(usec) by usec_delay_mult and store in R0
+        ".balign 16\n\t"         // Ensure loop is aligned for fastest performance
+        "loop: SUBS R0, #1\n\t"  // Subtract 1 from R0 and update flags (1 cycle)
+        "BNE loop\n\t"           // Branch if non-zero to loop label (2 cycles)  NOTE: USEC_DELAY_LOOP_CYCLES is the sum of loop cycles
+        "return:\n\t"            // Return label
+        :                        // No output registers
+        : "r"(usec_delay_mult)   // For %0
     );
-    //Note: BX LR generated
+    // Note: BX LR generated
 }
 
-void CLK_delay_ms(uint64_t msec)
-{
+void CLK_delay_ms(uint64_t msec) {
     msec += timer_read64();
-    while (msec > timer_read64()) {}
+    while (msec > timer_read64()) {
+    }
 }
 
-void clk_enable_sercom_apbmask(int sercomn)
-{
+void clk_enable_sercom_apbmask(int sercomn) {
     Mclk *pmclk = MCLK;
-    switch (sercomn)
-    {
+    switch (sercomn) {
         case 0:
             pmclk->APBAMASK.bit.SERCOM0_ = 1;
             break;
@@ -296,26 +340,27 @@ void clk_enable_sercom_apbmask(int sercomn)
     }
 }
 
-//call CLK_oscctrl_init first
-//call CLK_set_spi_freq(CHAN_SERCOM_SPI, FREQ_SPI_DEFAULT);
-uint32_t CLK_set_spi_freq(uint8_t sercomn, uint32_t freq)
-{
+// call CLK_oscctrl_init first
+// call CLK_set_spi_freq(CHAN_SERCOM_SPI, FREQ_SPI_DEFAULT);
+uint32_t CLK_set_spi_freq(uint8_t sercomn, uint32_t freq) {
     DBGC(DC_CLK_SET_SPI_FREQ_BEGIN);
 
-    Gclk *pgclk = GCLK;
+    Gclk *  pgclk   = GCLK;
     Sercom *psercom = (Sercom *)sercom_apbbase[sercomn];
     clk_enable_sercom_apbmask(sercomn);
 
-    //all gclk0 for now
-    pgclk->PCHCTRL[sercom_pchan[sercomn]].bit.GEN = 0;
+    // all gclk0 for now
+    pgclk->PCHCTRL[sercom_pchan[sercomn]].bit.GEN  = 0;
     pgclk->PCHCTRL[sercom_pchan[sercomn]].bit.CHEN = 1;
 
     psercom->I2CM.CTRLA.bit.SWRST = 1;
-    while (psercom->I2CM.SYNCBUSY.bit.SWRST) {}
-    while (psercom->I2CM.CTRLA.bit.SWRST) {}
+    while (psercom->I2CM.SYNCBUSY.bit.SWRST) {
+    }
+    while (psercom->I2CM.CTRLA.bit.SWRST) {
+    }
 
-    psercom->SPI.BAUD.reg = (uint8_t) (system_clks.freq_gclk[0]/2/freq-1);
-    system_clks.freq_spi = system_clks.freq_gclk[0]/2/(psercom->SPI.BAUD.reg+1);
+    psercom->SPI.BAUD.reg            = (uint8_t)(system_clks.freq_gclk[0] / 2 / freq - 1);
+    system_clks.freq_spi             = system_clks.freq_gclk[0] / 2 / (psercom->SPI.BAUD.reg + 1);
     system_clks.freq_sercom[sercomn] = system_clks.freq_spi;
 
     DBGC(DC_CLK_SET_SPI_FREQ_COMPLETE);
@@ -323,26 +368,27 @@ uint32_t CLK_set_spi_freq(uint8_t sercomn, uint32_t freq)
     return system_clks.freq_spi;
 }
 
-//call CLK_oscctrl_init first
-//call CLK_set_i2c0_freq(CHAN_SERCOM_I2C0, FREQ_I2C0_DEFAULT);
-uint32_t CLK_set_i2c0_freq(uint8_t sercomn, uint32_t freq)
-{
+// call CLK_oscctrl_init first
+// call CLK_set_i2c0_freq(CHAN_SERCOM_I2C0, FREQ_I2C0_DEFAULT);
+uint32_t CLK_set_i2c0_freq(uint8_t sercomn, uint32_t freq) {
     DBGC(DC_CLK_SET_I2C0_FREQ_BEGIN);
 
-    Gclk *pgclk = GCLK;
+    Gclk *  pgclk   = GCLK;
     Sercom *psercom = (Sercom *)sercom_apbbase[sercomn];
     clk_enable_sercom_apbmask(sercomn);
 
-    //all gclk0 for now
-    pgclk->PCHCTRL[sercom_pchan[sercomn]].bit.GEN = 0;
+    // all gclk0 for now
+    pgclk->PCHCTRL[sercom_pchan[sercomn]].bit.GEN  = 0;
     pgclk->PCHCTRL[sercom_pchan[sercomn]].bit.CHEN = 1;
 
     psercom->I2CM.CTRLA.bit.SWRST = 1;
-    while (psercom->I2CM.SYNCBUSY.bit.SWRST) {}
-    while (psercom->I2CM.CTRLA.bit.SWRST) {}
+    while (psercom->I2CM.SYNCBUSY.bit.SWRST) {
+    }
+    while (psercom->I2CM.CTRLA.bit.SWRST) {
+    }
 
-    psercom->I2CM.BAUD.bit.BAUD = (uint8_t) (system_clks.freq_gclk[0]/2/freq-1);
-    system_clks.freq_i2c0 = system_clks.freq_gclk[0]/2/(psercom->I2CM.BAUD.bit.BAUD+1);
+    psercom->I2CM.BAUD.bit.BAUD      = (uint8_t)(system_clks.freq_gclk[0] / 2 / freq - 1);
+    system_clks.freq_i2c0            = system_clks.freq_gclk[0] / 2 / (psercom->I2CM.BAUD.bit.BAUD + 1);
     system_clks.freq_sercom[sercomn] = system_clks.freq_i2c0;
 
     DBGC(DC_CLK_SET_I2C0_FREQ_COMPLETE);
@@ -350,26 +396,27 @@ uint32_t CLK_set_i2c0_freq(uint8_t sercomn, uint32_t freq)
     return system_clks.freq_i2c0;
 }
 
-//call CLK_oscctrl_init first
-//call CLK_set_i2c1_freq(CHAN_SERCOM_I2C1, FREQ_I2C1_DEFAULT);
-uint32_t CLK_set_i2c1_freq(uint8_t sercomn, uint32_t freq)
-{
+// call CLK_oscctrl_init first
+// call CLK_set_i2c1_freq(CHAN_SERCOM_I2C1, FREQ_I2C1_DEFAULT);
+uint32_t CLK_set_i2c1_freq(uint8_t sercomn, uint32_t freq) {
     DBGC(DC_CLK_SET_I2C1_FREQ_BEGIN);
 
-    Gclk *pgclk = GCLK;
+    Gclk *  pgclk   = GCLK;
     Sercom *psercom = (Sercom *)sercom_apbbase[sercomn];
     clk_enable_sercom_apbmask(sercomn);
 
-    //all gclk0 for now
-    pgclk->PCHCTRL[sercom_pchan[sercomn]].bit.GEN = 0;
+    // all gclk0 for now
+    pgclk->PCHCTRL[sercom_pchan[sercomn]].bit.GEN  = 0;
     pgclk->PCHCTRL[sercom_pchan[sercomn]].bit.CHEN = 1;
 
     psercom->I2CM.CTRLA.bit.SWRST = 1;
-    while (psercom->I2CM.SYNCBUSY.bit.SWRST) {}
-    while (psercom->I2CM.CTRLA.bit.SWRST) {}
+    while (psercom->I2CM.SYNCBUSY.bit.SWRST) {
+    }
+    while (psercom->I2CM.CTRLA.bit.SWRST) {
+    }
 
-    psercom->I2CM.BAUD.bit.BAUD = (uint8_t) (system_clks.freq_gclk[0]/2/freq-10);
-    system_clks.freq_i2c1 = system_clks.freq_gclk[0]/2/(psercom->I2CM.BAUD.bit.BAUD+10);
+    psercom->I2CM.BAUD.bit.BAUD      = (uint8_t)(system_clks.freq_gclk[0] / 2 / freq - 10);
+    system_clks.freq_i2c1            = system_clks.freq_gclk[0] / 2 / (psercom->I2CM.BAUD.bit.BAUD + 10);
     system_clks.freq_sercom[sercomn] = system_clks.freq_i2c1;
 
     DBGC(DC_CLK_SET_I2C1_FREQ_COMPLETE);
@@ -377,15 +424,13 @@ uint32_t CLK_set_i2c1_freq(uint8_t sercomn, uint32_t freq)
     return system_clks.freq_i2c1;
 }
 
-void CLK_init(void)
-{
+void CLK_init(void) {
     DBGC(DC_CLK_INIT_BEGIN);
 
-    memset((void *)&system_clks,0,sizeof(system_clks));
+    memset((void *)&system_clks, 0, sizeof(system_clks));
 
     CLK_oscctrl_init();
     CLK_enable_timebase();
 
     DBGC(DC_CLK_INIT_COMPLETE);
 }
-
diff --git a/tmk_core/protocol/arm_atsam/clks.h b/tmk_core/protocol/arm_atsam/clks.h
index 1b01a1764..72df3a8e3 100644
--- a/tmk_core/protocol/arm_atsam/clks.h
+++ b/tmk_core/protocol/arm_atsam/clks.h
@@ -20,20 +20,20 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 #ifndef MD_BOOTLOADER
 
-//From keyboard
-#include "config_led.h"
-#include "config.h"
+// From keyboard
+#    include "config_led.h"
+#    include "config.h"
 
-#endif //MD_BOOTLOADER
+#endif  // MD_BOOTLOADER
 
-#define PLL_RATIO                   47  //mcu frequency ((X+1)MHz)
-#define FREQ_DFLL_DEFAULT     48000000  //DFLL frequency / usb clock
-#define FREQ_SPI_DEFAULT       1000000  //spi to 595 shift regs
-#define FREQ_I2C0_DEFAULT       100000  //i2c to hub
-#define FREQ_I2C1_DEFAULT       I2C_HZ  //i2c to LED drivers
-#define FREQ_TC45_DEFAULT      1000000  //1 usec resolution
+#define PLL_RATIO 47                // mcu frequency ((X+1)MHz)
+#define FREQ_DFLL_DEFAULT 48000000  // DFLL frequency / usb clock
+#define FREQ_SPI_DEFAULT 1000000    // spi to 595 shift regs
+#define FREQ_I2C0_DEFAULT 100000    // i2c to hub
+#define FREQ_I2C1_DEFAULT I2C_HZ    // i2c to LED drivers
+#define FREQ_TC45_DEFAULT 1000000   // 1 usec resolution
 
-//I2C1 Set      ~Result     PWM Time (2x Drivers)
+// I2C1 Set      ~Result     PWM Time (2x Drivers)
 //     1000000  1090000
 //     900000   1000000     3.82ms
 //     800000   860000
@@ -42,20 +42,20 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 //     580000   615000      6.08ms
 //     500000   522000
 
-#define FREQ_XOSC0            16000000
+#define FREQ_XOSC0 16000000
 
-#define CHAN_SERCOM_SPI   2 //shift regs
-#define CHAN_SERCOM_I2C0  0 //hub
-#define CHAN_SERCOM_I2C1  1 //led drivers
-#define CHAN_SERCOM_UART  3 //debug util
+#define CHAN_SERCOM_SPI 2   // shift regs
+#define CHAN_SERCOM_I2C0 0  // hub
+#define CHAN_SERCOM_I2C1 1  // led drivers
+#define CHAN_SERCOM_UART 3  // debug util
 
-//Generator clock channels
-#define GEN_DPLL0   0
-#define GEN_OSC0    1
-#define GEN_TC45    2
+// Generator clock channels
+#define GEN_DPLL0 0
+#define GEN_OSC0 1
+#define GEN_TC45 2
 
 #define SERCOM_COUNT 5
-#define GCLK_COUNT  12
+#define GCLK_COUNT 12
 
 typedef struct clk_s {
     uint32_t freq_dfll;
@@ -70,20 +70,20 @@ typedef struct clk_s {
     uint32_t freq_adc0;
 } clk_t;
 
-extern volatile clk_t system_clks;
+extern volatile clk_t    system_clks;
 extern volatile uint64_t ms_clk;
 
-void CLK_oscctrl_init(void);
-void CLK_reset_time(void);
+void     CLK_oscctrl_init(void);
+void     CLK_reset_time(void);
 uint32_t CLK_set_gclk_freq(uint8_t gclkn, uint32_t freq);
 uint32_t CLK_enable_timebase(void);
 uint64_t timer_read64(void);
-void CLK_delay_us(uint32_t usec);
-void CLK_delay_ms(uint64_t msec);
+void     CLK_delay_us(uint32_t usec);
+void     CLK_delay_ms(uint64_t msec);
 
 uint32_t CLK_set_spi_freq(uint8_t sercomn, uint32_t freq);
 uint32_t CLK_set_i2c0_freq(uint8_t sercomn, uint32_t freq);
 uint32_t CLK_set_i2c1_freq(uint8_t sercomn, uint32_t freq);
-void CLK_init(void);
+void     CLK_init(void);
 
-#endif // _CLKS_H_
+#endif  // _CLKS_H_
diff --git a/tmk_core/protocol/arm_atsam/d51_util.c b/tmk_core/protocol/arm_atsam/d51_util.c
index ea4225857..df596f7ba 100644
--- a/tmk_core/protocol/arm_atsam/d51_util.c
+++ b/tmk_core/protocol/arm_atsam/d51_util.c
@@ -1,46 +1,50 @@
 #include "d51_util.h"
 
 static volatile uint32_t w;
-    
-//Display unsigned 32-bit number by port toggling DBG_1 (to view on a scope)
-//Read as follows: 1230 = |    | |    | | |    ||  (note zero is fast double toggle)
+
+// Display unsigned 32-bit number by port toggling DBG_1 (to view on a scope)
+// Read as follows: 1230 = |    | |    | | |    ||  (note zero is fast double toggle)
 #define DBG_PAUSE 5
-void dbg_print(uint32_t x)
-{
-    int8_t t;
+void dbg_print(uint32_t x) {
+    int8_t   t;
     uint32_t n;
     uint32_t p, p2;
 
-    if      (x < 10) t = 0;
-    else if (x < 100) t = 1;
-    else if (x < 1000) t = 2;
-    else if (x < 10000) t = 3;
-    else if (x < 100000) t = 4;
-    else if (x < 1000000) t = 5;
-    else if (x < 10000000) t = 6;
-    else if (x < 100000000) t = 7;
-    else if (x < 1000000000) t = 8;
-    else t = 9;
-
-    while (t >= 0)
-    {
+    if (x < 10)
+        t = 0;
+    else if (x < 100)
+        t = 1;
+    else if (x < 1000)
+        t = 2;
+    else if (x < 10000)
+        t = 3;
+    else if (x < 100000)
+        t = 4;
+    else if (x < 1000000)
+        t = 5;
+    else if (x < 10000000)
+        t = 6;
+    else if (x < 100000000)
+        t = 7;
+    else if (x < 1000000000)
+        t = 8;
+    else
+        t = 9;
+
+    while (t >= 0) {
         p2 = t;
-        p = 1;
+        p  = 1;
         while (p2--) p *= 10;
         n = x / p;
         x -= n * p;
-        if (!n)
-        {
+        if (!n) {
             DBG_1_ON;
             DBG_1_OFF;
             DBG_1_ON;
             DBG_1_OFF;
             n--;
-        }
-        else
-        {
-            while (n > 0)
-            {
+        } else {
+            while (n > 0) {
                 DBG_1_ON;
                 DBG_1_OFF;
                 n--;
@@ -50,68 +54,80 @@ void dbg_print(uint32_t x)
         t--;
     }
 
-    for (w = DBG_PAUSE; w; w--); //Long pause after number is complete
+    for (w = DBG_PAUSE; w; w--)
+        ;  // Long pause after number is complete
 }
 
-//Display unsigned 32-bit number through debug led
-//Read as follows: 1230 = [*]  [* *]  [* * *]  [**]  (note zero is fast double flash)
+// Display unsigned 32-bit number through debug led
+// Read as follows: 1230 = [*]  [* *]  [* * *]  [**]  (note zero is fast double flash)
 #define DLED_ONTIME 1000000
 #define DLED_PAUSE 1500000
-void dled_print(uint32_t x, uint8_t long_pause)
-{
-    int8_t t;
+void dled_print(uint32_t x, uint8_t long_pause) {
+    int8_t   t;
     uint32_t n;
     uint32_t p, p2;
 
-    if      (x < 10) t = 0;
-    else if (x < 100) t = 1;
-    else if (x < 1000) t = 2;
-    else if (x < 10000) t = 3;
-    else if (x < 100000) t = 4;
-    else if (x < 1000000) t = 5;
-    else if (x < 10000000) t = 6;
-    else if (x < 100000000) t = 7;
-    else if (x < 1000000000) t = 8;
-    else t = 9;
-
-    while (t >= 0)
-    {
+    if (x < 10)
+        t = 0;
+    else if (x < 100)
+        t = 1;
+    else if (x < 1000)
+        t = 2;
+    else if (x < 10000)
+        t = 3;
+    else if (x < 100000)
+        t = 4;
+    else if (x < 1000000)
+        t = 5;
+    else if (x < 10000000)
+        t = 6;
+    else if (x < 100000000)
+        t = 7;
+    else if (x < 1000000000)
+        t = 8;
+    else
+        t = 9;
+
+    while (t >= 0) {
         p2 = t;
-        p = 1;
+        p  = 1;
         while (p2--) p *= 10;
         n = x / p;
         x -= n * p;
-        if (!n)
-        {
+        if (!n) {
             DBG_LED_ON;
-            for (w = DLED_ONTIME / 4; w; w--);
+            for (w = DLED_ONTIME / 4; w; w--)
+                ;
             DBG_LED_OFF;
-            for (w = DLED_ONTIME / 4; w; w--);
+            for (w = DLED_ONTIME / 4; w; w--)
+                ;
             DBG_LED_ON;
-            for (w = DLED_ONTIME / 4; w; w--);
+            for (w = DLED_ONTIME / 4; w; w--)
+                ;
             DBG_LED_OFF;
-            for (w = DLED_ONTIME / 4; w; w--);
+            for (w = DLED_ONTIME / 4; w; w--)
+                ;
             n--;
-        }
-        else
-        {
-            while (n > 0)
-            {
+        } else {
+            while (n > 0) {
                 DBG_LED_ON;
-                for (w = DLED_ONTIME; w; w--);
+                for (w = DLED_ONTIME; w; w--)
+                    ;
                 DBG_LED_OFF;
-                for (w = DLED_ONTIME / 2; w; w--);
+                for (w = DLED_ONTIME / 2; w; w--)
+                    ;
                 n--;
             }
         }
 
-        for (w = DLED_PAUSE; w; w--);
+        for (w = DLED_PAUSE; w; w--)
+            ;
         t--;
     }
 
-    if (long_pause)
-    {
-        for (w = DLED_PAUSE * 4; w; w--);
+    if (long_pause) {
+        for (w = DLED_PAUSE * 4; w; w--)
+            ;
     }
 }
 
@@ -119,103 +135,102 @@ void dled_print(uint32_t x, uint8_t long_pause)
 
 volatile uint32_t debug_code;
 
-//These macros are for compile time substitution
-#define DEBUG_BOOT_TRACING_EXTINTn (DEBUG_BOOT_TRACING_PIN % _U_(0x10))
-#define DEBUG_BOOT_TRACING_EXTINTb (_U_(0x1) << DEBUG_BOOT_TRACING_EXTINTn)
-#define DEBUG_BOOT_TRACING_CONFIG_INDn (DEBUG_BOOT_TRACING_EXTINTn / _U_(0x8))
-#define DEBUG_BOOT_TRACING_CONFIG_SENSEn (DEBUG_BOOT_TRACING_EXTINTn % _U_(0x8))
-#define DEBUG_BOOT_TRACING_CONFIG_SENSEb (DEBUG_BOOT_TRACING_CONFIG_SENSEn * _U_(0x4))
-#define DEBUG_BOOT_TRACING_IRQn (EIC_0_IRQn + DEBUG_BOOT_TRACING_EXTINTn)
-
-//These macros perform PORT+PIN definition translation to IRQn in the preprocessor
-#define PORTPIN_TO_IRQn_EXPAND(def) def
-#define PORTPIN_TO_IRQn_DEF(def) PORTPIN_TO_IRQn_EXPAND(def)
-#if DEBUG_BOOT_TRACING_PIN < 10
-#define PORTPIN_TO_IRQn_TODEF(port, pin) PORTPIN_TO_IRQn_DEF(PIN_ ## port ## 0 ## pin ## A_EIC_EXTINT_NUM)
-#else
-#define PORTPIN_TO_IRQn_TODEF(port, pin) PORTPIN_TO_IRQn_DEF(PIN_ ## port ## pin ## A_EIC_EXTINT_NUM)
-#endif
-#define PORTPIN_TO_IRQn(port, pin) PORTPIN_TO_IRQn_TODEF(port, pin)
-
-//These macros perform function name output in the preprocessor
-#define DEBUG_BOOT_TRACING_HANDLER_CONCAT(irq) void EIC_ ## irq ## _Handler(void)
-#define DEBUG_BOOT_TRACING_HANDLER(irq) DEBUG_BOOT_TRACING_HANDLER_CONCAT(irq)
-
-//To generate the function name of the IRQ handler catching boot tracing,
+// These macros are for compile time substitution
+#    define DEBUG_BOOT_TRACING_EXTINTn (DEBUG_BOOT_TRACING_PIN % _U_(0x10))
+#    define DEBUG_BOOT_TRACING_EXTINTb (_U_(0x1) << DEBUG_BOOT_TRACING_EXTINTn)
+#    define DEBUG_BOOT_TRACING_CONFIG_INDn (DEBUG_BOOT_TRACING_EXTINTn / _U_(0x8))
+#    define DEBUG_BOOT_TRACING_CONFIG_SENSEn (DEBUG_BOOT_TRACING_EXTINTn % _U_(0x8))
+#    define DEBUG_BOOT_TRACING_CONFIG_SENSEb (DEBUG_BOOT_TRACING_CONFIG_SENSEn * _U_(0x4))
+#    define DEBUG_BOOT_TRACING_IRQn (EIC_0_IRQn + DEBUG_BOOT_TRACING_EXTINTn)
+
+// These macros perform PORT+PIN definition translation to IRQn in the preprocessor
+#    define PORTPIN_TO_IRQn_EXPAND(def) def
+#    define PORTPIN_TO_IRQn_DEF(def) PORTPIN_TO_IRQn_EXPAND(def)
+#    if DEBUG_BOOT_TRACING_PIN < 10
+#        define PORTPIN_TO_IRQn_TODEF(port, pin) PORTPIN_TO_IRQn_DEF(PIN_##port##0##pin##A_EIC_EXTINT_NUM)
+#    else
+#        define PORTPIN_TO_IRQn_TODEF(port, pin) PORTPIN_TO_IRQn_DEF(PIN_##port##pin##A_EIC_EXTINT_NUM)
+#    endif
+#    define PORTPIN_TO_IRQn(port, pin) PORTPIN_TO_IRQn_TODEF(port, pin)
+
+// These macros perform function name output in the preprocessor
+#    define DEBUG_BOOT_TRACING_HANDLER_CONCAT(irq) void EIC_##irq##_Handler(void)
+#    define DEBUG_BOOT_TRACING_HANDLER(irq) DEBUG_BOOT_TRACING_HANDLER_CONCAT(irq)
+
+// To generate the function name of the IRQ handler catching boot tracing,
 //  certain macros must be undefined, so save their current values to macro stack
-#pragma push_macro("PA")
-#pragma push_macro("PB")
-#pragma push_macro("_L_")
-
-//Undefine / redefine pushed macros
-#undef PA
-#undef PB
-#undef _L_
-#define _L_(x) x
-
-//Perform the work and output
-//Ex: PORT PB, PIN 31 = void EIC_15_Handler(void)
+#    pragma push_macro("PA")
+#    pragma push_macro("PB")
+#    pragma push_macro("_L_")
+
+// Undefine / redefine pushed macros
+#    undef PA
+#    undef PB
+#    undef _L_
+#    define _L_(x) x
+
+// Perform the work and output
+// Ex: PORT PB, PIN 31 = void EIC_15_Handler(void)
 DEBUG_BOOT_TRACING_HANDLER(PORTPIN_TO_IRQn(DEBUG_BOOT_TRACING_PORT, DEBUG_BOOT_TRACING_PIN))
-
-//Restore macros
-#pragma pop_macro("PA")
-#pragma pop_macro("PB")
-#pragma pop_macro("_L_")
+// Restore macros
+#    pragma pop_macro("PA")
+#    pragma pop_macro("PB")
+#    pragma pop_macro("_L_")
 {
-    //This is only for non-functional keyboard troubleshooting and should be disabled after boot
-    //Intention is to lock up the keyboard here with repeating debug led code
-    while (1)
-    {
+    // This is only for non-functional keyboard troubleshooting and should be disabled after boot
+    // Intention is to lock up the keyboard here with repeating debug led code
+    while (1) {
         dled_print(debug_code, 1);
     }
 }
 
-void debug_code_init(void)
-{
+void debug_code_init(void) {
     DBGC(DC_UNSET);
 
-    //Configure Ports for EIC
-    PORT->Group[DEBUG_BOOT_TRACING_PORT].DIRCLR.reg = 1 << DEBUG_BOOT_TRACING_PIN; //Input
-    PORT->Group[DEBUG_BOOT_TRACING_PORT].OUTSET.reg = 1 << DEBUG_BOOT_TRACING_PIN; //High
-    PORT->Group[DEBUG_BOOT_TRACING_PORT].PINCFG[DEBUG_BOOT_TRACING_PIN].bit.INEN = 1; //Input Enable
-    PORT->Group[DEBUG_BOOT_TRACING_PORT].PINCFG[DEBUG_BOOT_TRACING_PIN].bit.PULLEN = 1; //Pull Enable
-    PORT->Group[DEBUG_BOOT_TRACING_PORT].PINCFG[DEBUG_BOOT_TRACING_PIN].bit.PMUXEN = 1; //Mux Enable
-    PORT->Group[DEBUG_BOOT_TRACING_PORT].PMUX[DEBUG_BOOT_TRACING_PIN / 2].bit.PMUXO = 0; //Mux A
+    // Configure Ports for EIC
+    PORT->Group[DEBUG_BOOT_TRACING_PORT].DIRCLR.reg                                 = 1 << DEBUG_BOOT_TRACING_PIN;  // Input
+    PORT->Group[DEBUG_BOOT_TRACING_PORT].OUTSET.reg                                 = 1 << DEBUG_BOOT_TRACING_PIN;  // High
+    PORT->Group[DEBUG_BOOT_TRACING_PORT].PINCFG[DEBUG_BOOT_TRACING_PIN].bit.INEN    = 1;                            // Input Enable
+    PORT->Group[DEBUG_BOOT_TRACING_PORT].PINCFG[DEBUG_BOOT_TRACING_PIN].bit.PULLEN  = 1;                            // Pull Enable
+    PORT->Group[DEBUG_BOOT_TRACING_PORT].PINCFG[DEBUG_BOOT_TRACING_PIN].bit.PMUXEN  = 1;                            // Mux Enable
+    PORT->Group[DEBUG_BOOT_TRACING_PORT].PMUX[DEBUG_BOOT_TRACING_PIN / 2].bit.PMUXO = 0;                            // Mux A
 
-    //Enable CLK_EIC_APB
+    // Enable CLK_EIC_APB
     MCLK->APBAMASK.bit.EIC_ = 1;
 
-    //Configure EIC
+    // Configure EIC
     EIC->CTRLA.bit.SWRST = 1;
-    while (EIC->SYNCBUSY.bit.SWRST) {}
-    EIC->ASYNCH.reg = DEBUG_BOOT_TRACING_EXTINTb;
+    while (EIC->SYNCBUSY.bit.SWRST) {
+    }
+    EIC->ASYNCH.reg   = DEBUG_BOOT_TRACING_EXTINTb;
     EIC->INTENSET.reg = DEBUG_BOOT_TRACING_EXTINTb;
     EIC->CONFIG[DEBUG_BOOT_TRACING_CONFIG_INDn].reg |= (EIC_CONFIG_SENSE0_FALL_Val << DEBUG_BOOT_TRACING_CONFIG_SENSEb);
     EIC->CTRLA.bit.ENABLE = 1;
-    while (EIC->SYNCBUSY.bit.ENABLE) {}
+    while (EIC->SYNCBUSY.bit.ENABLE) {
+    }
 
-    //Enable EIC IRQ
+    // Enable EIC IRQ
     NVIC_EnableIRQ(DEBUG_BOOT_TRACING_IRQn);
 }
 
-void debug_code_disable(void)
-{
-    //Disable EIC IRQ
+void debug_code_disable(void) {
+    // Disable EIC IRQ
     NVIC_DisableIRQ(DEBUG_BOOT_TRACING_IRQn);
 
-    //Disable EIC
+    // Disable EIC
     EIC->CTRLA.bit.ENABLE = 0;
-    while (EIC->SYNCBUSY.bit.ENABLE) {}
+    while (EIC->SYNCBUSY.bit.ENABLE) {
+    }
 
-    //Default port configuration
-    PORT->Group[DEBUG_BOOT_TRACING_PORT].DIRCLR.reg = 1 << DEBUG_BOOT_TRACING_PIN; //Input
-    PORT->Group[DEBUG_BOOT_TRACING_PORT].OUTCLR.reg = 1 << DEBUG_BOOT_TRACING_PIN; //Low
-    PORT->Group[DEBUG_BOOT_TRACING_PORT].PINCFG[DEBUG_BOOT_TRACING_PIN].bit.INEN = 0; //Input Disable
-    PORT->Group[DEBUG_BOOT_TRACING_PORT].PINCFG[DEBUG_BOOT_TRACING_PIN].bit.PULLEN = 0; //Pull Disable
-    PORT->Group[DEBUG_BOOT_TRACING_PORT].PINCFG[DEBUG_BOOT_TRACING_PIN].bit.PMUXEN = 0; //Mux Disable
-    PORT->Group[DEBUG_BOOT_TRACING_PORT].PMUX[DEBUG_BOOT_TRACING_PIN / 2].bit.PMUXO = 0; //Mux A
+    // Default port configuration
+    PORT->Group[DEBUG_BOOT_TRACING_PORT].DIRCLR.reg                                 = 1 << DEBUG_BOOT_TRACING_PIN;  // Input
+    PORT->Group[DEBUG_BOOT_TRACING_PORT].OUTCLR.reg                                 = 1 << DEBUG_BOOT_TRACING_PIN;  // Low
+    PORT->Group[DEBUG_BOOT_TRACING_PORT].PINCFG[DEBUG_BOOT_TRACING_PIN].bit.INEN    = 0;                            // Input Disable
+    PORT->Group[DEBUG_BOOT_TRACING_PORT].PINCFG[DEBUG_BOOT_TRACING_PIN].bit.PULLEN  = 0;                            // Pull Disable
+    PORT->Group[DEBUG_BOOT_TRACING_PORT].PINCFG[DEBUG_BOOT_TRACING_PIN].bit.PMUXEN  = 0;                            // Mux Disable
+    PORT->Group[DEBUG_BOOT_TRACING_PORT].PMUX[DEBUG_BOOT_TRACING_PIN / 2].bit.PMUXO = 0;                            // Mux A
 
-    //Disable CLK_EIC_APB
+    // Disable CLK_EIC_APB
     MCLK->APBAMASK.bit.EIC_ = 0;
 }
 
@@ -224,4 +239,4 @@ void debug_code_disable(void)
 void debug_code_init(void) {}
 void debug_code_disable(void) {}
 
-#endif //DEBUG_BOOT_TRACING_ENABLE
+#endif  // DEBUG_BOOT_TRACING_ENABLE
diff --git a/tmk_core/protocol/arm_atsam/d51_util.h b/tmk_core/protocol/arm_atsam/d51_util.h
index 71431942c..89cf338d2 100644
--- a/tmk_core/protocol/arm_atsam/d51_util.h
+++ b/tmk_core/protocol/arm_atsam/d51_util.h
@@ -22,54 +22,54 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 /* Debug LED */
 #if DEBUG_LED_ENABLE == 1
-#define DBG_LED_ENA PORT->Group[DEBUG_LED_PORT].DIRSET.reg = (1 << DEBUG_LED_PIN)
-#define DBG_LED_DIS PORT->Group[DEBUG_LED_PORT].DIRCLR.reg = (1 << DEBUG_LED_PIN)
-#define DBG_LED_ON  PORT->Group[DEBUG_LED_PORT].OUTSET.reg = (1 << DEBUG_LED_PIN)
-#define DBG_LED_OFF PORT->Group[DEBUG_LED_PORT].OUTCLR.reg = (1 << DEBUG_LED_PIN)
+#    define DBG_LED_ENA PORT->Group[DEBUG_LED_PORT].DIRSET.reg = (1 << DEBUG_LED_PIN)
+#    define DBG_LED_DIS PORT->Group[DEBUG_LED_PORT].DIRCLR.reg = (1 << DEBUG_LED_PIN)
+#    define DBG_LED_ON PORT->Group[DEBUG_LED_PORT].OUTSET.reg = (1 << DEBUG_LED_PIN)
+#    define DBG_LED_OFF PORT->Group[DEBUG_LED_PORT].OUTCLR.reg = (1 << DEBUG_LED_PIN)
 #else
-#define DBG_LED_ENA
-#define DBG_LED_DIS
-#define DBG_LED_ON
-#define DBG_LED_OFF
+#    define DBG_LED_ENA
+#    define DBG_LED_DIS
+#    define DBG_LED_ON
+#    define DBG_LED_OFF
 #endif
 
 /* Debug Port 1 */
 #if DEBUG_PORT1_ENABLE == 1
-#define DBG_1_ENA PORT->Group[DEBUG_PORT1_PORT].DIRSET.reg = (1 << DEBUG_PORT1_PIN)
-#define DBG_1_DIS PORT->Group[DEBUG_PORT1_PORT].DIRCLR.reg = (1 << DEBUG_PORT1_PIN)
-#define DBG_1_ON  PORT->Group[DEBUG_PORT1_PORT].OUTSET.reg = (1 << DEBUG_PORT1_PIN)
-#define DBG_1_OFF PORT->Group[DEBUG_PORT1_PORT].OUTCLR.reg = (1 << DEBUG_PORT1_PIN)
+#    define DBG_1_ENA PORT->Group[DEBUG_PORT1_PORT].DIRSET.reg = (1 << DEBUG_PORT1_PIN)
+#    define DBG_1_DIS PORT->Group[DEBUG_PORT1_PORT].DIRCLR.reg = (1 << DEBUG_PORT1_PIN)
+#    define DBG_1_ON PORT->Group[DEBUG_PORT1_PORT].OUTSET.reg = (1 << DEBUG_PORT1_PIN)
+#    define DBG_1_OFF PORT->Group[DEBUG_PORT1_PORT].OUTCLR.reg = (1 << DEBUG_PORT1_PIN)
 #else
-#define DBG_1_ENA
-#define DBG_1_DIS
-#define DBG_1_ON 
-#define DBG_1_OFF
+#    define DBG_1_ENA
+#    define DBG_1_DIS
+#    define DBG_1_ON
+#    define DBG_1_OFF
 #endif
 
 /* Debug Port 2 */
 #if DEBUG_PORT2_ENABLE == 1
-#define DBG_2_ENA PORT->Group[DEBUG_PORT2_PORT].DIRSET.reg = (1 << DEBUG_PORT2_PIN)
-#define DBG_2_DIS PORT->Group[DEBUG_PORT2_PORT].DIRCLR.reg = (1 << DEBUG_PORT2_PIN)
-#define DBG_2_ON  PORT->Group[DEBUG_PORT2_PORT].OUTSET.reg = (1 << DEBUG_PORT2_PIN)
-#define DBG_2_OFF PORT->Group[DEBUG_PORT2_PORT].OUTCLR.reg = (1 << DEBUG_PORT2_PIN)
+#    define DBG_2_ENA PORT->Group[DEBUG_PORT2_PORT].DIRSET.reg = (1 << DEBUG_PORT2_PIN)
+#    define DBG_2_DIS PORT->Group[DEBUG_PORT2_PORT].DIRCLR.reg = (1 << DEBUG_PORT2_PIN)
+#    define DBG_2_ON PORT->Group[DEBUG_PORT2_PORT].OUTSET.reg = (1 << DEBUG_PORT2_PIN)
+#    define DBG_2_OFF PORT->Group[DEBUG_PORT2_PORT].OUTCLR.reg = (1 << DEBUG_PORT2_PIN)
 #else
-#define DBG_2_ENA
-#define DBG_2_DIS
-#define DBG_2_ON 
-#define DBG_2_OFF
+#    define DBG_2_ENA
+#    define DBG_2_DIS
+#    define DBG_2_ON
+#    define DBG_2_OFF
 #endif
 
 /* Debug Port 3 */
 #if DEBUG_PORT3_ENABLE == 1
-#define DBG_3_ENA PORT->Group[DEBUG_PORT3_PORT].DIRSET.reg = (1 << DEBUG_PORT3_PIN)
-#define DBG_3_DIS PORT->Group[DEBUG_PORT3_PORT].DIRCLR.reg = (1 << DEBUG_PORT3_PIN)
-#define DBG_3_ON  PORT->Group[DEBUG_PORT3_PORT].OUTSET.reg = (1 << DEBUG_PORT3_PIN)
-#define DBG_3_OFF PORT->Group[DEBUG_PORT3_PORT].OUTCLR.reg = (1 << DEBUG_PORT3_PIN)
+#    define DBG_3_ENA PORT->Group[DEBUG_PORT3_PORT].DIRSET.reg = (1 << DEBUG_PORT3_PIN)
+#    define DBG_3_DIS PORT->Group[DEBUG_PORT3_PORT].DIRCLR.reg = (1 << DEBUG_PORT3_PIN)
+#    define DBG_3_ON PORT->Group[DEBUG_PORT3_PORT].OUTSET.reg = (1 << DEBUG_PORT3_PIN)
+#    define DBG_3_OFF PORT->Group[DEBUG_PORT3_PORT].OUTCLR.reg = (1 << DEBUG_PORT3_PIN)
 #else
-#define DBG_3_ENA
-#define DBG_3_DIS
-#define DBG_3_ON 
-#define DBG_3_OFF
+#    define DBG_3_ENA
+#    define DBG_3_DIS
+#    define DBG_3_ON
+#    define DBG_3_OFF
 #endif
 
 void dbg_print(uint32_t x);
@@ -80,7 +80,7 @@ void debug_code_disable(void);
 
 #ifdef DEBUG_BOOT_TRACING_ENABLE
 
-#define DBGC(n) debug_code = n
+#    define DBGC(n) debug_code = n
 
 extern volatile uint32_t debug_code;
 
@@ -216,8 +216,9 @@ enum debug_code_list {
 
 #else
 
-#define DBGC(n) {}
+#    define DBGC(n) \
+        {}
 
-#endif //DEBUG_BOOT_TRACING_ENABLE
+#endif  // DEBUG_BOOT_TRACING_ENABLE
 
-#endif //_D51_UTIL_H_
+#endif  //_D51_UTIL_H_
diff --git a/tmk_core/protocol/arm_atsam/i2c_master.c b/tmk_core/protocol/arm_atsam/i2c_master.c
index 1741d9ac5..d3319ab44 100644
--- a/tmk_core/protocol/arm_atsam/i2c_master.c
+++ b/tmk_core/protocol/arm_atsam/i2c_master.c
@@ -19,77 +19,84 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 #if !defined(MD_BOOTLOADER) && defined(RGB_MATRIX_ENABLE)
 
-#include <string.h>
+#    include <string.h>
 
-//From keyboard
-#include "config.h"
-#include "config_led.h"
-#include "matrix.h"
+// From keyboard
+#    include "config.h"
+#    include "config_led.h"
+#    include "matrix.h"
 
-#define I2C_LED_USE_DMA 1               //Set 1 to use background DMA transfers for leds, Set 0 to use inline software transfers
+#    define I2C_LED_USE_DMA 1  // Set 1 to use background DMA transfers for leds, Set 0 to use inline software transfers
 
-static uint8_t i2c_led_q[I2C_Q_SIZE];   //I2C queue circular buffer
-static uint8_t i2c_led_q_s;             //Start of circular buffer
-static uint8_t i2c_led_q_e;             //End of circular buffer
-static uint8_t i2c_led_q_full;          //Queue full counter for reset
+static uint8_t i2c_led_q[I2C_Q_SIZE];  // I2C queue circular buffer
+static uint8_t i2c_led_q_s;            // Start of circular buffer
+static uint8_t i2c_led_q_e;            // End of circular buffer
+static uint8_t i2c_led_q_full;         // Queue full counter for reset
 
-static uint8_t dma_sendbuf[I2C_DMA_MAX_SEND]; //Data being written to I2C
+static uint8_t dma_sendbuf[I2C_DMA_MAX_SEND];  // Data being written to I2C
 
 volatile uint8_t i2c_led_q_running;
 
-#endif // !defined(MD_BOOTLOADER) && defined(RGB_MATRIX_ENABLE)
+#endif  // !defined(MD_BOOTLOADER) && defined(RGB_MATRIX_ENABLE)
 
-void i2c0_init(void)
-{
+void i2c0_init(void) {
     DBGC(DC_I2C0_INIT_BEGIN);
 
     CLK_set_i2c0_freq(CHAN_SERCOM_I2C0, FREQ_I2C0_DEFAULT);
 
-    //MCU
-    PORT->Group[0].PMUX[4].bit.PMUXE = 2;
-    PORT->Group[0].PMUX[4].bit.PMUXO = 2;
+    // MCU
+    PORT->Group[0].PMUX[4].bit.PMUXE    = 2;
+    PORT->Group[0].PMUX[4].bit.PMUXO    = 2;
     PORT->Group[0].PINCFG[8].bit.PMUXEN = 1;
     PORT->Group[0].PINCFG[9].bit.PMUXEN = 1;
 
-    //I2C
-    //Note: SW Reset handled in CLK_set_i2c0_freq clks.c
+    // I2C
+    // Note: SW Reset handled in CLK_set_i2c0_freq clks.c
 
-    SERCOM0->I2CM.CTRLA.bit.MODE = 5;                           //Set master mode
+    SERCOM0->I2CM.CTRLA.bit.MODE = 5;  // Set master mode
 
-    SERCOM0->I2CM.CTRLA.bit.SPEED = 0;                          //Set to 1 for Fast-mode Plus (FM+) up to 1 MHz
-    SERCOM0->I2CM.CTRLA.bit.RUNSTDBY = 1;                       //Enabled
+    SERCOM0->I2CM.CTRLA.bit.SPEED    = 0;  // Set to 1 for Fast-mode Plus (FM+) up to 1 MHz
+    SERCOM0->I2CM.CTRLA.bit.RUNSTDBY = 1;  // Enabled
 
-    SERCOM0->I2CM.CTRLA.bit.ENABLE = 1;                         //Enable the device
-    while (SERCOM0->I2CM.SYNCBUSY.bit.ENABLE) { DBGC(DC_I2C0_INIT_SYNC_ENABLING); }                //Wait for SYNCBUSY.ENABLE to clear
+    SERCOM0->I2CM.CTRLA.bit.ENABLE = 1;  // Enable the device
+    while (SERCOM0->I2CM.SYNCBUSY.bit.ENABLE) {
+        DBGC(DC_I2C0_INIT_SYNC_ENABLING);
+    }  // Wait for SYNCBUSY.ENABLE to clear
 
-    SERCOM0->I2CM.STATUS.bit.BUSSTATE = 1;                      //Force into IDLE state
-    while (SERCOM0->I2CM.SYNCBUSY.bit.SYSOP) { DBGC(DC_I2C0_INIT_SYNC_SYSOP); }
-    while (SERCOM0->I2CM.STATUS.bit.BUSSTATE != 1) { DBGC(DC_I2C0_INIT_WAIT_IDLE); }           //Wait while not idle
+    SERCOM0->I2CM.STATUS.bit.BUSSTATE = 1;  // Force into IDLE state
+    while (SERCOM0->I2CM.SYNCBUSY.bit.SYSOP) {
+        DBGC(DC_I2C0_INIT_SYNC_SYSOP);
+    }
+    while (SERCOM0->I2CM.STATUS.bit.BUSSTATE != 1) {
+        DBGC(DC_I2C0_INIT_WAIT_IDLE);
+    }  // Wait while not idle
 
     DBGC(DC_I2C0_INIT_COMPLETE);
 }
 
-uint8_t i2c0_start(uint8_t address)
-{
+uint8_t i2c0_start(uint8_t address) {
     SERCOM0->I2CM.ADDR.bit.ADDR = address;
-    while (SERCOM0->I2CM.SYNCBUSY.bit.SYSOP) {}
-    while (SERCOM0->I2CM.INTFLAG.bit.MB == 0) {}
-    while (SERCOM0->I2CM.STATUS.bit.RXNACK) {}
+    while (SERCOM0->I2CM.SYNCBUSY.bit.SYSOP) {
+    }
+    while (SERCOM0->I2CM.INTFLAG.bit.MB == 0) {
+    }
+    while (SERCOM0->I2CM.STATUS.bit.RXNACK) {
+    }
 
     return 1;
 }
 
-uint8_t i2c0_transmit(uint8_t address, uint8_t *data, uint16_t length, uint16_t timeout)
-{
+uint8_t i2c0_transmit(uint8_t address, uint8_t *data, uint16_t length, uint16_t timeout) {
     if (!length) return 0;
 
     i2c0_start(address);
 
-    while (length)
-    {
+    while (length) {
         SERCOM0->I2CM.DATA.bit.DATA = *data;
-        while (SERCOM0->I2CM.INTFLAG.bit.MB == 0) {}
-        while (SERCOM0->I2CM.STATUS.bit.RXNACK) {}
+        while (SERCOM0->I2CM.INTFLAG.bit.MB == 0) {
+        }
+        while (SERCOM0->I2CM.STATUS.bit.RXNACK) {
+        }
 
         data++;
         length--;
@@ -100,74 +107,83 @@ uint8_t i2c0_transmit(uint8_t address, uint8_t *data, uint16_t length, uint16_t
     return 1;
 }
 
-void i2c0_stop(void)
-{
-    if (SERCOM0->I2CM.STATUS.bit.CLKHOLD || SERCOM0->I2CM.INTFLAG.bit.MB == 1 || SERCOM0->I2CM.STATUS.bit.BUSSTATE != 1)
-    {
+void i2c0_stop(void) {
+    if (SERCOM0->I2CM.STATUS.bit.CLKHOLD || SERCOM0->I2CM.INTFLAG.bit.MB == 1 || SERCOM0->I2CM.STATUS.bit.BUSSTATE != 1) {
         SERCOM0->I2CM.CTRLB.bit.CMD = 3;
-        while (SERCOM0->I2CM.SYNCBUSY.bit.SYSOP);
-        while (SERCOM0->I2CM.STATUS.bit.CLKHOLD);
-        while (SERCOM0->I2CM.INTFLAG.bit.MB);
-        while (SERCOM0->I2CM.STATUS.bit.BUSSTATE != 1);
+        while (SERCOM0->I2CM.SYNCBUSY.bit.SYSOP)
+            ;
+        while (SERCOM0->I2CM.STATUS.bit.CLKHOLD)
+            ;
+        while (SERCOM0->I2CM.INTFLAG.bit.MB)
+            ;
+        while (SERCOM0->I2CM.STATUS.bit.BUSSTATE != 1)
+            ;
     }
 }
 
 #if !defined(MD_BOOTLOADER) && defined(RGB_MATRIX_ENABLE)
-void i2c1_init(void)
-{
+void i2c1_init(void) {
     DBGC(DC_I2C1_INIT_BEGIN);
 
     CLK_set_i2c1_freq(CHAN_SERCOM_I2C1, FREQ_I2C1_DEFAULT);
 
     /* MCU */
-    PORT->Group[0].PMUX[8].bit.PMUXE = 2;
-    PORT->Group[0].PMUX[8].bit.PMUXO = 2;
+    PORT->Group[0].PMUX[8].bit.PMUXE     = 2;
+    PORT->Group[0].PMUX[8].bit.PMUXO     = 2;
     PORT->Group[0].PINCFG[16].bit.PMUXEN = 1;
     PORT->Group[0].PINCFG[17].bit.PMUXEN = 1;
 
     /* I2C */
-    //Note: SW Reset handled in CLK_set_i2c1_freq clks.c
+    // Note: SW Reset handled in CLK_set_i2c1_freq clks.c
 
-    SERCOM1->I2CM.CTRLA.bit.MODE = 5;                   //MODE: Set master mode (No sync)
-    SERCOM1->I2CM.CTRLA.bit.SPEED = 1;                  //SPEED: Fm+ up to 1MHz (No sync)
-    SERCOM1->I2CM.CTRLA.bit.RUNSTDBY = 1;               //RUNSTBY: Enabled (No sync)
+    SERCOM1->I2CM.CTRLA.bit.MODE     = 5;  // MODE: Set master mode (No sync)
+    SERCOM1->I2CM.CTRLA.bit.SPEED    = 1;  // SPEED: Fm+ up to 1MHz (No sync)
+    SERCOM1->I2CM.CTRLA.bit.RUNSTDBY = 1;  // RUNSTBY: Enabled (No sync)
 
-    SERCOM1->I2CM.CTRLB.bit.SMEN = 1;                   //SMEN: Smart mode enabled (For DMA)(No sync)
+    SERCOM1->I2CM.CTRLB.bit.SMEN = 1;  // SMEN: Smart mode enabled (For DMA)(No sync)
 
     NVIC_EnableIRQ(SERCOM1_0_IRQn);
     SERCOM1->I2CM.INTENSET.bit.ERROR = 1;
 
-    SERCOM1->I2CM.CTRLA.bit.ENABLE = 1;                 //ENABLE: Enable the device (sync SYNCBUSY.ENABLE)
-    while (SERCOM1->I2CM.SYNCBUSY.bit.ENABLE) { DBGC(DC_I2C1_INIT_SYNC_ENABLING); }        //Wait for SYNCBUSY.ENABLE to clear
+    SERCOM1->I2CM.CTRLA.bit.ENABLE = 1;  // ENABLE: Enable the device (sync SYNCBUSY.ENABLE)
+    while (SERCOM1->I2CM.SYNCBUSY.bit.ENABLE) {
+        DBGC(DC_I2C1_INIT_SYNC_ENABLING);
+    }  // Wait for SYNCBUSY.ENABLE to clear
 
-    SERCOM1->I2CM.STATUS.bit.BUSSTATE = 1;              //BUSSTATE: Force into IDLE state (sync SYNCBUSY.SYSOP)
-    while (SERCOM1->I2CM.SYNCBUSY.bit.SYSOP) { DBGC(DC_I2C1_INIT_SYNC_SYSOP); }
-    while (SERCOM1->I2CM.STATUS.bit.BUSSTATE != 1) { DBGC(DC_I2C1_INIT_WAIT_IDLE); }  //Wait while not idle
+    SERCOM1->I2CM.STATUS.bit.BUSSTATE = 1;  // BUSSTATE: Force into IDLE state (sync SYNCBUSY.SYSOP)
+    while (SERCOM1->I2CM.SYNCBUSY.bit.SYSOP) {
+        DBGC(DC_I2C1_INIT_SYNC_SYSOP);
+    }
+    while (SERCOM1->I2CM.STATUS.bit.BUSSTATE != 1) {
+        DBGC(DC_I2C1_INIT_WAIT_IDLE);
+    }  // Wait while not idle
 
     DBGC(DC_I2C1_INIT_COMPLETE);
 }
 
-uint8_t i2c1_start(uint8_t address)
-{
+uint8_t i2c1_start(uint8_t address) {
     SERCOM1->I2CM.ADDR.bit.ADDR = address;
-    while (SERCOM1->I2CM.SYNCBUSY.bit.SYSOP) {}
-    while (SERCOM1->I2CM.INTFLAG.bit.MB == 0) {}
-    while (SERCOM1->I2CM.STATUS.bit.RXNACK) {}
+    while (SERCOM1->I2CM.SYNCBUSY.bit.SYSOP) {
+    }
+    while (SERCOM1->I2CM.INTFLAG.bit.MB == 0) {
+    }
+    while (SERCOM1->I2CM.STATUS.bit.RXNACK) {
+    }
 
     return 1;
 }
 
-uint8_t i2c1_transmit(uint8_t address, uint8_t *data, uint16_t length, uint16_t timeout)
-{
+uint8_t i2c1_transmit(uint8_t address, uint8_t *data, uint16_t length, uint16_t timeout) {
     if (!length) return 0;
 
     i2c1_start(address);
 
-    while (length)
-    {
+    while (length) {
         SERCOM1->I2CM.DATA.bit.DATA = *data;
-        while (SERCOM1->I2CM.INTFLAG.bit.MB == 0) {}
-        while (SERCOM1->I2CM.STATUS.bit.RXNACK) {}
+        while (SERCOM1->I2CM.INTFLAG.bit.MB == 0) {
+        }
+        while (SERCOM1->I2CM.STATUS.bit.RXNACK) {
+        }
 
         data++;
         length--;
@@ -178,33 +194,32 @@ uint8_t i2c1_transmit(uint8_t address, uint8_t *data, uint16_t length, uint16_t
     return 1;
 }
 
-void i2c1_stop(void)
-{
-    if (SERCOM1->I2CM.STATUS.bit.CLKHOLD || SERCOM1->I2CM.INTFLAG.bit.MB == 1 || SERCOM1->I2CM.STATUS.bit.BUSSTATE != 1)
-    {
+void i2c1_stop(void) {
+    if (SERCOM1->I2CM.STATUS.bit.CLKHOLD || SERCOM1->I2CM.INTFLAG.bit.MB == 1 || SERCOM1->I2CM.STATUS.bit.BUSSTATE != 1) {
         SERCOM1->I2CM.CTRLB.bit.CMD = 3;
-        while (SERCOM1->I2CM.SYNCBUSY.bit.SYSOP);
-        while (SERCOM1->I2CM.STATUS.bit.CLKHOLD);
-        while (SERCOM1->I2CM.INTFLAG.bit.MB);
-        while (SERCOM1->I2CM.STATUS.bit.BUSSTATE != 1);
+        while (SERCOM1->I2CM.SYNCBUSY.bit.SYSOP)
+            ;
+        while (SERCOM1->I2CM.STATUS.bit.CLKHOLD)
+            ;
+        while (SERCOM1->I2CM.INTFLAG.bit.MB)
+            ;
+        while (SERCOM1->I2CM.STATUS.bit.BUSSTATE != 1)
+            ;
     }
 }
 
-void i2c_led_send_CRWL(uint8_t drvid)
-{
-    uint8_t i2cdata[] = { ISSI3733_CMDRWL, ISSI3733_CMDRWL_WRITE_ENABLE_ONCE };
+void i2c_led_send_CRWL(uint8_t drvid) {
+    uint8_t i2cdata[] = {ISSI3733_CMDRWL, ISSI3733_CMDRWL_WRITE_ENABLE_ONCE};
     i2c1_transmit(issidrv[drvid].addr, i2cdata, sizeof(i2cdata), 0);
 }
 
-void i2c_led_select_page(uint8_t drvid, uint8_t pageno)
-{
-    uint8_t i2cdata[] = { ISSI3733_CMDR, pageno };
+void i2c_led_select_page(uint8_t drvid, uint8_t pageno) {
+    uint8_t i2cdata[] = {ISSI3733_CMDR, pageno};
     i2c1_transmit(issidrv[drvid].addr, i2cdata, sizeof(i2cdata), 0);
 }
 
-void i2c_led_send_GCR(uint8_t drvid)
-{
-    uint8_t i2cdata[] = { ISSI3733_GCCR, 0x00 };
+void i2c_led_send_GCR(uint8_t drvid) {
+    uint8_t i2cdata[] = {ISSI3733_GCCR, 0x00};
 
     if (gcr_actual > LED_GCR_MAX) gcr_actual = LED_GCR_MAX;
     i2cdata[1] = gcr_actual;
@@ -212,57 +227,50 @@ void i2c_led_send_GCR(uint8_t drvid)
     i2c1_transmit(issidrv[drvid].addr, i2cdata, sizeof(i2cdata), 0);
 }
 
-void i2c_led_send_onoff(uint8_t drvid)
-{
-#if I2C_LED_USE_DMA != 1
-    if (!i2c_led_q_running)
-    {
-#endif
+void i2c_led_send_onoff(uint8_t drvid) {
+#    if I2C_LED_USE_DMA != 1
+    if (!i2c_led_q_running) {
+#    endif
         i2c_led_send_CRWL(drvid);
         i2c_led_select_page(drvid, 0);
-#if I2C_LED_USE_DMA != 1
+#    if I2C_LED_USE_DMA != 1
     }
-#endif
+#    endif
 
-    *issidrv[drvid].onoff = 0; //Force start location offset to zero
+    *issidrv[drvid].onoff = 0;  // Force start location offset to zero
     i2c1_transmit(issidrv[drvid].addr, issidrv[drvid].onoff, ISSI3733_PG0_BYTES, 0);
 }
 
-void i2c_led_send_mode_op_gcr(uint8_t drvid, uint8_t mode, uint8_t operation)
-{
-    uint8_t i2cdata[] = { ISSI3733_CR, mode | operation, gcr_actual};
+void i2c_led_send_mode_op_gcr(uint8_t drvid, uint8_t mode, uint8_t operation) {
+    uint8_t i2cdata[] = {ISSI3733_CR, mode | operation, gcr_actual};
     i2c1_transmit(issidrv[drvid].addr, i2cdata, sizeof(i2cdata), 0);
 }
 
-void i2c_led_send_pur_pdr(uint8_t drvid, uint8_t pur, uint8_t pdr)
-{
-    uint8_t i2cdata[] = { ISSI3733_SWYR_PUR, pur, pdr };
+void i2c_led_send_pur_pdr(uint8_t drvid, uint8_t pur, uint8_t pdr) {
+    uint8_t i2cdata[] = {ISSI3733_SWYR_PUR, pur, pdr};
 
     i2c1_transmit(issidrv[drvid].addr, i2cdata, sizeof(i2cdata), 0);
 }
 
-void i2c_led_send_pwm(uint8_t drvid)
-{
-#if I2C_LED_USE_DMA != 1
-    if (!i2c_led_q_running)
-    {
-#endif
+void i2c_led_send_pwm(uint8_t drvid) {
+#    if I2C_LED_USE_DMA != 1
+    if (!i2c_led_q_running) {
+#    endif
         i2c_led_send_CRWL(drvid);
         i2c_led_select_page(drvid, 0);
-#if I2C_LED_USE_DMA != 1
+#    if I2C_LED_USE_DMA != 1
     }
-#endif
+#    endif
 
-    *issidrv[drvid].pwm = 0; //Force start location offset to zero
+    *issidrv[drvid].pwm = 0;  // Force start location offset to zero
     i2c1_transmit(issidrv[drvid].addr, issidrv[drvid].pwm, ISSI3733_PG1_BYTES, 0);
 }
 
-uint8_t I2C3733_Init_Control(void)
-{
+uint8_t I2C3733_Init_Control(void) {
     DBGC(DC_I2C3733_INIT_CONTROL_BEGIN);
 
-    //Hardware state shutdown on boot
-    //USB state machine will enable driver when communication is ready
+    // Hardware state shutdown on boot
+    // USB state machine will enable driver when communication is ready
     I2C3733_Control_Set(0);
 
     wait_ms(1);
@@ -277,25 +285,24 @@ uint8_t I2C3733_Init_Control(void)
     return 1;
 }
 
-uint8_t I2C3733_Init_Drivers(void)
-{
+uint8_t I2C3733_Init_Drivers(void) {
     DBGC(DC_I2C3733_INIT_DRIVERS_BEGIN);
 
-    gcr_actual = ISSI3733_GCR_DEFAULT;
+    gcr_actual      = ISSI3733_GCR_DEFAULT;
     gcr_actual_last = gcr_actual;
 
     if (gcr_actual > LED_GCR_MAX) gcr_actual = LED_GCR_MAX;
     gcr_desired = gcr_actual;
 
-    //Set up master device
+    // Set up master device
     i2c_led_send_CRWL(0);
     i2c_led_select_page(0, 3);
-    i2c_led_send_mode_op_gcr(0, 0, ISSI3733_CR_SSD_NORMAL); //No SYNC due to brightness mismatch with second driver
+    i2c_led_send_mode_op_gcr(0, 0, ISSI3733_CR_SSD_NORMAL);  // No SYNC due to brightness mismatch with second driver
 
-    //Set up slave device
+    // Set up slave device
     i2c_led_send_CRWL(1);
     i2c_led_select_page(1, 3);
-    i2c_led_send_mode_op_gcr(1, 0, ISSI3733_CR_SSD_NORMAL); //No SYNC due to brightness mismatch with first driver and slight flicker at rgb values 1,2
+    i2c_led_send_mode_op_gcr(1, 0, ISSI3733_CR_SSD_NORMAL);  // No SYNC due to brightness mismatch with first driver and slight flicker at rgb values 1,2
 
     i2c_led_send_CRWL(0);
     i2c_led_select_page(0, 3);
@@ -310,51 +317,54 @@ uint8_t I2C3733_Init_Drivers(void)
     return 1;
 }
 
-void I2C_DMAC_LED_Init(void)
-{
+void I2C_DMAC_LED_Init(void) {
     Dmac *dmac = DMAC;
 
     DBGC(DC_I2C_DMAC_LED_INIT_BEGIN);
 
-    //Disable device
-    dmac->CTRL.bit.DMAENABLE = 0;                   //Disable DMAC
-    while (dmac->CTRL.bit.DMAENABLE) {}             //Wait for disabled state in case of ongoing transfers
-    dmac->CTRL.bit.SWRST = 1;                       //Software Reset DMAC
-    while (dmac->CTRL.bit.SWRST) {}                 //Wait for software reset to complete
-
-    //Configure device
-    dmac->BASEADDR.reg = (uint32_t)&dmac_desc;      //Set descriptor base address
-    dmac->WRBADDR.reg = (uint32_t)&dmac_desc_wb;    //Set descriptor write back address
-    dmac->CTRL.reg |= 0x0f00;                       //Handle all priorities (LVL0-3)
-
-    //Disable channel
-    dmac->Channel[0].CHCTRLA.bit.ENABLE = 0;        //Disable the channel
-    while (dmac->Channel[0].CHCTRLA.bit.ENABLE) {}  //Wait for disabled state in case of ongoing transfers
-    dmac->Channel[0].CHCTRLA.bit.SWRST = 1;         //Software Reset the channel
-    while (dmac->Channel[0].CHCTRLA.bit.SWRST) {}   //Wait for software reset to complete
-
-    //Configure channel
-    dmac->Channel[0].CHCTRLA.bit.THRESHOLD = 0;     //1BEAT
-    dmac->Channel[0].CHCTRLA.bit.BURSTLEN = 0;      //SINGLE
-    dmac->Channel[0].CHCTRLA.bit.TRIGACT = 2;       //BURST
-    dmac->Channel[0].CHCTRLA.bit.TRIGSRC = SERCOM1_DMAC_ID_TX;  //Trigger source
-    dmac->Channel[0].CHCTRLA.bit.RUNSTDBY = 1;      //Run in standby
+    // Disable device
+    dmac->CTRL.bit.DMAENABLE = 0;  // Disable DMAC
+    while (dmac->CTRL.bit.DMAENABLE) {
+    }                          // Wait for disabled state in case of ongoing transfers
+    dmac->CTRL.bit.SWRST = 1;  // Software Reset DMAC
+    while (dmac->CTRL.bit.SWRST) {
+    }  // Wait for software reset to complete
+
+    // Configure device
+    dmac->BASEADDR.reg = (uint32_t)&dmac_desc;     // Set descriptor base address
+    dmac->WRBADDR.reg  = (uint32_t)&dmac_desc_wb;  // Set descriptor write back address
+    dmac->CTRL.reg |= 0x0f00;                      // Handle all priorities (LVL0-3)
+
+    // Disable channel
+    dmac->Channel[0].CHCTRLA.bit.ENABLE = 0;  // Disable the channel
+    while (dmac->Channel[0].CHCTRLA.bit.ENABLE) {
+    }                                        // Wait for disabled state in case of ongoing transfers
+    dmac->Channel[0].CHCTRLA.bit.SWRST = 1;  // Software Reset the channel
+    while (dmac->Channel[0].CHCTRLA.bit.SWRST) {
+    }  // Wait for software reset to complete
+
+    // Configure channel
+    dmac->Channel[0].CHCTRLA.bit.THRESHOLD = 0;                   // 1BEAT
+    dmac->Channel[0].CHCTRLA.bit.BURSTLEN  = 0;                   // SINGLE
+    dmac->Channel[0].CHCTRLA.bit.TRIGACT   = 2;                   // BURST
+    dmac->Channel[0].CHCTRLA.bit.TRIGSRC   = SERCOM1_DMAC_ID_TX;  // Trigger source
+    dmac->Channel[0].CHCTRLA.bit.RUNSTDBY  = 1;                   // Run in standby
 
     NVIC_EnableIRQ(DMAC_0_IRQn);
     dmac->Channel[0].CHINTENSET.bit.TCMPL = 1;
-    dmac->Channel[0].CHINTENSET.bit.TERR = 1;
+    dmac->Channel[0].CHINTENSET.bit.TERR  = 1;
 
-    //Enable device
-    dmac->CTRL.bit.DMAENABLE = 1;                   //Enable DMAC
-    while (dmac->CTRL.bit.DMAENABLE == 0) {}        //Wait for enable state
+    // Enable device
+    dmac->CTRL.bit.DMAENABLE = 1;  // Enable DMAC
+    while (dmac->CTRL.bit.DMAENABLE == 0) {
+    }  // Wait for enable state
 
     DBGC(DC_I2C_DMAC_LED_INIT_COMPLETE);
 }
 
-//state = 1 enable
-//state = 0 disable
-void I2C3733_Control_Set(uint8_t state)
-{
+// state = 1 enable
+// state = 0 disable
+void I2C3733_Control_Set(uint8_t state) {
     DBGC(DC_I2C3733_CONTROL_SET_BEGIN);
 
     sr_exp_data.bit.SDB_N = (state == 1 ? 1 : 0);
@@ -363,131 +373,111 @@ void I2C3733_Control_Set(uint8_t state)
     DBGC(DC_I2C3733_CONTROL_SET_COMPLETE);
 }
 
-void i2c_led_desc_defaults(void)
-{
-    dmac_desc.BTCTRL.bit.STEPSIZE = 0;      //SRCINC used in favor for auto 1 inc
-    dmac_desc.BTCTRL.bit.STEPSEL = 0;       //SRCINC used in favor for auto 1 inc
-    dmac_desc.BTCTRL.bit.DSTINC = 0;        //The Destination Address Increment is disabled
-    dmac_desc.BTCTRL.bit.SRCINC = 1;        //The Source Address Increment is enabled (Inc by 1)
-    dmac_desc.BTCTRL.bit.BEATSIZE = 0;      //8-bit bus transfer
-    dmac_desc.BTCTRL.bit.BLOCKACT = 0;      //Channel will be disabled if it is the last block transfer in the transaction
-    dmac_desc.BTCTRL.bit.EVOSEL = 0;        //Event generation disabled
-    dmac_desc.BTCTRL.bit.VALID = 1;         //Set dmac valid
+void i2c_led_desc_defaults(void) {
+    dmac_desc.BTCTRL.bit.STEPSIZE = 0;  // SRCINC used in favor for auto 1 inc
+    dmac_desc.BTCTRL.bit.STEPSEL  = 0;  // SRCINC used in favor for auto 1 inc
+    dmac_desc.BTCTRL.bit.DSTINC   = 0;  // The Destination Address Increment is disabled
+    dmac_desc.BTCTRL.bit.SRCINC   = 1;  // The Source Address Increment is enabled (Inc by 1)
+    dmac_desc.BTCTRL.bit.BEATSIZE = 0;  // 8-bit bus transfer
+    dmac_desc.BTCTRL.bit.BLOCKACT = 0;  // Channel will be disabled if it is the last block transfer in the transaction
+    dmac_desc.BTCTRL.bit.EVOSEL   = 0;  // Event generation disabled
+    dmac_desc.BTCTRL.bit.VALID    = 1;  // Set dmac valid
 }
 
-void i2c_led_prepare_send_dma(uint8_t *data, uint8_t len)
-{
+void i2c_led_prepare_send_dma(uint8_t *data, uint8_t len) {
     i2c_led_desc_defaults();
 
-    dmac_desc.BTCNT.reg = len;
-    dmac_desc.SRCADDR.reg = (uint32_t)data + len;
-    dmac_desc.DSTADDR.reg = (uint32_t)&SERCOM1->I2CM.DATA.reg;
+    dmac_desc.BTCNT.reg    = len;
+    dmac_desc.SRCADDR.reg  = (uint32_t)data + len;
+    dmac_desc.DSTADDR.reg  = (uint32_t)&SERCOM1->I2CM.DATA.reg;
     dmac_desc.DESCADDR.reg = 0;
 }
 
-void i2c_led_begin_dma(uint8_t drvid)
-{
-    DMAC->Channel[0].CHCTRLA.bit.ENABLE = 1; //Enable the channel
+void i2c_led_begin_dma(uint8_t drvid) {
+    DMAC->Channel[0].CHCTRLA.bit.ENABLE = 1;  // Enable the channel
 
-    SERCOM1->I2CM.ADDR.reg = (dmac_desc.BTCNT.reg << 16) | 0x2000 | issidrv[drvid].addr; //Begin transfer
+    SERCOM1->I2CM.ADDR.reg = (dmac_desc.BTCNT.reg << 16) | 0x2000 | issidrv[drvid].addr;  // Begin transfer
 }
 
-void i2c_led_send_CRWL_dma(uint8_t drvid)
-{
-    *(dma_sendbuf+0) = ISSI3733_CMDRWL;
-    *(dma_sendbuf+1) = ISSI3733_CMDRWL_WRITE_ENABLE_ONCE;
+void i2c_led_send_CRWL_dma(uint8_t drvid) {
+    *(dma_sendbuf + 0) = ISSI3733_CMDRWL;
+    *(dma_sendbuf + 1) = ISSI3733_CMDRWL_WRITE_ENABLE_ONCE;
     i2c_led_prepare_send_dma(dma_sendbuf, 2);
 
     i2c_led_begin_dma(drvid);
 }
 
-void i2c_led_select_page_dma(uint8_t drvid, uint8_t pageno)
-{
-    *(dma_sendbuf+0) = ISSI3733_CMDR;
-    *(dma_sendbuf+1) = pageno;
+void i2c_led_select_page_dma(uint8_t drvid, uint8_t pageno) {
+    *(dma_sendbuf + 0) = ISSI3733_CMDR;
+    *(dma_sendbuf + 1) = pageno;
     i2c_led_prepare_send_dma(dma_sendbuf, 2);
 
     i2c_led_begin_dma(drvid);
 }
 
-void i2c_led_send_GCR_dma(uint8_t drvid)
-{
-    *(dma_sendbuf+0) = ISSI3733_GCCR;
-    *(dma_sendbuf+1) = gcr_actual;
+void i2c_led_send_GCR_dma(uint8_t drvid) {
+    *(dma_sendbuf + 0) = ISSI3733_GCCR;
+    *(dma_sendbuf + 1) = gcr_actual;
     i2c_led_prepare_send_dma(dma_sendbuf, 2);
 
     i2c_led_begin_dma(drvid);
 }
 
-void i2c_led_send_pwm_dma(uint8_t drvid)
-{
-    //Note: This copies the CURRENT pwm buffer, which may be getting modified
+void i2c_led_send_pwm_dma(uint8_t drvid) {
+    // Note: This copies the CURRENT pwm buffer, which may be getting modified
     memcpy(dma_sendbuf, issidrv[drvid].pwm, ISSI3733_PG1_BYTES);
-    *dma_sendbuf = 0; //Force start location offset to zero
+    *dma_sendbuf = 0;  // Force start location offset to zero
     i2c_led_prepare_send_dma(dma_sendbuf, ISSI3733_PG1_BYTES);
 
     i2c_led_begin_dma(drvid);
 }
 
-void i2c_led_send_onoff_dma(uint8_t drvid)
-{
-    //Note: This copies the CURRENT onoff buffer, which may be getting modified
+void i2c_led_send_onoff_dma(uint8_t drvid) {
+    // Note: This copies the CURRENT onoff buffer, which may be getting modified
     memcpy(dma_sendbuf, issidrv[drvid].onoff, ISSI3733_PG0_BYTES);
-    *dma_sendbuf = 0; //Force start location offset to zero
+    *dma_sendbuf = 0;  // Force start location offset to zero
     i2c_led_prepare_send_dma(dma_sendbuf, ISSI3733_PG0_BYTES);
 
     i2c_led_begin_dma(drvid);
 }
 
-void i2c_led_q_init(void)
-{
+void i2c_led_q_init(void) {
     memset(i2c_led_q, 0, I2C_Q_SIZE);
-    i2c_led_q_s = 0;
-    i2c_led_q_e = 0;
+    i2c_led_q_s       = 0;
+    i2c_led_q_e       = 0;
     i2c_led_q_running = 0;
-    i2c_led_q_full = 0;
+    i2c_led_q_full    = 0;
 }
 
-uint8_t i2c_led_q_isempty(void)
-{
-    return i2c_led_q_s == i2c_led_q_e;
-}
+uint8_t i2c_led_q_isempty(void) { return i2c_led_q_s == i2c_led_q_e; }
 
-uint8_t i2c_led_q_size(void)
-{
-    return (i2c_led_q_e - i2c_led_q_s) % I2C_Q_SIZE;
-}
+uint8_t i2c_led_q_size(void) { return (i2c_led_q_e - i2c_led_q_s) % I2C_Q_SIZE; }
 
-uint8_t i2c_led_q_available(void)
-{
-    return I2C_Q_SIZE - i2c_led_q_size() - 1; //Never allow end to meet start
+uint8_t i2c_led_q_available(void) {
+    return I2C_Q_SIZE - i2c_led_q_size() - 1;  // Never allow end to meet start
 }
 
-void i2c_led_q_add(uint8_t cmd)
-{
-    //WARNING: Always request room before adding commands!
+void i2c_led_q_add(uint8_t cmd) {
+    // WARNING: Always request room before adding commands!
 
-    //Assign command
+    // Assign command
     i2c_led_q[i2c_led_q_e] = cmd;
 
-    i2c_led_q_e = (i2c_led_q_e + 1) % I2C_Q_SIZE; //Move end up one or wrap
+    i2c_led_q_e = (i2c_led_q_e + 1) % I2C_Q_SIZE;  // Move end up one or wrap
 }
 
-void i2c_led_q_s_advance(void)
-{
-    i2c_led_q_s = (i2c_led_q_s + 1) % I2C_Q_SIZE; //Move start up one or wrap
+void i2c_led_q_s_advance(void) {
+    i2c_led_q_s = (i2c_led_q_s + 1) % I2C_Q_SIZE;  // Move start up one or wrap
 }
 
-//Always request room before adding commands
-//PS: In case the queue somehow gets filled, it will reset if it can not clear up
-//PS: Could only get this to happen through unrealistic timings to overload the I2C bus
-uint8_t i2c_led_q_request_room(uint8_t request_size)
-{
-    if (request_size > i2c_led_q_available())
-    {
+// Always request room before adding commands
+// PS: In case the queue somehow gets filled, it will reset if it can not clear up
+// PS: Could only get this to happen through unrealistic timings to overload the I2C bus
+uint8_t i2c_led_q_request_room(uint8_t request_size) {
+    if (request_size > i2c_led_q_available()) {
         i2c_led_q_full++;
 
-        if (i2c_led_q_full >= 100) //Give the queue a chance to clear up
+        if (i2c_led_q_full >= 100)  // Give the queue a chance to clear up
         {
             DBG_LED_ON;
             I2C_DMAC_LED_Init();
@@ -503,10 +493,8 @@ uint8_t i2c_led_q_request_room(uint8_t request_size)
     return 1;
 }
 
-uint8_t i2c_led_q_run(void)
-{
-    if (i2c_led_q_isempty())
-    {
+uint8_t i2c_led_q_run(void) {
+    if (i2c_led_q_isempty()) {
         i2c_led_q_running = 0;
         return 0;
     }
@@ -515,72 +503,62 @@ uint8_t i2c_led_q_run(void)
 
     i2c_led_q_running = 1;
 
-#if I2C_LED_USE_DMA != 1
-    while (!i2c_led_q_isempty())
-    {
-#endif
-        //run command
-        if (i2c_led_q[i2c_led_q_s] == I2C_Q_CRWL)
-        {
+#    if I2C_LED_USE_DMA != 1
+    while (!i2c_led_q_isempty()) {
+#    endif
+        // run command
+        if (i2c_led_q[i2c_led_q_s] == I2C_Q_CRWL) {
             i2c_led_q_s_advance();
             uint8_t drvid = i2c_led_q[i2c_led_q_s];
-#if I2C_LED_USE_DMA == 1
+#    if I2C_LED_USE_DMA == 1
             i2c_led_send_CRWL_dma(drvid);
-#else
-            i2c_led_send_CRWL(drvid);
-#endif
-        }
-        else if (i2c_led_q[i2c_led_q_s] == I2C_Q_PAGE_SELECT)
-        {
+#    else
+        i2c_led_send_CRWL(drvid);
+#    endif
+        } else if (i2c_led_q[i2c_led_q_s] == I2C_Q_PAGE_SELECT) {
             i2c_led_q_s_advance();
             uint8_t drvid = i2c_led_q[i2c_led_q_s];
             i2c_led_q_s_advance();
             uint8_t page = i2c_led_q[i2c_led_q_s];
-#if I2C_LED_USE_DMA == 1
+#    if I2C_LED_USE_DMA == 1
             i2c_led_select_page_dma(drvid, page);
-#else
-            i2c_led_select_page(drvid, page);
-#endif
-        }
-        else if (i2c_led_q[i2c_led_q_s] == I2C_Q_PWM)
-        {
+#    else
+        i2c_led_select_page(drvid, page);
+#    endif
+        } else if (i2c_led_q[i2c_led_q_s] == I2C_Q_PWM) {
             i2c_led_q_s_advance();
             uint8_t drvid = i2c_led_q[i2c_led_q_s];
-#if I2C_LED_USE_DMA == 1
+#    if I2C_LED_USE_DMA == 1
             i2c_led_send_pwm_dma(drvid);
-#else
-            i2c_led_send_pwm(drvid);
-#endif
-        }
-        else if (i2c_led_q[i2c_led_q_s] == I2C_Q_GCR)
-        {
+#    else
+        i2c_led_send_pwm(drvid);
+#    endif
+        } else if (i2c_led_q[i2c_led_q_s] == I2C_Q_GCR) {
             i2c_led_q_s_advance();
             uint8_t drvid = i2c_led_q[i2c_led_q_s];
-#if I2C_LED_USE_DMA == 1
+#    if I2C_LED_USE_DMA == 1
             i2c_led_send_GCR_dma(drvid);
-#else
-            i2c_led_send_GCR(drvid);
-#endif
-        }
-        else if (i2c_led_q[i2c_led_q_s] == I2C_Q_ONOFF)
-        {
+#    else
+        i2c_led_send_GCR(drvid);
+#    endif
+        } else if (i2c_led_q[i2c_led_q_s] == I2C_Q_ONOFF) {
             i2c_led_q_s_advance();
             uint8_t drvid = i2c_led_q[i2c_led_q_s];
-#if I2C_LED_USE_DMA == 1
+#    if I2C_LED_USE_DMA == 1
             i2c_led_send_onoff_dma(drvid);
-#else
-            i2c_led_send_onoff(drvid);
-#endif
+#    else
+        i2c_led_send_onoff(drvid);
+#    endif
         }
 
-        i2c_led_q_s_advance(); //Advance last run command or if the command byte was not serviced
+        i2c_led_q_s_advance();  // Advance last run command or if the command byte was not serviced
 
-#if I2C_LED_USE_DMA != 1
+#    if I2C_LED_USE_DMA != 1
     }
 
     i2c_led_q_running = 0;
-#endif
+#    endif
 
     return 1;
 }
-#endif // !defined(MD_BOOTLOADER) && defined(RGB_MATRIX_ENABLE)
+#endif  // !defined(MD_BOOTLOADER) && defined(RGB_MATRIX_ENABLE)
diff --git a/tmk_core/protocol/arm_atsam/i2c_master.h b/tmk_core/protocol/arm_atsam/i2c_master.h
index 99481366a..44dbdfbff 100644
--- a/tmk_core/protocol/arm_atsam/i2c_master.h
+++ b/tmk_core/protocol/arm_atsam/i2c_master.h
@@ -20,89 +20,85 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 #ifndef MD_BOOTLOADER
 
-#include "samd51j18a.h"
-#include "issi3733_driver.h"
-#include "config.h"
+#    include "samd51j18a.h"
+#    include "issi3733_driver.h"
+#    include "config.h"
 
-__attribute__((__aligned__(16)))
-DmacDescriptor dmac_desc;
-__attribute__((__aligned__(16)))
-DmacDescriptor dmac_desc_wb;
+__attribute__((__aligned__(16))) DmacDescriptor dmac_desc;
+__attribute__((__aligned__(16))) DmacDescriptor dmac_desc_wb;
 
 uint8_t I2C3733_Init_Control(void);
 uint8_t I2C3733_Init_Drivers(void);
-void I2C3733_Control_Set(uint8_t state);
-void I2C_DMAC_LED_Init(void);
+void    I2C3733_Control_Set(uint8_t state);
+void    I2C_DMAC_LED_Init(void);
 
-#define I2C_Q_SIZE              100
+#    define I2C_Q_SIZE 100
 
-#define I2C_Q_NA                100
-#define I2C_Q_CRWL              101
-#define I2C_Q_PAGE_SELECT       102
-#define I2C_Q_PWM               103
-#define I2C_Q_GCR               104
-#define I2C_Q_ONOFF             105
+#    define I2C_Q_NA 100
+#    define I2C_Q_CRWL 101
+#    define I2C_Q_PAGE_SELECT 102
+#    define I2C_Q_PWM 103
+#    define I2C_Q_GCR 104
+#    define I2C_Q_ONOFF 105
 
-#define I2C_DMA_MAX_SEND        255
+#    define I2C_DMA_MAX_SEND 255
 
 extern volatile uint8_t i2c_led_q_running;
 
-#define I2C_LED_Q_PWM(a)    { \
-                                if (i2c_led_q_request_room(7)) \
-                                { \
-                                    i2c_led_q_add(I2C_Q_CRWL); \
-                                    i2c_led_q_add(a); \
-                                    i2c_led_q_add(I2C_Q_PAGE_SELECT); \
-                                    i2c_led_q_add(a); \
-                                    i2c_led_q_add(ISSI3733_PG_PWM); \
-                                    i2c_led_q_add(I2C_Q_PWM); \
-                                    i2c_led_q_add(a); \
-                                } \
-                            }
-
-#define I2C_LED_Q_GCR(a)    { \
-                                if (i2c_led_q_request_room(7)) \
-                                { \
-                                    i2c_led_q_add(I2C_Q_CRWL); \
-                                    i2c_led_q_add(a); \
-                                    i2c_led_q_add(I2C_Q_PAGE_SELECT); \
-                                    i2c_led_q_add(a); \
-                                    i2c_led_q_add(ISSI3733_PG_FN); \
-                                    i2c_led_q_add(I2C_Q_GCR); \
-                                    i2c_led_q_add(a); \
-                                } \
-                            }
-
-#define I2C_LED_Q_ONOFF(a)  { \
-                                if (i2c_led_q_request_room(7)) \
-                                { \
-                                    i2c_led_q_add(I2C_Q_CRWL); \
-                                    i2c_led_q_add(a); \
-                                    i2c_led_q_add(I2C_Q_PAGE_SELECT); \
-                                    i2c_led_q_add(a); \
-                                    i2c_led_q_add(ISSI3733_PG_ONOFF); \
-                                    i2c_led_q_add(I2C_Q_ONOFF); \
-                                    i2c_led_q_add(a); \
-                                } \
-                            }
-
-
-void i2c_led_q_init(void);
-void i2c_led_q_add(uint8_t cmd);
-void i2c_led_q_s_advance(void);
+#    define I2C_LED_Q_PWM(a)                      \
+        {                                         \
+            if (i2c_led_q_request_room(7)) {      \
+                i2c_led_q_add(I2C_Q_CRWL);        \
+                i2c_led_q_add(a);                 \
+                i2c_led_q_add(I2C_Q_PAGE_SELECT); \
+                i2c_led_q_add(a);                 \
+                i2c_led_q_add(ISSI3733_PG_PWM);   \
+                i2c_led_q_add(I2C_Q_PWM);         \
+                i2c_led_q_add(a);                 \
+            }                                     \
+        }
+
+#    define I2C_LED_Q_GCR(a)                      \
+        {                                         \
+            if (i2c_led_q_request_room(7)) {      \
+                i2c_led_q_add(I2C_Q_CRWL);        \
+                i2c_led_q_add(a);                 \
+                i2c_led_q_add(I2C_Q_PAGE_SELECT); \
+                i2c_led_q_add(a);                 \
+                i2c_led_q_add(ISSI3733_PG_FN);    \
+                i2c_led_q_add(I2C_Q_GCR);         \
+                i2c_led_q_add(a);                 \
+            }                                     \
+        }
+
+#    define I2C_LED_Q_ONOFF(a)                    \
+        {                                         \
+            if (i2c_led_q_request_room(7)) {      \
+                i2c_led_q_add(I2C_Q_CRWL);        \
+                i2c_led_q_add(a);                 \
+                i2c_led_q_add(I2C_Q_PAGE_SELECT); \
+                i2c_led_q_add(a);                 \
+                i2c_led_q_add(ISSI3733_PG_ONOFF); \
+                i2c_led_q_add(I2C_Q_ONOFF);       \
+                i2c_led_q_add(a);                 \
+            }                                     \
+        }
+
+void    i2c_led_q_init(void);
+void    i2c_led_q_add(uint8_t cmd);
+void    i2c_led_q_s_advance(void);
 uint8_t i2c_led_q_size(void);
 uint8_t i2c_led_q_request_room(uint8_t request_size);
 uint8_t i2c_led_q_run(void);
 
-void i2c1_init(void);
+void    i2c1_init(void);
 uint8_t i2c1_transmit(uint8_t address, uint8_t *data, uint16_t length, uint16_t timeout);
-void i2c1_stop(void);
+void    i2c1_stop(void);
 
-#endif //MD_BOOTLOADER
+#endif  // MD_BOOTLOADER
 
-void i2c0_init(void);
+void    i2c0_init(void);
 uint8_t i2c0_transmit(uint8_t address, uint8_t *data, uint16_t length, uint16_t timeout);
-void i2c0_stop(void);
-
-#endif // _I2C_MASTER_H_
+void    i2c0_stop(void);
 
+#endif  // _I2C_MASTER_H_
diff --git a/tmk_core/protocol/arm_atsam/issi3733_driver.h b/tmk_core/protocol/arm_atsam/issi3733_driver.h
index a537029f0..bd29fe76b 100644
--- a/tmk_core/protocol/arm_atsam/issi3733_driver.h
+++ b/tmk_core/protocol/arm_atsam/issi3733_driver.h
@@ -18,31 +18,31 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #ifndef _ISSI3733_DRIVER_H_
 #define _ISSI3733_DRIVER_H_
 
-//ISII3733 Registers
+// ISII3733 Registers
 
-#define ISSI3733_CMDR 0xFD                      //Command Register (Write Only)
+#define ISSI3733_CMDR 0xFD  // Command Register (Write Only)
 
-#define ISSI3733_CMDRWL 0xFE                    //Command Register Write Lock (Read/Write)
-#define ISSI3733_CMDRWL_WRITE_DISABLE 0x00      //Lock register
-#define ISSI3733_CMDRWL_WRITE_ENABLE_ONCE 0xC5  //Enable one write to register then reset to locked
+#define ISSI3733_CMDRWL 0xFE                    // Command Register Write Lock (Read/Write)
+#define ISSI3733_CMDRWL_WRITE_DISABLE 0x00      // Lock register
+#define ISSI3733_CMDRWL_WRITE_ENABLE_ONCE 0xC5  // Enable one write to register then reset to locked
 
-#define ISSI3733_IMR 0xF0                       //Interrupt Mask Register (Write Only)
-#define ISSI3733_IMR_IAC_ON 0x08                //Auto Clear Interrupt Bit - Interrupt auto clear when INTB stay low exceeds 8ms
-#define ISSI3733_IMR_IAB_ON 0x04                //Auto Breath Interrupt Bit - Enable auto breath loop finish interrupt
-#define ISSI3733_IMR_IS_ON 0x02                 //Dot Short Interrupt Bit - Enable dot short interrupt
-#define ISSI3733_IMR_IO_ON 0x01                 //Dot Open Interrupt Bit - Enable dot open interrupt
+#define ISSI3733_IMR 0xF0         // Interrupt Mask Register (Write Only)
+#define ISSI3733_IMR_IAC_ON 0x08  // Auto Clear Interrupt Bit - Interrupt auto clear when INTB stay low exceeds 8ms
+#define ISSI3733_IMR_IAB_ON 0x04  // Auto Breath Interrupt Bit - Enable auto breath loop finish interrupt
+#define ISSI3733_IMR_IS_ON 0x02   // Dot Short Interrupt Bit - Enable dot short interrupt
+#define ISSI3733_IMR_IO_ON 0x01   // Dot Open Interrupt Bit - Enable dot open interrupt
 
-#define ISSI3733_ISR 0xF1                       //Interrupt Status Register (Read Only)
-#define ISSI3733_ISR_ABM3_FINISH 0x10           //Auto Breath Mode 3 Finish Bit - ABM3 finished
-#define ISSI3733_ISR_ABM2_FINISH 0x08           //Auto Breath Mode 2 Finish Bit - ABM2 finished
-#define ISSI3733_ISR_ABM1_FINISH 0x04           //Auto Breath Mode 1 Finish Bit - ABM1 finished
-#define ISSI3733_ISR_SB 0x02                    //Short Bit - Shorted
-#define ISSI3733_ISR_OB 0x01                    //Open Bit - Opened
+#define ISSI3733_ISR 0xF1              // Interrupt Status Register (Read Only)
+#define ISSI3733_ISR_ABM3_FINISH 0x10  // Auto Breath Mode 3 Finish Bit - ABM3 finished
+#define ISSI3733_ISR_ABM2_FINISH 0x08  // Auto Breath Mode 2 Finish Bit - ABM2 finished
+#define ISSI3733_ISR_ABM1_FINISH 0x04  // Auto Breath Mode 1 Finish Bit - ABM1 finished
+#define ISSI3733_ISR_SB 0x02           // Short Bit - Shorted
+#define ISSI3733_ISR_OB 0x01           // Open Bit - Opened
 
-#define ISSI3733_PG0 0x00                       //LED Control Register
-#define ISSI3733_PG1 0x01                       //PWM Register
-#define ISSI3733_PG2 0x02                       //Auto Breath Mode Register
-#define ISSI3733_PG3 0x03                       //Function Register
+#define ISSI3733_PG0 0x00  // LED Control Register
+#define ISSI3733_PG1 0x01  // PWM Register
+#define ISSI3733_PG2 0x02  // Auto Breath Mode Register
+#define ISSI3733_PG3 0x03  // Function Register
 
 #define ISSI3733_PG_ONOFF ISSI3733_PG0
 #define ISSI3733_PG_OR ISSI3733_PG0
@@ -51,88 +51,88 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define ISSI3733_PG_ABM ISSI3733_PG2
 #define ISSI3733_PG_FN ISSI3733_PG3
 
-#define ISSI3733_CR 0x00                        //Configuration Register
+#define ISSI3733_CR 0x00  // Configuration Register
 
-//PG3: Configuration Register: Synchronize Configuration
-#define ISSI3733_CR_SYNC_MASTER 0x40            //Master
-#define ISSI3733_CR_SYNC_SLAVE 0x80             //Slave
-#define ISSI3733_CR_SYNC_HIGH_IMP 0xC0          //High Impedance
+// PG3: Configuration Register: Synchronize Configuration
+#define ISSI3733_CR_SYNC_MASTER 0x40    // Master
+#define ISSI3733_CR_SYNC_SLAVE 0x80     // Slave
+#define ISSI3733_CR_SYNC_HIGH_IMP 0xC0  // High Impedance
 
-//PG3: Configuration Register: Open/Short Detection Enable Bit
+// PG3: Configuration Register: Open/Short Detection Enable Bit
 //#define ISSI3733_CR_OSD_DISABLE 0x00          //Disable open/short detection
-#define ISSI3733_CR_OSD_ENABLE 0x04             //Enable open/short detection
+#define ISSI3733_CR_OSD_ENABLE 0x04  // Enable open/short detection
 
-//PG3: Configuration Register: Auto Breath Enable
+// PG3: Configuration Register: Auto Breath Enable
 //#define ISSI3733_CR_B_EN_PWM 0x00             //PWM Mode Enable
-#define ISSI3733_CR_B_EN_AUTO 0x02              //Auto Breath Mode Enable
+#define ISSI3733_CR_B_EN_AUTO 0x02  // Auto Breath Mode Enable
 
-//PG3: Configuration Register: Software Shutdown Control
+// PG3: Configuration Register: Software Shutdown Control
 //#define ISSI3733_CR_SSD_SHUTDOWN 0x00         //Software shutdown
-#define ISSI3733_CR_SSD_NORMAL 0x01             //Normal operation
-
-#define ISSI3733_GCCR 0x01              //Global Current Control Register
-
-//1 Byte, Iout = (GCC / 256) * (840 / Rext)
-//TODO: Give user define for Rext
-
-//PG3: Auto Breath Control Register 1
-#define ISSI3733_ABCR1_ABM1 0x02        //Auto Breath Control Register 1 of ABM-1
-#define ISSI3733_ABCR1_ABM2 0x06        //Auto Breath Control Register 1 of ABM-2
-#define ISSI3733_ABCR1_ABM3 0x0A        //Auto Breath Control Register 1 of ABM-3
-
-//Rise time
-#define ISSI3733_ABCR1_T1_0021 0x00     //0.21s
-#define ISSI3733_ABCR1_T1_0042 0x20     //0.42s
-#define ISSI3733_ABCR1_T1_0084 0x40     //0.84s
-#define ISSI3733_ABCR1_T1_0168 0x60     //1.68s
-#define ISSI3733_ABCR1_T1_0336 0x80     //3.36s
-#define ISSI3733_ABCR1_T1_0672 0xA0     //6.72s
-#define ISSI3733_ABCR1_T1_1344 0xC0     //13.44s
-#define ISSI3733_ABCR1_T1_2688 0xE0     //26.88s
-
-//Max value time
-#define ISSI3733_ABCR1_T2_0000 0x00     //0s
-#define ISSI3733_ABCR1_T2_0021 0x02     //0.21s
-#define ISSI3733_ABCR1_T2_0042 0x04     //0.42s
-#define ISSI3733_ABCR1_T2_0084 0x06     //0.84s
-#define ISSI3733_ABCR1_T2_0168 0x08     //1.68s
-#define ISSI3733_ABCR1_T2_0336 0x0A     //3.36s
-#define ISSI3733_ABCR1_T2_0672 0x0C     //6.72s
-#define ISSI3733_ABCR1_T2_1344 0x0E     //13.44s
-#define ISSI3733_ABCR1_T2_2688 0x10     //26.88s
-
-//PG3: Auto Breath Control Register 2
-#define ISSI3733_ABCR2_ABM1 0x03        //Auto Breath Control Register 2 of ABM-1
-#define ISSI3733_ABCR2_ABM2 0x07        //Auto Breath Control Register 2 of ABM-2
-#define ISSI3733_ABCR2_ABM3 0x0B        //Auto Breath Control Register 2 of ABM-3
-
-//Fall time
-#define ISSI3733_ABCR2_T3_0021 0x00     //0.21s
-#define ISSI3733_ABCR2_T3_0042 0x20     //0.42s
-#define ISSI3733_ABCR2_T3_0084 0x40     //0.84s
-#define ISSI3733_ABCR2_T3_0168 0x60     //1.68s
-#define ISSI3733_ABCR2_T3_0336 0x80     //3.36s
-#define ISSI3733_ABCR2_T3_0672 0xA0     //6.72s
-#define ISSI3733_ABCR2_T3_1344 0xC0     //13.44s
-#define ISSI3733_ABCR2_T3_2688 0xE0     //26.88s
-
-//Min value time
-#define ISSI3733_ABCR2_T4_0000 0x00     //0s
-#define ISSI3733_ABCR2_T4_0021 0x02     //0.21s
-#define ISSI3733_ABCR2_T4_0042 0x04     //0.42s
-#define ISSI3733_ABCR2_T4_0084 0x06     //0.84s
-#define ISSI3733_ABCR2_T4_0168 0x08     //1.68s
-#define ISSI3733_ABCR2_T4_0336 0x0A     //3.36s
-#define ISSI3733_ABCR2_T4_0672 0x0C     //6.72s
-#define ISSI3733_ABCR2_T4_1344 0x0E     //13.44s
-#define ISSI3733_ABCR2_T4_2688 0x10     //26.88s
-#define ISSI3733_ABCR2_T4_5376 0x12     //53.76s
-#define ISSI3733_ABCR2_T4_10752 0x14    //107.52s
-
-//PG3: Auto Breath Control Register 3
-#define ISSI3733_ABCR3_ABM1 0x04        //Auto Breath Control Register 3 of ABM-1
-#define ISSI3733_ABCR3_ABM2 0x08        //Auto Breath Control Register 3 of ABM-2
-#define ISSI3733_ABCR3_ABM3 0x0C        //Auto Breath Control Register 3 of ABM-3
+#define ISSI3733_CR_SSD_NORMAL 0x01  // Normal operation
+
+#define ISSI3733_GCCR 0x01  // Global Current Control Register
+
+// 1 Byte, Iout = (GCC / 256) * (840 / Rext)
+// TODO: Give user define for Rext
+
+// PG3: Auto Breath Control Register 1
+#define ISSI3733_ABCR1_ABM1 0x02  // Auto Breath Control Register 1 of ABM-1
+#define ISSI3733_ABCR1_ABM2 0x06  // Auto Breath Control Register 1 of ABM-2
+#define ISSI3733_ABCR1_ABM3 0x0A  // Auto Breath Control Register 1 of ABM-3
+
+// Rise time
+#define ISSI3733_ABCR1_T1_0021 0x00  // 0.21s
+#define ISSI3733_ABCR1_T1_0042 0x20  // 0.42s
+#define ISSI3733_ABCR1_T1_0084 0x40  // 0.84s
+#define ISSI3733_ABCR1_T1_0168 0x60  // 1.68s
+#define ISSI3733_ABCR1_T1_0336 0x80  // 3.36s
+#define ISSI3733_ABCR1_T1_0672 0xA0  // 6.72s
+#define ISSI3733_ABCR1_T1_1344 0xC0  // 13.44s
+#define ISSI3733_ABCR1_T1_2688 0xE0  // 26.88s
+
+// Max value time
+#define ISSI3733_ABCR1_T2_0000 0x00  // 0s
+#define ISSI3733_ABCR1_T2_0021 0x02  // 0.21s
+#define ISSI3733_ABCR1_T2_0042 0x04  // 0.42s
+#define ISSI3733_ABCR1_T2_0084 0x06  // 0.84s
+#define ISSI3733_ABCR1_T2_0168 0x08  // 1.68s
+#define ISSI3733_ABCR1_T2_0336 0x0A  // 3.36s
+#define ISSI3733_ABCR1_T2_0672 0x0C  // 6.72s
+#define ISSI3733_ABCR1_T2_1344 0x0E  // 13.44s
+#define ISSI3733_ABCR1_T2_2688 0x10  // 26.88s
+
+// PG3: Auto Breath Control Register 2
+#define ISSI3733_ABCR2_ABM1 0x03  // Auto Breath Control Register 2 of ABM-1
+#define ISSI3733_ABCR2_ABM2 0x07  // Auto Breath Control Register 2 of ABM-2
+#define ISSI3733_ABCR2_ABM3 0x0B  // Auto Breath Control Register 2 of ABM-3
+
+// Fall time
+#define ISSI3733_ABCR2_T3_0021 0x00  // 0.21s
+#define ISSI3733_ABCR2_T3_0042 0x20  // 0.42s
+#define ISSI3733_ABCR2_T3_0084 0x40  // 0.84s
+#define ISSI3733_ABCR2_T3_0168 0x60  // 1.68s
+#define ISSI3733_ABCR2_T3_0336 0x80  // 3.36s
+#define ISSI3733_ABCR2_T3_0672 0xA0  // 6.72s
+#define ISSI3733_ABCR2_T3_1344 0xC0  // 13.44s
+#define ISSI3733_ABCR2_T3_2688 0xE0  // 26.88s
+
+// Min value time
+#define ISSI3733_ABCR2_T4_0000 0x00   // 0s
+#define ISSI3733_ABCR2_T4_0021 0x02   // 0.21s
+#define ISSI3733_ABCR2_T4_0042 0x04   // 0.42s
+#define ISSI3733_ABCR2_T4_0084 0x06   // 0.84s
+#define ISSI3733_ABCR2_T4_0168 0x08   // 1.68s
+#define ISSI3733_ABCR2_T4_0336 0x0A   // 3.36s
+#define ISSI3733_ABCR2_T4_0672 0x0C   // 6.72s
+#define ISSI3733_ABCR2_T4_1344 0x0E   // 13.44s
+#define ISSI3733_ABCR2_T4_2688 0x10   // 26.88s
+#define ISSI3733_ABCR2_T4_5376 0x12   // 53.76s
+#define ISSI3733_ABCR2_T4_10752 0x14  // 107.52s
+
+// PG3: Auto Breath Control Register 3
+#define ISSI3733_ABCR3_ABM1 0x04  // Auto Breath Control Register 3 of ABM-1
+#define ISSI3733_ABCR3_ABM2 0x08  // Auto Breath Control Register 3 of ABM-2
+#define ISSI3733_ABCR3_ABM3 0x0C  // Auto Breath Control Register 3 of ABM-3
 
 #define ISSI3733_ABCR3_LTA_LOOP_ENDLESS 0x00
 #define ISSI3733_ABCR3_LTA_LOOP_1 0x01
@@ -151,51 +151,51 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define ISSI3733_ABCR3_LTA_LOOP_14 0x0E
 #define ISSI3733_ABCR3_LTA_LOOP_15 0x0F
 
-//Loop Begin
+// Loop Begin
 #define ISSI3733_ABCR3_LB_T1 0x00
 #define ISSI3733_ABCR3_LB_T2 0x10
 #define ISSI3733_ABCR3_LB_T3 0x20
 #define ISSI3733_ABCR3_LB_T4 0x30
 
-//Loop End
-#define ISSI3733_ABCR3_LE_T3 0x00       //End at Off state
-#define ISSI3733_ABCR3_LE_T1 0x40       //End at On State
+// Loop End
+#define ISSI3733_ABCR3_LE_T3 0x00  // End at Off state
+#define ISSI3733_ABCR3_LE_T1 0x40  // End at On State
 
-//PG3: Auto Breath Control Register 4
-#define ISSI3733_ABCR4_ABM1 0x05        //Auto Breath Control Register 4 of ABM-1
-#define ISSI3733_ABCR4_ABM2 0x09        //Auto Breath Control Register 4 of ABM-2
-#define ISSI3733_ABCR4_ABM3 0x0D        //Auto Breath Control Register 4 of ABM-3
+// PG3: Auto Breath Control Register 4
+#define ISSI3733_ABCR4_ABM1 0x05  // Auto Breath Control Register 4 of ABM-1
+#define ISSI3733_ABCR4_ABM2 0x09  // Auto Breath Control Register 4 of ABM-2
+#define ISSI3733_ABCR4_ABM3 0x0D  // Auto Breath Control Register 4 of ABM-3
 
 #define ISSI3733_ABCR4_LTB_LOOP_ENDLESS 0x00
-//Or 8bit loop times
+// Or 8bit loop times
 
-//PG3: Time Update Register
+// PG3: Time Update Register
 #define ISSI3733_TUR 0x0E
-#define ISSI3733_TUR_UPDATE 0x00        //Write to update 02h~0Dh time registers after configuring
+#define ISSI3733_TUR_UPDATE 0x00  // Write to update 02h~0Dh time registers after configuring
 
-//PG3: SWy Pull-Up Resistor Selection Register
+// PG3: SWy Pull-Up Resistor Selection Register
 #define ISSI3733_SWYR_PUR 0x0F
-#define ISSI3733_SWYR_PUR_NONE 0x00     //No pull-up resistor
-#define ISSI3733_SWYR_PUR_500 0x01      //0.5k Ohm
-#define ISSI3733_SWYR_PUR_1000 0x02     //1.0k Ohm
-#define ISSI3733_SWYR_PUR_2000 0x03     //2.0k Ohm
-#define ISSI3733_SWYR_PUR_4000 0x04     //4.0k Ohm
-#define ISSI3733_SWYR_PUR_8000 0x05     //8.0k Ohm
-#define ISSI3733_SWYR_PUR_16000 0x06    //16k Ohm
-#define ISSI3733_SWYR_PUR_32000 0x07    //32k Ohm
-
-//PG3: CSx Pull-Down Resistor Selection Register
+#define ISSI3733_SWYR_PUR_NONE 0x00   // No pull-up resistor
+#define ISSI3733_SWYR_PUR_500 0x01    // 0.5k Ohm
+#define ISSI3733_SWYR_PUR_1000 0x02   // 1.0k Ohm
+#define ISSI3733_SWYR_PUR_2000 0x03   // 2.0k Ohm
+#define ISSI3733_SWYR_PUR_4000 0x04   // 4.0k Ohm
+#define ISSI3733_SWYR_PUR_8000 0x05   // 8.0k Ohm
+#define ISSI3733_SWYR_PUR_16000 0x06  // 16k Ohm
+#define ISSI3733_SWYR_PUR_32000 0x07  // 32k Ohm
+
+// PG3: CSx Pull-Down Resistor Selection Register
 #define ISSI3733_CSXR_PDR 0x10
-#define ISSI3733_CSXR_PDR_NONE 0x00     //No pull-down resistor
-#define ISSI3733_CSXR_PDR_500 0x01      //0.5k Ohm
-#define ISSI3733_CSXR_PDR_1000 0x02     //1.0k Ohm
-#define ISSI3733_CSXR_PDR_2000 0x03     //2.0k Ohm
-#define ISSI3733_CSXR_PDR_4000 0x04     //4.0k Ohm
-#define ISSI3733_CSXR_PDR_8000 0x05     //8.0k Ohm
-#define ISSI3733_CSXR_PDR_16000 0x06    //16k Ohm
-#define ISSI3733_CSXR_PDR_32000 0x07    //32k Ohm
-
-//PG3: Reset Register
-#define ISSI3733_RR 0x11                //Read to reset all registers to default values
-
-#endif //_ISSI3733_DRIVER_H_
+#define ISSI3733_CSXR_PDR_NONE 0x00   // No pull-down resistor
+#define ISSI3733_CSXR_PDR_500 0x01    // 0.5k Ohm
+#define ISSI3733_CSXR_PDR_1000 0x02   // 1.0k Ohm
+#define ISSI3733_CSXR_PDR_2000 0x03   // 2.0k Ohm
+#define ISSI3733_CSXR_PDR_4000 0x04   // 4.0k Ohm
+#define ISSI3733_CSXR_PDR_8000 0x05   // 8.0k Ohm
+#define ISSI3733_CSXR_PDR_16000 0x06  // 16k Ohm
+#define ISSI3733_CSXR_PDR_32000 0x07  // 32k Ohm
+
+// PG3: Reset Register
+#define ISSI3733_RR 0x11  // Read to reset all registers to default values
+
+#endif  //_ISSI3733_DRIVER_H_
diff --git a/tmk_core/protocol/arm_atsam/led_matrix.c b/tmk_core/protocol/arm_atsam/led_matrix.c
index 42dfccbc5..c078980d6 100644
--- a/tmk_core/protocol/arm_atsam/led_matrix.c
+++ b/tmk_core/protocol/arm_atsam/led_matrix.c
@@ -22,24 +22,18 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include <math.h>
 
 #ifdef USE_MASSDROP_CONFIGURATOR
-__attribute__((weak))
-led_instruction_t led_instructions[] = { { .end = 1 } };
-static void led_matrix_massdrop_config_override(int i);
-#endif // USE_MASSDROP_CONFIGURATOR
+__attribute__((weak)) led_instruction_t led_instructions[] = {{.end = 1}};
+static void                             led_matrix_massdrop_config_override(int i);
+#endif  // USE_MASSDROP_CONFIGURATOR
 
-
-void SERCOM1_0_Handler( void )
-{
-    if (SERCOM1->I2CM.INTFLAG.bit.ERROR)
-    {
+void SERCOM1_0_Handler(void) {
+    if (SERCOM1->I2CM.INTFLAG.bit.ERROR) {
         SERCOM1->I2CM.INTFLAG.reg = SERCOM_I2CM_INTENCLR_ERROR;
     }
 }
 
-void DMAC_0_Handler( void )
-{
-    if (DMAC->Channel[0].CHINTFLAG.bit.TCMPL)
-    {
+void DMAC_0_Handler(void) {
+    if (DMAC->Channel[0].CHINTFLAG.bit.TCMPL) {
         DMAC->Channel[0].CHINTFLAG.reg = DMAC_CHINTENCLR_TCMPL;
 
         i2c1_stop();
@@ -51,8 +45,7 @@ void DMAC_0_Handler( void )
         return;
     }
 
-    if (DMAC->Channel[0].CHINTFLAG.bit.TERR)
-    {
+    if (DMAC->Channel[0].CHINTFLAG.bit.TERR) {
         DMAC->Channel[0].CHINTFLAG.reg = DMAC_CHINTENCLR_TERR;
     }
 }
@@ -60,118 +53,109 @@ void DMAC_0_Handler( void )
 issi3733_driver_t issidrv[ISSI3733_DRIVER_COUNT];
 
 issi3733_led_t led_map[ISSI3733_LED_COUNT] = ISSI3733_LED_MAP;
-RGB led_buffer[ISSI3733_LED_COUNT];
+RGB            led_buffer[ISSI3733_LED_COUNT];
 
 uint8_t gcr_desired;
 uint8_t gcr_actual;
 uint8_t gcr_actual_last;
 #ifdef USE_MASSDROP_CONFIGURATOR
 uint8_t gcr_breathe;
-float breathe_mult;
-float pomod;
+float   breathe_mult;
+float   pomod;
 #endif
 
-#define ACT_GCR_NONE    0
-#define ACT_GCR_INC     1
-#define ACT_GCR_DEC     2
+#define ACT_GCR_NONE 0
+#define ACT_GCR_INC 1
+#define ACT_GCR_DEC 2
 
 #define LED_GCR_STEP_AUTO 2
 
 static uint8_t gcr_min_counter;
 static uint8_t v_5v_cat_hit;
 
-//WARNING: Automatic GCR is in place to prevent USB shutdown and LED driver overloading
-void gcr_compute(void)
-{
-    uint8_t action = ACT_GCR_NONE;
+// WARNING: Automatic GCR is in place to prevent USB shutdown and LED driver overloading
+void gcr_compute(void) {
+    uint8_t action  = ACT_GCR_NONE;
     uint8_t gcr_use = gcr_desired;
 
 #ifdef USE_MASSDROP_CONFIGURATOR
-    if (led_animation_breathing)
-    {
+    if (led_animation_breathing) {
         gcr_use = gcr_breathe;
     }
 #endif
 
-    //If the 5v takes a catastrophic hit, disable the LED drivers briefly, assert auto gcr mode, min gcr and let the auto take over
-    if (v_5v < V5_CAT)
-    {
+    // If the 5v takes a catastrophic hit, disable the LED drivers briefly, assert auto gcr mode, min gcr and let the auto take over
+    if (v_5v < V5_CAT) {
         I2C3733_Control_Set(0);
-        //CDC_print("USB: WARNING: 5V catastrophic level reached! Disabling LED drivers!\r\n"); //Blocking print is bad here!
-        v_5v_cat_hit = 20; //~100ms recover
-        gcr_actual = 0; //Minimize GCR
-        usb_gcr_auto = 1; //Force auto mode enabled
+        // CDC_print("USB: WARNING: 5V catastrophic level reached! Disabling LED drivers!\r\n"); //Blocking print is bad here!
+        v_5v_cat_hit = 20;  //~100ms recover
+        gcr_actual   = 0;   // Minimize GCR
+        usb_gcr_auto = 1;   // Force auto mode enabled
         return;
-    }
-    else if (v_5v_cat_hit > 1)
-    {
+    } else if (v_5v_cat_hit > 1) {
         v_5v_cat_hit--;
         return;
-    }
-    else if (v_5v_cat_hit == 1)
-    {
+    } else if (v_5v_cat_hit == 1) {
         I2C3733_Control_Set(1);
         CDC_print("USB: WARNING: Re-enabling LED drivers\r\n");
         v_5v_cat_hit = 0;
         return;
     }
 
-    if (usb_gcr_auto)
-    {
-        if (v_5v_avg < V5_LOW) action = ACT_GCR_DEC;
-        else if (v_5v_avg > V5_HIGH && gcr_actual < gcr_use) action = ACT_GCR_INC;
-        else if (gcr_actual > gcr_use) action = ACT_GCR_DEC;
-    }
-    else
-    {
-        if (gcr_actual < gcr_use) action = ACT_GCR_INC;
-        else if (gcr_actual > gcr_use) action = ACT_GCR_DEC;
+    if (usb_gcr_auto) {
+        if (v_5v_avg < V5_LOW)
+            action = ACT_GCR_DEC;
+        else if (v_5v_avg > V5_HIGH && gcr_actual < gcr_use)
+            action = ACT_GCR_INC;
+        else if (gcr_actual > gcr_use)
+            action = ACT_GCR_DEC;
+    } else {
+        if (gcr_actual < gcr_use)
+            action = ACT_GCR_INC;
+        else if (gcr_actual > gcr_use)
+            action = ACT_GCR_DEC;
     }
 
-    if (action == ACT_GCR_NONE)
-    {
+    if (action == ACT_GCR_NONE) {
         gcr_min_counter = 0;
-    }
-    else if (action == ACT_GCR_INC)
-    {
-        if (LED_GCR_STEP_AUTO > LED_GCR_MAX - gcr_actual) gcr_actual = LED_GCR_MAX; //Obey max and prevent wrapping
-        else gcr_actual += LED_GCR_STEP_AUTO;
+    } else if (action == ACT_GCR_INC) {
+        if (LED_GCR_STEP_AUTO > LED_GCR_MAX - gcr_actual)
+            gcr_actual = LED_GCR_MAX;  // Obey max and prevent wrapping
+        else
+            gcr_actual += LED_GCR_STEP_AUTO;
         gcr_min_counter = 0;
-    }
-    else if (action == ACT_GCR_DEC)
-    {
-        if (LED_GCR_STEP_AUTO > gcr_actual) //Prevent wrapping
+    } else if (action == ACT_GCR_DEC) {
+        if (LED_GCR_STEP_AUTO > gcr_actual)  // Prevent wrapping
         {
             gcr_actual = 0;
-            //At this point, power can no longer be cut from the LED drivers, so focus on cutting out extra port if active
-            if (usb_extra_state != USB_EXTRA_STATE_DISABLED_UNTIL_REPLUG) //If not in a wait for replug state
+            // At this point, power can no longer be cut from the LED drivers, so focus on cutting out extra port if active
+            if (usb_extra_state != USB_EXTRA_STATE_DISABLED_UNTIL_REPLUG)  // If not in a wait for replug state
             {
-                if (usb_extra_state == USB_EXTRA_STATE_ENABLED) //If extra usb is enabled
+                if (usb_extra_state == USB_EXTRA_STATE_ENABLED)  // If extra usb is enabled
                 {
                     gcr_min_counter++;
-                    if (gcr_min_counter > 200) //5ms per check = 1s delay
+                    if (gcr_min_counter > 200)  // 5ms per check = 1s delay
                     {
                         USB_ExtraSetState(USB_EXTRA_STATE_DISABLED_UNTIL_REPLUG);
-                        usb_extra_manual = 0; //Force disable manual mode of extra port
-                        if (usb_extra_manual) CDC_print("USB: Disabling extra port until replug and manual mode toggle!\r\n");
-                        else CDC_print("USB: Disabling extra port until replug!\r\n");
+                        usb_extra_manual = 0;  // Force disable manual mode of extra port
+                        if (usb_extra_manual)
+                            CDC_print("USB: Disabling extra port until replug and manual mode toggle!\r\n");
+                        else
+                            CDC_print("USB: Disabling extra port until replug!\r\n");
                     }
                 }
             }
-        }
-        else
-        {
-            //Power successfully cut back from LED drivers
+        } else {
+            // Power successfully cut back from LED drivers
             gcr_actual -= LED_GCR_STEP_AUTO;
             gcr_min_counter = 0;
 
 #ifdef USE_MASSDROP_CONFIGURATOR
-            //If breathe mode is active, the top end can fluctuate if the host can not supply enough current
-            //So set the breathe GCR to where it becomes stable
-            if (led_animation_breathing == 1)
-            {
+            // If breathe mode is active, the top end can fluctuate if the host can not supply enough current
+            // So set the breathe GCR to where it becomes stable
+            if (led_animation_breathing == 1) {
                 gcr_breathe = gcr_actual;
-                //PS: At this point, setting breathing to exhale makes a noticebly shorter cycle
+                // PS: At this point, setting breathing to exhale makes a noticebly shorter cycle
                 //    and the same would happen maybe one or two more times. Therefore I'm favoring
                 //    powering through one full breathe and letting gcr settle completely
             }
@@ -180,47 +164,40 @@ void gcr_compute(void)
     }
 }
 
-void issi3733_prepare_arrays(void)
-{
-    memset(issidrv,0,sizeof(issi3733_driver_t) * ISSI3733_DRIVER_COUNT);
+void issi3733_prepare_arrays(void) {
+    memset(issidrv, 0, sizeof(issi3733_driver_t) * ISSI3733_DRIVER_COUNT);
 
-    int i;
+    int     i;
     uint8_t addrs[ISSI3733_DRIVER_COUNT] = ISSI3773_DRIVER_ADDRESSES;
 
-    for (i=0;i<ISSI3733_DRIVER_COUNT;i++)
-    {
+    for (i = 0; i < ISSI3733_DRIVER_COUNT; i++) {
         issidrv[i].addr = addrs[i];
     }
 
-    for (uint8_t i = 0; i < ISSI3733_LED_COUNT; i++)
-    {
-        //BYTE: 1 + (SW-1)*16 + (CS-1)
-        led_map[i].rgb.g = issidrv[led_map[i].adr.drv-1].pwm + 1 + ((led_map[i].adr.swg-1)*16 + (led_map[i].adr.cs-1));
-        led_map[i].rgb.r = issidrv[led_map[i].adr.drv-1].pwm + 1 + ((led_map[i].adr.swr-1)*16 + (led_map[i].adr.cs-1));
-        led_map[i].rgb.b = issidrv[led_map[i].adr.drv-1].pwm + 1 + ((led_map[i].adr.swb-1)*16 + (led_map[i].adr.cs-1));
-
-        //BYTE: 1 + (SW-1)*2 + (CS-1)/8
-        //BIT: (CS-1)%8
-        *(issidrv[led_map[i].adr.drv-1].onoff + 1 + (led_map[i].adr.swg-1)*2+(led_map[i].adr.cs-1)/8) |= (1<<((led_map[i].adr.cs-1)%8));
-        *(issidrv[led_map[i].adr.drv-1].onoff + 1 + (led_map[i].adr.swr-1)*2+(led_map[i].adr.cs-1)/8) |= (1<<((led_map[i].adr.cs-1)%8));
-        *(issidrv[led_map[i].adr.drv-1].onoff + 1 + (led_map[i].adr.swb-1)*2+(led_map[i].adr.cs-1)/8) |= (1<<((led_map[i].adr.cs-1)%8));
+    for (uint8_t i = 0; i < ISSI3733_LED_COUNT; i++) {
+        // BYTE: 1 + (SW-1)*16 + (CS-1)
+        led_map[i].rgb.g = issidrv[led_map[i].adr.drv - 1].pwm + 1 + ((led_map[i].adr.swg - 1) * 16 + (led_map[i].adr.cs - 1));
+        led_map[i].rgb.r = issidrv[led_map[i].adr.drv - 1].pwm + 1 + ((led_map[i].adr.swr - 1) * 16 + (led_map[i].adr.cs - 1));
+        led_map[i].rgb.b = issidrv[led_map[i].adr.drv - 1].pwm + 1 + ((led_map[i].adr.swb - 1) * 16 + (led_map[i].adr.cs - 1));
+
+        // BYTE: 1 + (SW-1)*2 + (CS-1)/8
+        // BIT: (CS-1)%8
+        *(issidrv[led_map[i].adr.drv - 1].onoff + 1 + (led_map[i].adr.swg - 1) * 2 + (led_map[i].adr.cs - 1) / 8) |= (1 << ((led_map[i].adr.cs - 1) % 8));
+        *(issidrv[led_map[i].adr.drv - 1].onoff + 1 + (led_map[i].adr.swr - 1) * 2 + (led_map[i].adr.cs - 1) / 8) |= (1 << ((led_map[i].adr.cs - 1) % 8));
+        *(issidrv[led_map[i].adr.drv - 1].onoff + 1 + (led_map[i].adr.swb - 1) * 2 + (led_map[i].adr.cs - 1) / 8) |= (1 << ((led_map[i].adr.cs - 1) % 8));
     }
 }
 
-void led_matrix_prepare(void)
-{
-    for (uint8_t i = 0; i < ISSI3733_LED_COUNT; i++)
-    {
+void led_matrix_prepare(void) {
+    for (uint8_t i = 0; i < ISSI3733_LED_COUNT; i++) {
         *led_map[i].rgb.r = 0;
         *led_map[i].rgb.g = 0;
         *led_map[i].rgb.b = 0;
     }
 }
 
-void led_set_one(int i, uint8_t r, uint8_t g, uint8_t b)
-{
-    if (i < ISSI3733_LED_COUNT)
-    {
+void led_set_one(int i, uint8_t r, uint8_t g, uint8_t b) {
+    if (i < ISSI3733_LED_COUNT) {
 #ifdef USE_MASSDROP_CONFIGURATOR
         led_matrix_massdrop_config_override(i);
 #else
@@ -231,16 +208,13 @@ void led_set_one(int i, uint8_t r, uint8_t g, uint8_t b)
     }
 }
 
-void led_set_all(uint8_t r, uint8_t g, uint8_t b)
-{
-  for (uint8_t i = 0; i < ISSI3733_LED_COUNT; i++)
-  {
-    led_set_one(i, r, g, b);
-  }
+void led_set_all(uint8_t r, uint8_t g, uint8_t b) {
+    for (uint8_t i = 0; i < ISSI3733_LED_COUNT; i++) {
+        led_set_one(i, r, g, b);
+    }
 }
 
-void init(void)
-{
+void init(void) {
     DBGC(DC_LED_MATRIX_INIT_BEGIN);
 
     issi3733_prepare_arrays();
@@ -248,25 +222,28 @@ void init(void)
     led_matrix_prepare();
 
     gcr_min_counter = 0;
-    v_5v_cat_hit = 0;
+    v_5v_cat_hit    = 0;
 
     DBGC(DC_LED_MATRIX_INIT_COMPLETE);
 }
 
-void flush(void)
-{
+void flush(void) {
 #ifdef USE_MASSDROP_CONFIGURATOR
-    if (!led_enabled) { return; } //Prevent calculations and I2C traffic if LED drivers are not enabled
+    if (!led_enabled) {
+        return;
+    }  // Prevent calculations and I2C traffic if LED drivers are not enabled
 #else
-    if (!sr_exp_data.bit.SDB_N) { return; } //Prevent calculations and I2C traffic if LED drivers are not enabled
+    if (!sr_exp_data.bit.SDB_N) {
+        return;
+    }  // Prevent calculations and I2C traffic if LED drivers are not enabled
 #endif
 
     // Wait for previous transfer to complete
-    while (i2c_led_q_running) {}
+    while (i2c_led_q_running) {
+    }
 
     // Copy buffer to live DMA region
-    for (uint8_t i = 0; i < ISSI3733_LED_COUNT; i++)
-    {
+    for (uint8_t i = 0; i < ISSI3733_LED_COUNT; i++) {
         *led_map[i].rgb.r = led_buffer[i].r;
         *led_map[i].rgb.g = led_buffer[i].g;
         *led_map[i].rgb.b = led_buffer[i].b;
@@ -275,8 +252,7 @@ void flush(void)
 #ifdef USE_MASSDROP_CONFIGURATOR
     breathe_mult = 1;
 
-    if (led_animation_breathing)
-    {
+    if (led_animation_breathing) {
         //+60us 119 LED
         led_animation_breathe_cur += BREATHE_STEP * breathe_dir;
 
@@ -285,76 +261,65 @@ void flush(void)
         else if (led_animation_breathe_cur <= BREATHE_MIN_STEP)
             breathe_dir = 1;
 
-        //Brightness curve created for 256 steps, 0 - ~98%
+        // Brightness curve created for 256 steps, 0 - ~98%
         breathe_mult = 0.000015 * led_animation_breathe_cur * led_animation_breathe_cur;
-        if (breathe_mult > 1) breathe_mult = 1;
-        else if (breathe_mult < 0) breathe_mult = 0;
+        if (breathe_mult > 1)
+            breathe_mult = 1;
+        else if (breathe_mult < 0)
+            breathe_mult = 0;
     }
 
-    //This should only be performed once per frame
+    // This should only be performed once per frame
     pomod = (float)((g_rgb_counters.tick / 10) % (uint32_t)(1000.0f / led_animation_speed)) / 10.0f * led_animation_speed;
     pomod *= 100.0f;
     pomod = (uint32_t)pomod % 10000;
     pomod /= 100.0f;
 
-#endif // USE_MASSDROP_CONFIGURATOR
+#endif  // USE_MASSDROP_CONFIGURATOR
 
     uint8_t drvid;
 
-    //NOTE: GCR does not need to be timed with LED processing, but there is really no harm
-    if (gcr_actual != gcr_actual_last)
-    {
-        for (drvid=0;drvid<ISSI3733_DRIVER_COUNT;drvid++)
-            I2C_LED_Q_GCR(drvid); //Queue data
+    // NOTE: GCR does not need to be timed with LED processing, but there is really no harm
+    if (gcr_actual != gcr_actual_last) {
+        for (drvid = 0; drvid < ISSI3733_DRIVER_COUNT; drvid++) I2C_LED_Q_GCR(drvid);  // Queue data
         gcr_actual_last = gcr_actual;
     }
 
-    for (drvid=0;drvid<ISSI3733_DRIVER_COUNT;drvid++)
-        I2C_LED_Q_PWM(drvid); //Queue data
+    for (drvid = 0; drvid < ISSI3733_DRIVER_COUNT; drvid++) I2C_LED_Q_PWM(drvid);  // Queue data
 
     i2c_led_q_run();
 }
 
-void led_matrix_indicators(void)
-{
+void led_matrix_indicators(void) {
     uint8_t kbled = keyboard_leds();
-    if (kbled && rgb_matrix_config.enable)
-    {
-        for (uint8_t i = 0; i < ISSI3733_LED_COUNT; i++)
-        {
+    if (kbled && rgb_matrix_config.enable) {
+        for (uint8_t i = 0; i < ISSI3733_LED_COUNT; i++) {
             if (
-            #if USB_LED_NUM_LOCK_SCANCODE != 255
-                (led_map[i].scan == USB_LED_NUM_LOCK_SCANCODE && (kbled & (1<<USB_LED_NUM_LOCK))) ||
-            #endif //NUM LOCK
-            #if USB_LED_CAPS_LOCK_SCANCODE != 255
-                (led_map[i].scan == USB_LED_CAPS_LOCK_SCANCODE && (kbled & (1<<USB_LED_CAPS_LOCK))) ||
-            #endif //CAPS LOCK
-            #if USB_LED_SCROLL_LOCK_SCANCODE != 255
-                (led_map[i].scan == USB_LED_SCROLL_LOCK_SCANCODE && (kbled & (1<<USB_LED_SCROLL_LOCK))) ||
-            #endif //SCROLL LOCK
-            #if USB_LED_COMPOSE_SCANCODE != 255
-                (led_map[i].scan == USB_LED_COMPOSE_SCANCODE && (kbled & (1<<USB_LED_COMPOSE))) ||
-            #endif //COMPOSE
-            #if USB_LED_KANA_SCANCODE != 255
-                (led_map[i].scan == USB_LED_KANA_SCANCODE && (kbled & (1<<USB_LED_KANA))) ||
-            #endif //KANA
-            (0))
-            {
+#if USB_LED_NUM_LOCK_SCANCODE != 255
+                (led_map[i].scan == USB_LED_NUM_LOCK_SCANCODE && (kbled & (1 << USB_LED_NUM_LOCK))) ||
+#endif  // NUM LOCK
+#if USB_LED_CAPS_LOCK_SCANCODE != 255
+                (led_map[i].scan == USB_LED_CAPS_LOCK_SCANCODE && (kbled & (1 << USB_LED_CAPS_LOCK))) ||
+#endif  // CAPS LOCK
+#if USB_LED_SCROLL_LOCK_SCANCODE != 255
+                (led_map[i].scan == USB_LED_SCROLL_LOCK_SCANCODE && (kbled & (1 << USB_LED_SCROLL_LOCK))) ||
+#endif  // SCROLL LOCK
+#if USB_LED_COMPOSE_SCANCODE != 255
+                (led_map[i].scan == USB_LED_COMPOSE_SCANCODE && (kbled & (1 << USB_LED_COMPOSE))) ||
+#endif  // COMPOSE
+#if USB_LED_KANA_SCANCODE != 255
+                (led_map[i].scan == USB_LED_KANA_SCANCODE && (kbled & (1 << USB_LED_KANA))) ||
+#endif  // KANA
+                (0)) {
                 led_buffer[i].r = 255 - led_buffer[i].r;
                 led_buffer[i].g = 255 - led_buffer[i].g;
                 led_buffer[i].b = 255 - led_buffer[i].b;
             }
         }
     }
-
 }
 
-const rgb_matrix_driver_t rgb_matrix_driver = {
-  .init = init,
-  .flush = flush,
-  .set_color = led_set_one,
-  .set_color_all = led_set_all
-};
+const rgb_matrix_driver_t rgb_matrix_driver = {.init = init, .flush = flush, .set_color = led_set_one, .set_color_all = led_set_all};
 
 /*==============================================================================
 =                           Legacy Lighting Support                            =
@@ -365,103 +330,100 @@ const rgb_matrix_driver_t rgb_matrix_driver = {
 
 // TODO?: wire these up to keymap.c
 uint8_t led_animation_orientation = 0;
-uint8_t led_animation_direction = 0;
-uint8_t led_animation_breathing = 0;
-uint8_t led_animation_id = 0;
-float led_animation_speed = 4.0f;
-uint8_t led_lighting_mode = LED_MODE_NORMAL;
-uint8_t led_enabled = 1;
+uint8_t led_animation_direction   = 0;
+uint8_t led_animation_breathing   = 0;
+uint8_t led_animation_id          = 0;
+float   led_animation_speed       = 4.0f;
+uint8_t led_lighting_mode         = LED_MODE_NORMAL;
+uint8_t led_enabled               = 1;
 uint8_t led_animation_breathe_cur = BREATHE_MIN_STEP;
-uint8_t breathe_dir = 1;
+uint8_t breathe_dir               = 1;
 
-static void led_run_pattern(led_setup_t *f, float* ro, float* go, float* bo, float pos) {
+static void led_run_pattern(led_setup_t* f, float* ro, float* go, float* bo, float pos) {
     float po;
 
-    while (f->end != 1)
-    {
-        po = pos; //Reset po for new frame
+    while (f->end != 1) {
+        po = pos;  // Reset po for new frame
 
-        //Add in any moving effects
-        if ((!led_animation_direction && f->ef & EF_SCR_R) || (led_animation_direction && (f->ef & EF_SCR_L)))
-        {
+        // Add in any moving effects
+        if ((!led_animation_direction && f->ef & EF_SCR_R) || (led_animation_direction && (f->ef & EF_SCR_L))) {
             po -= pomod;
 
-            if (po > 100) po -= 100;
-            else if (po < 0) po += 100;
-        }
-        else if ((!led_animation_direction && f->ef & EF_SCR_L) || (led_animation_direction && (f->ef & EF_SCR_R)))
-        {
+            if (po > 100)
+                po -= 100;
+            else if (po < 0)
+                po += 100;
+        } else if ((!led_animation_direction && f->ef & EF_SCR_L) || (led_animation_direction && (f->ef & EF_SCR_R))) {
             po += pomod;
 
-            if (po > 100) po -= 100;
-            else if (po < 0) po += 100;
+            if (po > 100)
+                po -= 100;
+            else if (po < 0)
+                po += 100;
         }
 
-        //Check if LED's po is in current frame
-        if (po < f->hs) { f++; continue; }
-        if (po > f->he) { f++; continue; }
-        //note: < 0 or > 100 continue
+        // Check if LED's po is in current frame
+        if (po < f->hs) {
+            f++;
+            continue;
+        }
+        if (po > f->he) {
+            f++;
+            continue;
+        }
+        // note: < 0 or > 100 continue
 
-        //Calculate the po within the start-stop percentage for color blending
+        // Calculate the po within the start-stop percentage for color blending
         po = (po - f->hs) / (f->he - f->hs);
 
-        //Add in any color effects
-        if (f->ef & EF_OVER)
-        {
-            *ro = (po * (f->re - f->rs)) + f->rs;// + 0.5;
-            *go = (po * (f->ge - f->gs)) + f->gs;// + 0.5;
-            *bo = (po * (f->be - f->bs)) + f->bs;// + 0.5;
-        }
-        else if (f->ef & EF_SUBTRACT)
-        {
-            *ro -= (po * (f->re - f->rs)) + f->rs;// + 0.5;
-            *go -= (po * (f->ge - f->gs)) + f->gs;// + 0.5;
-            *bo -= (po * (f->be - f->bs)) + f->bs;// + 0.5;
-        }
-        else
-        {
-            *ro += (po * (f->re - f->rs)) + f->rs;// + 0.5;
-            *go += (po * (f->ge - f->gs)) + f->gs;// + 0.5;
-            *bo += (po * (f->be - f->bs)) + f->bs;// + 0.5;
+        // Add in any color effects
+        if (f->ef & EF_OVER) {
+            *ro = (po * (f->re - f->rs)) + f->rs;  // + 0.5;
+            *go = (po * (f->ge - f->gs)) + f->gs;  // + 0.5;
+            *bo = (po * (f->be - f->bs)) + f->bs;  // + 0.5;
+        } else if (f->ef & EF_SUBTRACT) {
+            *ro -= (po * (f->re - f->rs)) + f->rs;  // + 0.5;
+            *go -= (po * (f->ge - f->gs)) + f->gs;  // + 0.5;
+            *bo -= (po * (f->be - f->bs)) + f->bs;  // + 0.5;
+        } else {
+            *ro += (po * (f->re - f->rs)) + f->rs;  // + 0.5;
+            *go += (po * (f->ge - f->gs)) + f->gs;  // + 0.5;
+            *bo += (po * (f->be - f->bs)) + f->bs;  // + 0.5;
         }
 
         f++;
     }
 }
 
-static void led_matrix_massdrop_config_override(int i)
-{
+static void led_matrix_massdrop_config_override(int i) {
     float ro = 0;
     float go = 0;
     float bo = 0;
 
-    float po = (led_animation_orientation)
-        ? (float)g_led_config.point[i].y / 64.f * 100
-        : (float)g_led_config.point[i].x / 224.f * 100;
+    float po = (led_animation_orientation) ? (float)g_led_config.point[i].y / 64.f * 100 : (float)g_led_config.point[i].x / 224.f * 100;
 
     uint8_t highest_active_layer = biton32(layer_state);
 
     if (led_lighting_mode == LED_MODE_KEYS_ONLY && HAS_FLAGS(g_led_config.flags[i], LED_FLAG_UNDERGLOW)) {
-        //Do not act on this LED
+        // Do not act on this LED
     } else if (led_lighting_mode == LED_MODE_NON_KEYS_ONLY && !HAS_FLAGS(g_led_config.flags[i], LED_FLAG_UNDERGLOW)) {
-        //Do not act on this LED
+        // Do not act on this LED
     } else if (led_lighting_mode == LED_MODE_INDICATORS_ONLY) {
-        //Do not act on this LED (Only show indicators)
+        // Do not act on this LED (Only show indicators)
     } else {
         led_instruction_t* led_cur_instruction = led_instructions;
         while (!led_cur_instruction->end) {
             // Check if this applies to current layer
-            if ((led_cur_instruction->flags & LED_FLAG_MATCH_LAYER) &&
-                (led_cur_instruction->layer != highest_active_layer)) {
+            if ((led_cur_instruction->flags & LED_FLAG_MATCH_LAYER) && (led_cur_instruction->layer != highest_active_layer)) {
                 goto next_iter;
             }
 
             // Check if this applies to current index
             if (led_cur_instruction->flags & LED_FLAG_MATCH_ID) {
-                uint8_t modid = i / 32;                                     //Calculate which id# contains the led bit
-                uint32_t modidbit = 1 << (i % 32);                          //Calculate the bit within the id#
-                uint32_t *bitfield = &led_cur_instruction->id0 + modid;     //Add modid as offset to id0 address. *bitfield is now idX of the led id
-                if (~(*bitfield) & modidbit) {                              //Check if led bit is not set in idX
+                uint8_t   modid    = i / 32;                             // Calculate which id# contains the led bit
+                uint32_t  modidbit = 1 << (i % 32);                      // Calculate the bit within the id#
+                uint32_t* bitfield = &led_cur_instruction->id0 + modid;  // Add modid as offset to id0 address. *bitfield is now idX of the led id
+                if (~(*bitfield) & modidbit) {                           // Check if led bit is not set in idX
                     goto next_iter;
                 }
             }
@@ -476,16 +438,24 @@ static void led_matrix_massdrop_config_override(int i)
                 led_run_pattern(led_setups[led_animation_id], &ro, &go, &bo, po);
             }
 
-            next_iter:
-                led_cur_instruction++;
+        next_iter:
+            led_cur_instruction++;
         }
 
-        if (ro > 255) ro = 255; else if (ro < 0) ro = 0;
-        if (go > 255) go = 255; else if (go < 0) go = 0;
-        if (bo > 255) bo = 255; else if (bo < 0) bo = 0;
-
-        if (led_animation_breathing)
-        {
+        if (ro > 255)
+            ro = 255;
+        else if (ro < 0)
+            ro = 0;
+        if (go > 255)
+            go = 255;
+        else if (go < 0)
+            go = 0;
+        if (bo > 255)
+            bo = 255;
+        else if (bo < 0)
+            bo = 0;
+
+        if (led_animation_breathing) {
             ro *= breathe_mult;
             go *= breathe_mult;
             bo *= breathe_mult;
@@ -497,4 +467,4 @@ static void led_matrix_massdrop_config_override(int i)
     led_buffer[i].b = (uint8_t)bo;
 }
 
-#endif // USE_MASSDROP_CONFIGURATOR
+#endif  // USE_MASSDROP_CONFIGURATOR
diff --git a/tmk_core/protocol/arm_atsam/led_matrix.h b/tmk_core/protocol/arm_atsam/led_matrix.h
index 1316efd9a..8eaa5623b 100644
--- a/tmk_core/protocol/arm_atsam/led_matrix.h
+++ b/tmk_core/protocol/arm_atsam/led_matrix.h
@@ -20,20 +20,20 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 #include "quantum.h"
 
-//From keyboard
+// From keyboard
 #include "config_led.h"
 
-//CS1-CS16 Current Source "Col"
+// CS1-CS16 Current Source "Col"
 #define ISSI3733_CS_COUNT 16
 
-//SW1-SW12 Switch "Row"
+// SW1-SW12 Switch "Row"
 #define ISSI3733_SW_COUNT 12
 
-#define ISSI3733_LED_RGB_COUNT ISSI3733_CS_COUNT * ISSI3733_SW_COUNT
-#define ISSI3733_PG0_BYTES ISSI3733_LED_RGB_COUNT / 8 + 1       //+1 for first byte being memory start offset for I2C transfer
-#define ISSI3733_PG1_BYTES ISSI3733_LED_RGB_COUNT + 1           //+1 for first byte being memory start offset for I2C transfer
-#define ISSI3733_PG2_BYTES ISSI3733_LED_RGB_COUNT + 1           //+1 for first byte being memory start offset for I2C transfer
-#define ISSI3733_PG3_BYTES 18 + 1                               //+1 for first byte being memory start offset for I2C transfer
+#define ISSI3733_LED_RGB_COUNT ISSI3733_CS_COUNT *ISSI3733_SW_COUNT
+#define ISSI3733_PG0_BYTES ISSI3733_LED_RGB_COUNT / 8 + 1  //+1 for first byte being memory start offset for I2C transfer
+#define ISSI3733_PG1_BYTES ISSI3733_LED_RGB_COUNT + 1      //+1 for first byte being memory start offset for I2C transfer
+#define ISSI3733_PG2_BYTES ISSI3733_LED_RGB_COUNT + 1      //+1 for first byte being memory start offset for I2C transfer
+#define ISSI3733_PG3_BYTES 18 + 1                          //+1 for first byte being memory start offset for I2C transfer
 
 #define ISSI3733_PG_ONOFF_BYTES ISSI3733_PG0_BYTES
 #define ISSI3733_PG_OR_BYTES ISSI3733_PG0_BYTES
@@ -43,38 +43,38 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define ISSI3733_PG_FN_BYTES ISSI3733_PG3_BYTES
 
 typedef struct issi3733_driver_s {
-    uint8_t addr; //Address of the driver according to wiring "ISSI3733: Table 1 Slave Address"
-    uint8_t onoff[ISSI3733_PG_ONOFF_BYTES]; //PG0 - LED Control Register - LED On/Off Register
-    uint8_t open[ISSI3733_PG_OR_BYTES];     //PG0 - LED Control Register - LED Open Register
-    uint8_t shrt[ISSI3733_PG_SR_BYTES];     //PG0 - LED Control Register - LED Short Register
-    uint8_t pwm[ISSI3733_PG_PWM_BYTES];     //PG1 - PWM Register
-    uint8_t abm[ISSI3733_PG_ABM_BYTES];     //PG2 - Auto Breath Mode Register
-    uint8_t conf[ISSI3733_PG_FN_BYTES];     //PG3 - Function Register
+    uint8_t addr;                            // Address of the driver according to wiring "ISSI3733: Table 1 Slave Address"
+    uint8_t onoff[ISSI3733_PG_ONOFF_BYTES];  // PG0 - LED Control Register - LED On/Off Register
+    uint8_t open[ISSI3733_PG_OR_BYTES];      // PG0 - LED Control Register - LED Open Register
+    uint8_t shrt[ISSI3733_PG_SR_BYTES];      // PG0 - LED Control Register - LED Short Register
+    uint8_t pwm[ISSI3733_PG_PWM_BYTES];      // PG1 - PWM Register
+    uint8_t abm[ISSI3733_PG_ABM_BYTES];      // PG2 - Auto Breath Mode Register
+    uint8_t conf[ISSI3733_PG_FN_BYTES];      // PG3 - Function Register
 } issi3733_driver_t;
 
 typedef struct issi3733_rgb_s {
-    uint8_t *r;         //Direct access into PWM data
-    uint8_t *g;         //Direct access into PWM data
-    uint8_t *b;         //Direct access into PWM data
+    uint8_t *r;  // Direct access into PWM data
+    uint8_t *g;  // Direct access into PWM data
+    uint8_t *b;  // Direct access into PWM data
 } issi3733_rgb_t;
 
 typedef struct issi3733_rgb_adr_s {
-    uint8_t drv;        //Driver from given list
-    uint8_t cs;         //CS
-    uint8_t swr;        //SW Red
-    uint8_t swg;        //SW Green
-    uint8_t swb;        //SW Blue
+    uint8_t drv;  // Driver from given list
+    uint8_t cs;   // CS
+    uint8_t swr;  // SW Red
+    uint8_t swg;  // SW Green
+    uint8_t swb;  // SW Blue
 } issi3733_rgb_adr_t;
 
 typedef struct issi3733_led_s {
-    uint8_t id;                 //According to PCB ref
-    issi3733_rgb_t rgb;         //PWM settings of R G B
-    issi3733_rgb_adr_t adr;     //Hardware addresses
-    float x;                    //Physical position X
-    float y;                    //Physical position Y
-    float px;                   //Physical position X in percent
-    float py;                   //Physical position Y in percent
-    uint8_t scan;               //Key scan code from wiring (set 0xFF if no key)
+    uint8_t            id;    // According to PCB ref
+    issi3733_rgb_t     rgb;   // PWM settings of R G B
+    issi3733_rgb_adr_t adr;   // Hardware addresses
+    float              x;     // Physical position X
+    float              y;     // Physical position Y
+    float              px;    // Physical position X in percent
+    float              py;    // Physical position Y in percent
+    uint8_t            scan;  // Key scan code from wiring (set 0xFF if no key)
 } issi3733_led_t;
 
 extern issi3733_driver_t issidrv[ISSI3733_DRIVER_COUNT];
@@ -92,67 +92,67 @@ void led_matrix_indicators(void);
 
 #ifdef USE_MASSDROP_CONFIGURATOR
 
-#define EF_NONE         0x00000000  //No effect
-#define EF_OVER         0x00000001  //Overwrite any previous color information with new
-#define EF_SCR_L        0x00000002  //Scroll left
-#define EF_SCR_R        0x00000004  //Scroll right
-#define EF_SUBTRACT     0x00000008  //Subtract color values
+#    define EF_NONE 0x00000000      // No effect
+#    define EF_OVER 0x00000001      // Overwrite any previous color information with new
+#    define EF_SCR_L 0x00000002     // Scroll left
+#    define EF_SCR_R 0x00000004     // Scroll right
+#    define EF_SUBTRACT 0x00000008  // Subtract color values
 
 typedef struct led_setup_s {
-  float hs;         //Band begin at percent
-  float he;         //Band end at percent
-  uint8_t rs;       //Red start value
-  uint8_t re;       //Red end value
-  uint8_t gs;       //Green start value
-  uint8_t ge;       //Green end value
-  uint8_t bs;       //Blue start value
-  uint8_t be;       //Blue end value
-  uint32_t ef;      //Animation and color effects
-  uint8_t end;      //Set to signal end of the setup
+    float    hs;   // Band begin at percent
+    float    he;   // Band end at percent
+    uint8_t  rs;   // Red start value
+    uint8_t  re;   // Red end value
+    uint8_t  gs;   // Green start value
+    uint8_t  ge;   // Green end value
+    uint8_t  bs;   // Blue start value
+    uint8_t  be;   // Blue end value
+    uint32_t ef;   // Animation and color effects
+    uint8_t  end;  // Set to signal end of the setup
 } led_setup_t;
 
 extern const uint8_t led_setups_count;
-extern void *led_setups[];
+extern void *        led_setups[];
 
-//LED Extra Instructions
-#define LED_FLAG_NULL                0x00       //Matching and coloring not used (default)
-#define LED_FLAG_MATCH_ID            0x01       //Match on the ID of the LED (set id#'s to desired bit pattern, first LED is id 1)
-#define LED_FLAG_MATCH_LAYER         0x02       //Match on the current active layer (set layer to desired match layer)
-#define LED_FLAG_USE_RGB             0x10       //Use a specific RGB value (set r, g, b to desired output color values)
-#define LED_FLAG_USE_PATTERN         0x20       //Use a specific pattern ID (set pattern_id to desired output pattern)
-#define LED_FLAG_USE_ROTATE_PATTERN  0x40       //Use pattern the user has cycled to manually
+// LED Extra Instructions
+#    define LED_FLAG_NULL 0x00                // Matching and coloring not used (default)
+#    define LED_FLAG_MATCH_ID 0x01            // Match on the ID of the LED (set id#'s to desired bit pattern, first LED is id 1)
+#    define LED_FLAG_MATCH_LAYER 0x02         // Match on the current active layer (set layer to desired match layer)
+#    define LED_FLAG_USE_RGB 0x10             // Use a specific RGB value (set r, g, b to desired output color values)
+#    define LED_FLAG_USE_PATTERN 0x20         // Use a specific pattern ID (set pattern_id to desired output pattern)
+#    define LED_FLAG_USE_ROTATE_PATTERN 0x40  // Use pattern the user has cycled to manually
 
 typedef struct led_instruction_s {
-    uint16_t flags; // Bitfield for LED instructions
-    uint32_t id0; // Bitwise id, IDs 0-31
-    uint32_t id1; // Bitwise id, IDs 32-63
-    uint32_t id2; // Bitwise id, IDs 64-95
-    uint32_t id3; // Bitwise id, IDs 96-127
-    uint8_t layer;
-    uint8_t r;
-    uint8_t g;
-    uint8_t b;
-    uint8_t pattern_id;
-    uint8_t end;
+    uint16_t flags;  // Bitfield for LED instructions
+    uint32_t id0;    // Bitwise id, IDs 0-31
+    uint32_t id1;    // Bitwise id, IDs 32-63
+    uint32_t id2;    // Bitwise id, IDs 64-95
+    uint32_t id3;    // Bitwise id, IDs 96-127
+    uint8_t  layer;
+    uint8_t  r;
+    uint8_t  g;
+    uint8_t  b;
+    uint8_t  pattern_id;
+    uint8_t  end;
 } led_instruction_t;
 
 extern led_instruction_t led_instructions[];
 
 extern uint8_t led_animation_breathing;
 extern uint8_t led_animation_id;
-extern float led_animation_speed;
+extern float   led_animation_speed;
 extern uint8_t led_lighting_mode;
 extern uint8_t led_enabled;
 extern uint8_t led_animation_breathe_cur;
 extern uint8_t led_animation_direction;
 extern uint8_t breathe_dir;
 
-#define LED_MODE_NORMAL             0   //Must be 0
-#define LED_MODE_KEYS_ONLY          1
-#define LED_MODE_NON_KEYS_ONLY      2
-#define LED_MODE_INDICATORS_ONLY    3
-#define LED_MODE_MAX_INDEX          LED_MODE_INDICATORS_ONLY   //Must be highest value
+#    define LED_MODE_NORMAL 0  // Must be 0
+#    define LED_MODE_KEYS_ONLY 1
+#    define LED_MODE_NON_KEYS_ONLY 2
+#    define LED_MODE_INDICATORS_ONLY 3
+#    define LED_MODE_MAX_INDEX LED_MODE_INDICATORS_ONLY  // Must be highest value
 
-#endif // USE_MASSDROP_CONFIGURATOR
+#endif  // USE_MASSDROP_CONFIGURATOR
 
-#endif //_LED_MATRIX_H_
+#endif  //_LED_MATRIX_H_
diff --git a/tmk_core/protocol/arm_atsam/led_matrix_programs.c b/tmk_core/protocol/arm_atsam/led_matrix_programs.c
index cf7478dc3..360102ba8 100644
--- a/tmk_core/protocol/arm_atsam/led_matrix_programs.c
+++ b/tmk_core/protocol/arm_atsam/led_matrix_programs.c
@@ -17,106 +17,82 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 #ifdef USE_MASSDROP_CONFIGURATOR
 
-#include "led_matrix.h"
+#    include "led_matrix.h"
 
-//Teal <-> Salmon
+// Teal <-> Salmon
 led_setup_t leds_teal_salmon[] = {
-    { .hs = 0,  .he = 33,  .rs = 24,  .re = 24,  .gs = 215, .ge = 215, .bs = 204, .be = 204, .ef = EF_NONE },
-    { .hs = 33, .he = 66,  .rs = 24,  .re = 255, .gs = 215, .ge = 114, .bs = 204, .be = 118, .ef = EF_NONE },
-    { .hs = 66, .he = 100, .rs = 255, .re = 255, .gs = 114, .ge = 114, .bs = 118, .be = 118, .ef = EF_NONE },
-    { .end = 1 },
+    {.hs = 0, .he = 33, .rs = 24, .re = 24, .gs = 215, .ge = 215, .bs = 204, .be = 204, .ef = EF_NONE},
+    {.hs = 33, .he = 66, .rs = 24, .re = 255, .gs = 215, .ge = 114, .bs = 204, .be = 118, .ef = EF_NONE},
+    {.hs = 66, .he = 100, .rs = 255, .re = 255, .gs = 114, .ge = 114, .bs = 118, .be = 118, .ef = EF_NONE},
+    {.end = 1},
 };
 
-//Yellow
+// Yellow
 led_setup_t leds_yellow[] = {
-    { .hs = 0, .he = 100, .rs = 255, .re = 255, .gs = 255, .ge = 255, .bs = 0, .be = 0, .ef = EF_NONE },
-    { .end = 1 },
+    {.hs = 0, .he = 100, .rs = 255, .re = 255, .gs = 255, .ge = 255, .bs = 0, .be = 0, .ef = EF_NONE},
+    {.end = 1},
 };
 
-//Off
+// Off
 led_setup_t leds_off[] = {
-    { .hs = 0, .he = 100, .rs = 0, .re = 0, .gs = 0, .ge = 0, .bs = 0, .be = 0, .ef = EF_NONE },
-    { .end = 1 },
+    {.hs = 0, .he = 100, .rs = 0, .re = 0, .gs = 0, .ge = 0, .bs = 0, .be = 0, .ef = EF_NONE},
+    {.end = 1},
 };
 
-//Red
+// Red
 led_setup_t leds_red[] = {
-    { .hs = 0, .he = 100, .rs = 255, .re = 255, .gs = 0, .ge = 0, .bs = 0, .be = 0, .ef = EF_NONE },
-    { .end = 1 },
+    {.hs = 0, .he = 100, .rs = 255, .re = 255, .gs = 0, .ge = 0, .bs = 0, .be = 0, .ef = EF_NONE},
+    {.end = 1},
 };
 
-//Green
+// Green
 led_setup_t leds_green[] = {
-    { .hs = 0, .he = 100, .rs = 0, .re = 0, .gs = 255, .ge = 255, .bs = 0, .be = 0, .ef = EF_NONE },
-    { .end = 1 },
+    {.hs = 0, .he = 100, .rs = 0, .re = 0, .gs = 255, .ge = 255, .bs = 0, .be = 0, .ef = EF_NONE},
+    {.end = 1},
 };
 
-//Blue
+// Blue
 led_setup_t leds_blue[] = {
-    { .hs = 0, .he = 100, .rs = 0, .re = 0, .gs = 0, .ge = 0, .bs = 255, .be = 255, .ef = EF_NONE },
-    { .end = 1 },
+    {.hs = 0, .he = 100, .rs = 0, .re = 0, .gs = 0, .ge = 0, .bs = 255, .be = 255, .ef = EF_NONE},
+    {.end = 1},
 };
 
-//White
+// White
 led_setup_t leds_white[] = {
-    { .hs = 0, .he = 100, .rs = 255, .re = 255, .gs = 255, .ge = 255, .bs = 255, .be = 255, .ef = EF_NONE },
-    { .end = 1 },
+    {.hs = 0, .he = 100, .rs = 255, .re = 255, .gs = 255, .ge = 255, .bs = 255, .be = 255, .ef = EF_NONE},
+    {.end = 1},
 };
 
-//White with moving red stripe
+// White with moving red stripe
 led_setup_t leds_white_with_red_stripe[] = {
-    { .hs = 0, .he = 100, .rs = 255, .re = 255, .gs = 255, .ge = 255, .bs = 255, .be = 255, .ef = EF_NONE },
-    { .hs = 0, .he = 15, .rs = 0, .re = 0, .gs = 0, .ge = 255, .bs = 0, .be = 255, .ef = EF_SCR_R | EF_SUBTRACT },
-    { .hs = 15, .he = 30, .rs = 0, .re = 0, .gs = 255, .ge = 0, .bs = 255, .be = 0, .ef = EF_SCR_R | EF_SUBTRACT },
-    { .end = 1 },
+    {.hs = 0, .he = 100, .rs = 255, .re = 255, .gs = 255, .ge = 255, .bs = 255, .be = 255, .ef = EF_NONE},
+    {.hs = 0, .he = 15, .rs = 0, .re = 0, .gs = 0, .ge = 255, .bs = 0, .be = 255, .ef = EF_SCR_R | EF_SUBTRACT},
+    {.hs = 15, .he = 30, .rs = 0, .re = 0, .gs = 255, .ge = 0, .bs = 255, .be = 0, .ef = EF_SCR_R | EF_SUBTRACT},
+    {.end = 1},
 };
 
-//Black with moving red stripe
+// Black with moving red stripe
 led_setup_t leds_black_with_red_stripe[] = {
-    { .hs = 0, .he = 15, .rs = 0, .re = 255, .gs = 0, .ge = 0, .bs = 0, .be = 0, .ef = EF_SCR_R },
-    { .hs = 15, .he = 30, .rs = 255, .re = 0, .gs = 0, .ge = 0, .bs = 0, .be = 0, .ef = EF_SCR_R },
-    { .end = 1 },
+    {.hs = 0, .he = 15, .rs = 0, .re = 255, .gs = 0, .ge = 0, .bs = 0, .be = 0, .ef = EF_SCR_R},
+    {.hs = 15, .he = 30, .rs = 255, .re = 0, .gs = 0, .ge = 0, .bs = 0, .be = 0, .ef = EF_SCR_R},
+    {.end = 1},
 };
 
-//Rainbow no scrolling
+// Rainbow no scrolling
 led_setup_t leds_rainbow_ns[] = {
-    { .hs = 0,      .he = 16.67,  .rs = 255, .re = 255, .gs = 0,   .ge = 255, .bs = 0,   .be = 0,   .ef = EF_OVER },
-    { .hs = 16.67,  .he = 33.33,  .rs = 255, .re = 0,   .gs = 255, .ge = 255, .bs = 0,   .be = 0,   .ef = EF_OVER },
-    { .hs = 33.33,  .he = 50,     .rs = 0,   .re = 0,   .gs = 255, .ge = 255, .bs = 0,   .be = 255, .ef = EF_OVER },
-    { .hs = 50,     .he = 66.67,  .rs = 0,   .re = 0,   .gs = 255, .ge = 0,   .bs = 255, .be = 255, .ef = EF_OVER },
-    { .hs = 66.67,  .he = 83.33,  .rs = 0,   .re = 255, .gs = 0,   .ge = 0,   .bs = 255, .be = 255, .ef = EF_OVER },
-    { .hs = 83.33,  .he = 100,    .rs = 255, .re = 255, .gs = 0,   .ge = 0,   .bs = 255, .be = 0,   .ef = EF_OVER },
-    { .end = 1 },
+    {.hs = 0, .he = 16.67, .rs = 255, .re = 255, .gs = 0, .ge = 255, .bs = 0, .be = 0, .ef = EF_OVER}, {.hs = 16.67, .he = 33.33, .rs = 255, .re = 0, .gs = 255, .ge = 255, .bs = 0, .be = 0, .ef = EF_OVER}, {.hs = 33.33, .he = 50, .rs = 0, .re = 0, .gs = 255, .ge = 255, .bs = 0, .be = 255, .ef = EF_OVER}, {.hs = 50, .he = 66.67, .rs = 0, .re = 0, .gs = 255, .ge = 0, .bs = 255, .be = 255, .ef = EF_OVER}, {.hs = 66.67, .he = 83.33, .rs = 0, .re = 255, .gs = 0, .ge = 0, .bs = 255, .be = 255, .ef = EF_OVER}, {.hs = 83.33, .he = 100, .rs = 255, .re = 255, .gs = 0, .ge = 0, .bs = 255, .be = 0, .ef = EF_OVER}, {.end = 1},
 };
 
-//Rainbow scrolling
+// Rainbow scrolling
 led_setup_t leds_rainbow_s[] = {
-    { .hs = 0,      .he = 16.67,  .rs = 255, .re = 255, .gs = 0,   .ge = 255, .bs = 0,   .be = 0,   .ef = EF_OVER | EF_SCR_R },
-    { .hs = 16.67,  .he = 33.33,  .rs = 255, .re = 0,   .gs = 255, .ge = 255, .bs = 0,   .be = 0,   .ef = EF_OVER | EF_SCR_R },
-    { .hs = 33.33,  .he = 50,     .rs = 0,   .re = 0,   .gs = 255, .ge = 255, .bs = 0,   .be = 255, .ef = EF_OVER | EF_SCR_R },
-    { .hs = 50,     .he = 66.67,  .rs = 0,   .re = 0,   .gs = 255, .ge = 0,   .bs = 255, .be = 255, .ef = EF_OVER | EF_SCR_R },
-    { .hs = 66.67,  .he = 83.33,  .rs = 0,   .re = 255, .gs = 0,   .ge = 0,   .bs = 255, .be = 255, .ef = EF_OVER | EF_SCR_R },
-    { .hs = 83.33,  .he = 100,    .rs = 255, .re = 255, .gs = 0,   .ge = 0,   .bs = 255, .be = 0,   .ef = EF_OVER | EF_SCR_R },
-    { .end = 1 },
+    {.hs = 0, .he = 16.67, .rs = 255, .re = 255, .gs = 0, .ge = 255, .bs = 0, .be = 0, .ef = EF_OVER | EF_SCR_R}, {.hs = 16.67, .he = 33.33, .rs = 255, .re = 0, .gs = 255, .ge = 255, .bs = 0, .be = 0, .ef = EF_OVER | EF_SCR_R}, {.hs = 33.33, .he = 50, .rs = 0, .re = 0, .gs = 255, .ge = 255, .bs = 0, .be = 255, .ef = EF_OVER | EF_SCR_R}, {.hs = 50, .he = 66.67, .rs = 0, .re = 0, .gs = 255, .ge = 0, .bs = 255, .be = 255, .ef = EF_OVER | EF_SCR_R}, {.hs = 66.67, .he = 83.33, .rs = 0, .re = 255, .gs = 0, .ge = 0, .bs = 255, .be = 255, .ef = EF_OVER | EF_SCR_R}, {.hs = 83.33, .he = 100, .rs = 255, .re = 255, .gs = 0, .ge = 0, .bs = 255, .be = 0, .ef = EF_OVER | EF_SCR_R}, {.end = 1},
 };
 
-//Add new LED animations here using one from above as example
-//The last entry must be { .end = 1 }
-//Add the new animation name to the list below following its format
-
-void *led_setups[] = {
-    leds_rainbow_s,
-    leds_rainbow_ns,
-    leds_teal_salmon,
-    leds_yellow,
-    leds_red,
-    leds_green,
-    leds_blue,
-    leds_white,
-    leds_white_with_red_stripe,
-    leds_black_with_red_stripe,
-    leds_off
-};
+// Add new LED animations here using one from above as example
+// The last entry must be { .end = 1 }
+// Add the new animation name to the list below following its format
+
+void *led_setups[] = {leds_rainbow_s, leds_rainbow_ns, leds_teal_salmon, leds_yellow, leds_red, leds_green, leds_blue, leds_white, leds_white_with_red_stripe, leds_black_with_red_stripe, leds_off};
 
 const uint8_t led_setups_count = sizeof(led_setups) / sizeof(led_setups[0]);
 
diff --git a/tmk_core/protocol/arm_atsam/main_arm_atsam.c b/tmk_core/protocol/arm_atsam/main_arm_atsam.c
index 0974a230d..a42d9daf3 100644
--- a/tmk_core/protocol/arm_atsam/main_arm_atsam.c
+++ b/tmk_core/protocol/arm_atsam/main_arm_atsam.c
@@ -25,50 +25,43 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include <string.h>
 #include "quantum.h"
 
-//From protocol directory
+// From protocol directory
 #include "arm_atsam_protocol.h"
 
-//From keyboard's directory
+// From keyboard's directory
 #include "config_led.h"
 
-uint8_t g_usb_state = USB_FSMSTATUS_FSMSTATE_OFF_Val;   //Saved USB state from hardware value to detect changes
+uint8_t g_usb_state = USB_FSMSTATUS_FSMSTATE_OFF_Val;  // Saved USB state from hardware value to detect changes
 
-void main_subtasks(void);
+void    main_subtasks(void);
 uint8_t keyboard_leds(void);
-void send_keyboard(report_keyboard_t *report);
-void send_mouse(report_mouse_t *report);
-void send_system(uint16_t data);
-void send_consumer(uint16_t data);
-
-host_driver_t arm_atsam_driver = {
-    keyboard_leds,
-    send_keyboard,
-    send_mouse,
-    send_system,
-    send_consumer
-};
+void    send_keyboard(report_keyboard_t *report);
+void    send_mouse(report_mouse_t *report);
+void    send_system(uint16_t data);
+void    send_consumer(uint16_t data);
+
+host_driver_t arm_atsam_driver = {keyboard_leds, send_keyboard, send_mouse, send_system, send_consumer};
 
 uint8_t led_states;
 
-uint8_t keyboard_leds(void)
-{
+uint8_t keyboard_leds(void) {
 #ifdef NKRO_ENABLE
     if (keymap_config.nkro)
         return udi_hid_nkro_report_set;
     else
-#endif //NKRO_ENABLE
+#endif  // NKRO_ENABLE
         return udi_hid_kbd_report_set;
 }
 
-void send_keyboard(report_keyboard_t *report)
-{
+void send_keyboard(report_keyboard_t *report) {
     uint32_t irqflags;
 
 #ifdef NKRO_ENABLE
-    if (!keymap_config.nkro)
-    {
-#endif //NKRO_ENABLE
-        while (udi_hid_kbd_b_report_trans_ongoing) { main_subtasks(); } //Run other tasks while waiting for USB to be free
+    if (!keymap_config.nkro) {
+#endif  // NKRO_ENABLE
+        while (udi_hid_kbd_b_report_trans_ongoing) {
+            main_subtasks();
+        }  // Run other tasks while waiting for USB to be free
 
         irqflags = __get_PRIMASK();
         __disable_irq();
@@ -81,10 +74,10 @@ void send_keyboard(report_keyboard_t *report)
         __DMB();
         __set_PRIMASK(irqflags);
 #ifdef NKRO_ENABLE
-    }
-    else
-    {
-        while (udi_hid_nkro_b_report_trans_ongoing) { main_subtasks(); } //Run other tasks while waiting for USB to be free
+    } else {
+        while (udi_hid_nkro_b_report_trans_ongoing) {
+            main_subtasks();
+        }  // Run other tasks while waiting for USB to be free
 
         irqflags = __get_PRIMASK();
         __disable_irq();
@@ -97,11 +90,10 @@ void send_keyboard(report_keyboard_t *report)
         __DMB();
         __set_PRIMASK(irqflags);
     }
-#endif //NKRO_ENABLE
+#endif  // NKRO_ENABLE
 }
 
-void send_mouse(report_mouse_t *report)
-{
+void send_mouse(report_mouse_t *report) {
 #ifdef MOUSEKEY_ENABLE
     uint32_t irqflags;
 
@@ -115,11 +107,10 @@ void send_mouse(report_mouse_t *report)
 
     __DMB();
     __set_PRIMASK(irqflags);
-#endif //MOUSEKEY_ENABLE
+#endif  // MOUSEKEY_ENABLE
 }
 
-void send_system(uint16_t data)
-{
+void send_system(uint16_t data) {
 #ifdef EXTRAKEY_ENABLE
     uint32_t irqflags;
 
@@ -130,16 +121,15 @@ void send_system(uint16_t data)
     udi_hid_exk_report.desc.report_id = REPORT_ID_SYSTEM;
     if (data != 0) data = data - SYSTEM_POWER_DOWN + 1;
     udi_hid_exk_report.desc.report_data = data;
-    udi_hid_exk_b_report_valid = 1;
+    udi_hid_exk_b_report_valid          = 1;
     udi_hid_exk_send_report();
 
     __DMB();
     __set_PRIMASK(irqflags);
-#endif //EXTRAKEY_ENABLE
+#endif  // EXTRAKEY_ENABLE
 }
 
-void send_consumer(uint16_t data)
-{
+void send_consumer(uint16_t data) {
 #ifdef EXTRAKEY_ENABLE
     uint32_t irqflags;
 
@@ -147,71 +137,64 @@ void send_consumer(uint16_t data)
     __disable_irq();
     __DMB();
 
-    udi_hid_exk_report.desc.report_id = REPORT_ID_CONSUMER;
+    udi_hid_exk_report.desc.report_id   = REPORT_ID_CONSUMER;
     udi_hid_exk_report.desc.report_data = data;
-    udi_hid_exk_b_report_valid = 1;
+    udi_hid_exk_b_report_valid          = 1;
     udi_hid_exk_send_report();
 
     __DMB();
     __set_PRIMASK(irqflags);
-#endif //EXTRAKEY_ENABLE
+#endif  // EXTRAKEY_ENABLE
 }
 
-void main_subtask_usb_state(void)
-{
-    static uint64_t fsmstate_on_delay = 0;                          //Delay timer to be sure USB is actually operating before bringing up hardware
-    uint8_t fsmstate_now = USB->DEVICE.FSMSTATUS.reg;               //Current state from hardware register
+void main_subtask_usb_state(void) {
+    static uint64_t fsmstate_on_delay = 0;                          // Delay timer to be sure USB is actually operating before bringing up hardware
+    uint8_t         fsmstate_now      = USB->DEVICE.FSMSTATUS.reg;  // Current state from hardware register
 
-    if (fsmstate_now == USB_FSMSTATUS_FSMSTATE_SUSPEND_Val)         //If USB SUSPENDED
+    if (fsmstate_now == USB_FSMSTATUS_FSMSTATE_SUSPEND_Val)  // If USB SUSPENDED
     {
-        fsmstate_on_delay = 0;                                      //Clear ON delay timer
+        fsmstate_on_delay = 0;  // Clear ON delay timer
 
-        if (g_usb_state != USB_FSMSTATUS_FSMSTATE_SUSPEND_Val)      //If previously not SUSPENDED
+        if (g_usb_state != USB_FSMSTATUS_FSMSTATE_SUSPEND_Val)  // If previously not SUSPENDED
         {
-            suspend_power_down();                                   //Run suspend routine
-            g_usb_state = fsmstate_now;                             //Save current USB state
+            suspend_power_down();        // Run suspend routine
+            g_usb_state = fsmstate_now;  // Save current USB state
         }
-    }
-    else if (fsmstate_now == USB_FSMSTATUS_FSMSTATE_SLEEP_Val)      //Else if USB SLEEPING
+    } else if (fsmstate_now == USB_FSMSTATUS_FSMSTATE_SLEEP_Val)  // Else if USB SLEEPING
     {
-        fsmstate_on_delay = 0;                                      //Clear ON delay timer
+        fsmstate_on_delay = 0;  // Clear ON delay timer
 
-        if (g_usb_state != USB_FSMSTATUS_FSMSTATE_SLEEP_Val)        //If previously not SLEEPING
+        if (g_usb_state != USB_FSMSTATUS_FSMSTATE_SLEEP_Val)  // If previously not SLEEPING
         {
-            suspend_power_down();                                   //Run suspend routine
-            g_usb_state = fsmstate_now;                             //Save current USB state
+            suspend_power_down();        // Run suspend routine
+            g_usb_state = fsmstate_now;  // Save current USB state
         }
-    }
-    else if (fsmstate_now == USB_FSMSTATUS_FSMSTATE_ON_Val)         //Else if USB ON
+    } else if (fsmstate_now == USB_FSMSTATUS_FSMSTATE_ON_Val)  // Else if USB ON
     {
-        if (g_usb_state != USB_FSMSTATUS_FSMSTATE_ON_Val)           //If previously not ON
+        if (g_usb_state != USB_FSMSTATUS_FSMSTATE_ON_Val)  // If previously not ON
         {
-            if (fsmstate_on_delay == 0)                             //If ON delay timer is cleared
+            if (fsmstate_on_delay == 0)  // If ON delay timer is cleared
             {
-                fsmstate_on_delay = timer_read64() + 250;             //Set ON delay timer
-            }
-            else if (timer_read64() > fsmstate_on_delay)              //Else if ON delay timer is active and timed out
+                fsmstate_on_delay = timer_read64() + 250;   // Set ON delay timer
+            } else if (timer_read64() > fsmstate_on_delay)  // Else if ON delay timer is active and timed out
             {
-                suspend_wakeup_init();                              //Run wakeup routine
-                g_usb_state = fsmstate_now;                         //Save current USB state
+                suspend_wakeup_init();       // Run wakeup routine
+                g_usb_state = fsmstate_now;  // Save current USB state
             }
         }
-    }
-    else                                                            //Else if USB is in a state not being tracked
+    } else  // Else if USB is in a state not being tracked
     {
-        fsmstate_on_delay = 0;                                      //Clear ON delay timer
+        fsmstate_on_delay = 0;  // Clear ON delay timer
     }
 }
 
-void main_subtask_power_check(void)
-{
+void main_subtask_power_check(void) {
     static uint64_t next_5v_checkup = 0;
 
-    if (timer_read64() > next_5v_checkup)
-    {
+    if (timer_read64() > next_5v_checkup) {
         next_5v_checkup = timer_read64() + 5;
 
-        v_5v = adc_get(ADC_5V);
+        v_5v     = adc_get(ADC_5V);
         v_5v_avg = 0.9 * v_5v_avg + 0.1 * v_5v;
 
 #ifdef RGB_MATRIX_ENABLE
@@ -220,27 +203,23 @@ void main_subtask_power_check(void)
     }
 }
 
-void main_subtask_usb_extra_device(void)
-{
+void main_subtask_usb_extra_device(void) {
     static uint64_t next_usb_checkup = 0;
 
-    if (timer_read64() > next_usb_checkup)
-    {
+    if (timer_read64() > next_usb_checkup) {
         next_usb_checkup = timer_read64() + 10;
 
         USB_HandleExtraDevice();
     }
 }
 
-void main_subtasks(void)
-{
+void main_subtasks(void) {
     main_subtask_usb_state();
     main_subtask_power_check();
     main_subtask_usb_extra_device();
 }
 
-int main(void)
-{
+int main(void) {
     DBG_LED_ENA;
     DBG_1_ENA;
     DBG_1_OFF;
@@ -259,7 +238,7 @@ int main(void)
 
 #ifdef RGB_MATRIX_ENABLE
     i2c1_init();
-#endif // RGB_MATRIX_ENABLE
+#endif  // RGB_MATRIX_ENABLE
 
     matrix_init();
 
@@ -273,21 +252,23 @@ int main(void)
     CDC_init();
     DBGC(DC_MAIN_CDC_INIT_COMPLETE);
 
-    while (USB2422_Port_Detect_Init() == 0) {}
+    while (USB2422_Port_Detect_Init() == 0) {
+    }
 
     DBG_LED_OFF;
 
 #ifdef RGB_MATRIX_ENABLE
-    while (I2C3733_Init_Control() != 1) {}
-    while (I2C3733_Init_Drivers() != 1) {}
+    while (I2C3733_Init_Control() != 1) {
+    }
+    while (I2C3733_Init_Drivers() != 1) {
+    }
 
     I2C_DMAC_LED_Init();
 
     i2c_led_q_init();
 
-    for (uint8_t drvid = 0; drvid < ISSI3733_DRIVER_COUNT; drvid++)
-        I2C_LED_Q_ONOFF(drvid); //Queue data
-#endif // RGB_MATRIX_ENABLE
+    for (uint8_t drvid = 0; drvid < ISSI3733_DRIVER_COUNT; drvid++) I2C_LED_Q_ONOFF(drvid);  // Queue data
+#endif                                                                                       // RGB_MATRIX_ENABLE
 
     keyboard_setup();
 
@@ -297,21 +278,18 @@ int main(void)
 
 #ifdef CONSOLE_ENABLE
     uint64_t next_print = 0;
-#endif //CONSOLE_ENABLE
+#endif  // CONSOLE_ENABLE
 
     v_5v_avg = adc_get(ADC_5V);
 
     debug_code_disable();
 
-    while (1)
-    {
-        main_subtasks(); //Note these tasks will also be run while waiting for USB keyboard polling intervals
+    while (1) {
+        main_subtasks();  // Note these tasks will also be run while waiting for USB keyboard polling intervals
 
-        if (g_usb_state == USB_FSMSTATUS_FSMSTATE_SUSPEND_Val || g_usb_state == USB_FSMSTATUS_FSMSTATE_SLEEP_Val)
-        {
-            if (suspend_wakeup_condition())
-            {
-                udc_remotewakeup(); //Send remote wakeup signal
+        if (g_usb_state == USB_FSMSTATUS_FSMSTATE_SUSPEND_Val || g_usb_state == USB_FSMSTATUS_FSMSTATE_SLEEP_Val) {
+            if (suspend_wakeup_condition()) {
+                udc_remotewakeup();  // Send remote wakeup signal
                 wait_ms(50);
             }
 
@@ -321,16 +299,13 @@ int main(void)
         keyboard_task();
 
 #ifdef CONSOLE_ENABLE
-        if (timer_read64() > next_print)
-        {
+        if (timer_read64() > next_print) {
             next_print = timer_read64() + 250;
-            //Add any debug information here that you want to see very often
-            //dprintf("5v=%u 5vu=%u dlow=%u dhi=%u gca=%u gcd=%u\r\n", v_5v, v_5v_avg, v_5v_avg - V5_LOW, v_5v_avg - V5_HIGH, gcr_actual, gcr_desired);
+            // Add any debug information here that you want to see very often
+            // dprintf("5v=%u 5vu=%u dlow=%u dhi=%u gca=%u gcd=%u\r\n", v_5v, v_5v_avg, v_5v_avg - V5_LOW, v_5v_avg - V5_HIGH, gcr_actual, gcr_desired);
         }
-#endif //CONSOLE_ENABLE
+#endif  // CONSOLE_ENABLE
     }
 
-
     return 1;
 }
-
diff --git a/tmk_core/protocol/arm_atsam/main_arm_atsam.h b/tmk_core/protocol/arm_atsam/main_arm_atsam.h
index 78205e2e1..5b088f0e2 100644
--- a/tmk_core/protocol/arm_atsam/main_arm_atsam.h
+++ b/tmk_core/protocol/arm_atsam/main_arm_atsam.h
@@ -20,4 +20,4 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 uint8_t keyboard_leds(void);
 
-#endif //_MAIN_ARM_ATSAM_H_
+#endif  //_MAIN_ARM_ATSAM_H_
diff --git a/tmk_core/protocol/arm_atsam/md_bootloader.h b/tmk_core/protocol/arm_atsam/md_bootloader.h
index 6b80ef492..362b9bd52 100644
--- a/tmk_core/protocol/arm_atsam/md_bootloader.h
+++ b/tmk_core/protocol/arm_atsam/md_bootloader.h
@@ -5,20 +5,20 @@ extern uint32_t _srom;
 extern uint32_t _lrom;
 extern uint32_t _erom;
 
-#define BOOTLOADER_SERIAL_MAX_SIZE 20   //DO NOT MODIFY!
+#define BOOTLOADER_SERIAL_MAX_SIZE 20  // DO NOT MODIFY!
 
 #ifdef KEYBOARD_massdrop_ctrl
-//WARNING: These are only for CTRL bootloader release "v2.18Jun 22 2018 17:28:08" for bootloader_jump support
+// WARNING: These are only for CTRL bootloader release "v2.18Jun 22 2018 17:28:08" for bootloader_jump support
 extern uint32_t _eram;
-#define BOOTLOADER_MAGIC 0x3B9ACA00
-#define MAGIC_ADDR (uint32_t *)((intptr_t)(&_eram) - 4)
+#    define BOOTLOADER_MAGIC 0x3B9ACA00
+#    define MAGIC_ADDR (uint32_t *)((intptr_t)(&_eram) - 4)
 #endif
 
 #ifdef MD_BOOTLOADER
 
-#define MCU_HZ 48000000
-#define I2C_HZ 0 //Not used
+#    define MCU_HZ 48000000
+#    define I2C_HZ 0  // Not used
 
-#endif //MD_BOOTLOADER
+#endif  // MD_BOOTLOADER
 
-#endif //_MD_BOOTLOADER_H_
+#endif  //_MD_BOOTLOADER_H_
diff --git a/tmk_core/protocol/arm_atsam/spi.c b/tmk_core/protocol/arm_atsam/spi.c
index e275ba13f..3b118bc1f 100644
--- a/tmk_core/protocol/arm_atsam/spi.c
+++ b/tmk_core/protocol/arm_atsam/spi.c
@@ -19,69 +19,74 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 sr_exp_t sr_exp_data;
 
-void SR_EXP_WriteData(void)
-{
+void SR_EXP_WriteData(void) {
     SR_EXP_RCLK_LO;
 
-    while (!(SR_EXP_SERCOM->SPI.INTFLAG.bit.DRE)) { DBGC(DC_SPI_WRITE_DRE); }
+    while (!(SR_EXP_SERCOM->SPI.INTFLAG.bit.DRE)) {
+        DBGC(DC_SPI_WRITE_DRE);
+    }
 
-    SR_EXP_SERCOM->SPI.DATA.bit.DATA = sr_exp_data.reg & 0xFF; //Shift in bits 7-0
-    while (!(SR_EXP_SERCOM->SPI.INTFLAG.bit.TXC)) { DBGC(DC_SPI_WRITE_TXC_1); }
+    SR_EXP_SERCOM->SPI.DATA.bit.DATA = sr_exp_data.reg & 0xFF;  // Shift in bits 7-0
+    while (!(SR_EXP_SERCOM->SPI.INTFLAG.bit.TXC)) {
+        DBGC(DC_SPI_WRITE_TXC_1);
+    }
 
-    SR_EXP_SERCOM->SPI.DATA.bit.DATA = (sr_exp_data.reg >> 8) & 0xFF; //Shift in bits 15-8
-    while (!(SR_EXP_SERCOM->SPI.INTFLAG.bit.TXC)) { DBGC(DC_SPI_WRITE_TXC_2); }
+    SR_EXP_SERCOM->SPI.DATA.bit.DATA = (sr_exp_data.reg >> 8) & 0xFF;  // Shift in bits 15-8
+    while (!(SR_EXP_SERCOM->SPI.INTFLAG.bit.TXC)) {
+        DBGC(DC_SPI_WRITE_TXC_2);
+    }
 
     SR_EXP_RCLK_HI;
 }
 
-void SR_EXP_Init(void)
-{
+void SR_EXP_Init(void) {
     DBGC(DC_SPI_INIT_BEGIN);
 
     CLK_set_spi_freq(CHAN_SERCOM_SPI, FREQ_SPI_DEFAULT);
 
-    //Set up MCU Shift Register pins
+    // Set up MCU Shift Register pins
     PORT->Group[SR_EXP_RCLK_PORT].DIRSET.reg = (1 << SR_EXP_RCLK_PIN);
     PORT->Group[SR_EXP_OE_N_PORT].DIRSET.reg = (1 << SR_EXP_OE_N_PIN);
-    
-    //Set up MCU SPI pins
-    PORT->Group[SR_EXP_DATAOUT_PORT].PMUX[SR_EXP_DATAOUT_PIN / 2].bit.SR_EXP_DATAOUT_MUX_SEL = SR_EXP_DATAOUT_MUX; //MUX select for sercom
-    PORT->Group[SR_EXP_SCLK_PORT].PMUX[SR_EXP_SCLK_PIN / 2].bit.SR_EXP_SCLK_MUX_SEL = SR_EXP_SCLK_MUX; //MUX select for sercom
-    PORT->Group[SR_EXP_DATAOUT_PORT].PINCFG[SR_EXP_DATAOUT_PIN].bit.PMUXEN = 1; //MUX Enable
-    PORT->Group[SR_EXP_SCLK_PORT].PINCFG[SR_EXP_SCLK_PIN].bit.PMUXEN = 1; //MUX Enable
-
-    //Initialize Shift Register
+
+    // Set up MCU SPI pins
+    PORT->Group[SR_EXP_DATAOUT_PORT].PMUX[SR_EXP_DATAOUT_PIN / 2].bit.SR_EXP_DATAOUT_MUX_SEL = SR_EXP_DATAOUT_MUX;  // MUX select for sercom
+    PORT->Group[SR_EXP_SCLK_PORT].PMUX[SR_EXP_SCLK_PIN / 2].bit.SR_EXP_SCLK_MUX_SEL          = SR_EXP_SCLK_MUX;     // MUX select for sercom
+    PORT->Group[SR_EXP_DATAOUT_PORT].PINCFG[SR_EXP_DATAOUT_PIN].bit.PMUXEN                   = 1;                   // MUX Enable
+    PORT->Group[SR_EXP_SCLK_PORT].PINCFG[SR_EXP_SCLK_PIN].bit.PMUXEN                         = 1;                   // MUX Enable
+
+    // Initialize Shift Register
     SR_EXP_OE_N_DIS;
     SR_EXP_RCLK_HI;
 
-    SR_EXP_SERCOM->SPI.CTRLA.bit.DORD = 1; //Data Order - LSB is transferred first
-    SR_EXP_SERCOM->SPI.CTRLA.bit.CPOL = 1; //Clock Polarity - SCK high when idle. Leading edge of cycle is falling. Trailing rising.
-    SR_EXP_SERCOM->SPI.CTRLA.bit.CPHA = 1; //Clock Phase - Leading Edge Falling, change, Trailing Edge - Rising, sample
-    SR_EXP_SERCOM->SPI.CTRLA.bit.DIPO = 3; //Data In Pinout - SERCOM PAD[3] is used as data input (Configure away from DOPO. Not using input.)
-    SR_EXP_SERCOM->SPI.CTRLA.bit.DOPO = 0; //Data Output PAD[0], Serial Clock PAD[1]
-    SR_EXP_SERCOM->SPI.CTRLA.bit.MODE = 3; //Operating Mode - Master operation
+    SR_EXP_SERCOM->SPI.CTRLA.bit.DORD = 1;  // Data Order - LSB is transferred first
+    SR_EXP_SERCOM->SPI.CTRLA.bit.CPOL = 1;  // Clock Polarity - SCK high when idle. Leading edge of cycle is falling. Trailing rising.
+    SR_EXP_SERCOM->SPI.CTRLA.bit.CPHA = 1;  // Clock Phase - Leading Edge Falling, change, Trailing Edge - Rising, sample
+    SR_EXP_SERCOM->SPI.CTRLA.bit.DIPO = 3;  // Data In Pinout - SERCOM PAD[3] is used as data input (Configure away from DOPO. Not using input.)
+    SR_EXP_SERCOM->SPI.CTRLA.bit.DOPO = 0;  // Data Output PAD[0], Serial Clock PAD[1]
+    SR_EXP_SERCOM->SPI.CTRLA.bit.MODE = 3;  // Operating Mode - Master operation
 
-    SR_EXP_SERCOM->SPI.CTRLA.bit.ENABLE = 1; //Enable - Peripheral is enabled or being enabled
-    while (SR_EXP_SERCOM->SPI.SYNCBUSY.bit.ENABLE) { DBGC(DC_SPI_SYNC_ENABLING); }
+    SR_EXP_SERCOM->SPI.CTRLA.bit.ENABLE = 1;  // Enable - Peripheral is enabled or being enabled
+    while (SR_EXP_SERCOM->SPI.SYNCBUSY.bit.ENABLE) {
+        DBGC(DC_SPI_SYNC_ENABLING);
+    }
 
-    sr_exp_data.reg = 0;
+    sr_exp_data.reg             = 0;
     sr_exp_data.bit.HUB_CONNECT = 0;
     sr_exp_data.bit.HUB_RESET_N = 0;
-    sr_exp_data.bit.S_UP = 0;
-    sr_exp_data.bit.E_UP_N = 1;
-    sr_exp_data.bit.S_DN1 = 1;
-    sr_exp_data.bit.E_DN1_N = 1;
-    sr_exp_data.bit.E_VBUS_1 = 0;
-    sr_exp_data.bit.E_VBUS_2 = 0;
-    sr_exp_data.bit.SRC_1 = 1;
-    sr_exp_data.bit.SRC_2 = 1;
-    sr_exp_data.bit.IRST = 1;
-    sr_exp_data.bit.SDB_N = 0;
+    sr_exp_data.bit.S_UP        = 0;
+    sr_exp_data.bit.E_UP_N      = 1;
+    sr_exp_data.bit.S_DN1       = 1;
+    sr_exp_data.bit.E_DN1_N     = 1;
+    sr_exp_data.bit.E_VBUS_1    = 0;
+    sr_exp_data.bit.E_VBUS_2    = 0;
+    sr_exp_data.bit.SRC_1       = 1;
+    sr_exp_data.bit.SRC_2       = 1;
+    sr_exp_data.bit.IRST        = 1;
+    sr_exp_data.bit.SDB_N       = 0;
     SR_EXP_WriteData();
 
-    //Enable Shift Register output
+    // Enable Shift Register output
     SR_EXP_OE_N_ENA;
 
     DBGC(DC_SPI_INIT_COMPLETE);
 }
-
diff --git a/tmk_core/protocol/arm_atsam/spi.h b/tmk_core/protocol/arm_atsam/spi.h
index 4739b775d..dcd45f31a 100644
--- a/tmk_core/protocol/arm_atsam/spi.h
+++ b/tmk_core/protocol/arm_atsam/spi.h
@@ -26,40 +26,40 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 /* Determine bits to set for mux selection */
 #if SR_EXP_DATAOUT_PIN % 2 == 0
-#define SR_EXP_DATAOUT_MUX_SEL PMUXE
+#    define SR_EXP_DATAOUT_MUX_SEL PMUXE
 #else
-#define SR_EXP_DATAOUT_MUX_SEL PMUXO
+#    define SR_EXP_DATAOUT_MUX_SEL PMUXO
 #endif
 
 /* Determine bits to set for mux selection */
 #if SR_EXP_SCLK_PIN % 2 == 0
-#define SR_EXP_SCLK_MUX_SEL PMUXE
+#    define SR_EXP_SCLK_MUX_SEL PMUXE
 #else
-#define SR_EXP_SCLK_MUX_SEL PMUXO
+#    define SR_EXP_SCLK_MUX_SEL PMUXO
 #endif
 
 /* Data structure to define Shift Register output expander hardware */
 /* This structure gets shifted into registers LSB first */
 typedef union {
-  struct {
-    uint16_t RSVD4:1;          /*!< bit:      0                                               */
-    uint16_t RSVD3:1;          /*!< bit:      1                                               */
-    uint16_t RSVD2:1;          /*!< bit:      2                                               */
-    uint16_t RSVD1:1;          /*!< bit:      3                                               */
-    uint16_t SDB_N:1;          /*!< bit:      4  SHUTDOWN THE CHIP WHEN 0, RUN WHEN 1         */
-    uint16_t IRST:1;           /*!< bit:      5  RESET THE IS3733 I2C WHEN 1, RUN WHEN 0      */
-    uint16_t SRC_2:1;          /*!< bit:      6  ADVERTISE A SOURCE TO USBC-2 CC              */
-    uint16_t SRC_1:1;          /*!< bit:      7  ADVERTISE A SOURCE TO USBC-1 CC              */
-    uint16_t E_VBUS_2:1;       /*!< bit:      8  ENABLE 5V OUT TO USBC-2 WHEN 1               */
-    uint16_t E_VBUS_1:1;       /*!< bit:      9  ENABLE 5V OUT TO USBC-1 WHEN 1               */
-    uint16_t E_DN1_N:1;        /*!< bit:     10  ENABLE DN1 1:2 MUX WHEN 0                    */
-    uint16_t S_DN1:1;          /*!< bit:     11  SELECT DN1 PATH 0:USBC-1, 1:USBC-2           */
-    uint16_t E_UP_N:1;         /*!< bit:     12  ENABLE SUP 1:2 MUX WHEN 0                    */
-    uint16_t S_UP:1;           /*!< bit:     13  SELECT UP PATH 0:USBC-1, 1:USBC-2            */
-    uint16_t HUB_RESET_N:1;    /*!< bit:     14  RESET USB HUB WHEN 0, RUN WHEN 1             */
-    uint16_t HUB_CONNECT:1;    /*!< bit:     15  SIGNAL VBUS CONNECT TO USB HUB WHEN 1        */
-  } bit;                       /*!< Structure used for bit access                             */
-  uint16_t reg;                /*!< Type      used for register access                        */
+    struct {
+        uint16_t RSVD4 : 1;       /*!< bit:      0                                               */
+        uint16_t RSVD3 : 1;       /*!< bit:      1                                               */
+        uint16_t RSVD2 : 1;       /*!< bit:      2                                               */
+        uint16_t RSVD1 : 1;       /*!< bit:      3                                               */
+        uint16_t SDB_N : 1;       /*!< bit:      4  SHUTDOWN THE CHIP WHEN 0, RUN WHEN 1         */
+        uint16_t IRST : 1;        /*!< bit:      5  RESET THE IS3733 I2C WHEN 1, RUN WHEN 0      */
+        uint16_t SRC_2 : 1;       /*!< bit:      6  ADVERTISE A SOURCE TO USBC-2 CC              */
+        uint16_t SRC_1 : 1;       /*!< bit:      7  ADVERTISE A SOURCE TO USBC-1 CC              */
+        uint16_t E_VBUS_2 : 1;    /*!< bit:      8  ENABLE 5V OUT TO USBC-2 WHEN 1               */
+        uint16_t E_VBUS_1 : 1;    /*!< bit:      9  ENABLE 5V OUT TO USBC-1 WHEN 1               */
+        uint16_t E_DN1_N : 1;     /*!< bit:     10  ENABLE DN1 1:2 MUX WHEN 0                    */
+        uint16_t S_DN1 : 1;       /*!< bit:     11  SELECT DN1 PATH 0:USBC-1, 1:USBC-2           */
+        uint16_t E_UP_N : 1;      /*!< bit:     12  ENABLE SUP 1:2 MUX WHEN 0                    */
+        uint16_t S_UP : 1;        /*!< bit:     13  SELECT UP PATH 0:USBC-1, 1:USBC-2            */
+        uint16_t HUB_RESET_N : 1; /*!< bit:     14  RESET USB HUB WHEN 0, RUN WHEN 1             */
+        uint16_t HUB_CONNECT : 1; /*!< bit:     15  SIGNAL VBUS CONNECT TO USB HUB WHEN 1        */
+    } bit;                        /*!< Structure used for bit access                             */
+    uint16_t reg;                 /*!< Type      used for register access                        */
 } sr_exp_t;
 
 extern sr_exp_t sr_exp_data;
@@ -67,4 +67,4 @@ extern sr_exp_t sr_exp_data;
 void SR_EXP_WriteData(void);
 void SR_EXP_Init(void);
 
-#endif //_SPI_H_
+#endif  //_SPI_H_
diff --git a/tmk_core/protocol/arm_atsam/startup.c b/tmk_core/protocol/arm_atsam/startup.c
index f29fac179..7a5791ab5 100644
--- a/tmk_core/protocol/arm_atsam/startup.c
+++ b/tmk_core/protocol/arm_atsam/startup.c
@@ -14,9 +14,9 @@
  * Licensed under the Apache License, Version 2.0 (the "License"); you may
  * not use this file except in compliance with the License.
  * You may obtain a copy of the Licence at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an AS IS BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -51,447 +51,448 @@ void __libc_init_array(void);
 void Dummy_Handler(void);
 
 /* Cortex-M4 core handlers */
-void NMI_Handler             ( void ) __attribute__ ((weak, alias("Dummy_Handler")));
-void HardFault_Handler       ( void ) __attribute__ ((weak, alias("Dummy_Handler")));
-void MemManage_Handler       ( void ) __attribute__ ((weak, alias("Dummy_Handler")));
-void BusFault_Handler        ( void ) __attribute__ ((weak, alias("Dummy_Handler")));
-void UsageFault_Handler      ( void ) __attribute__ ((weak, alias("Dummy_Handler")));
-void SVC_Handler             ( void ) __attribute__ ((weak, alias("Dummy_Handler")));
-void DebugMon_Handler        ( void ) __attribute__ ((weak, alias("Dummy_Handler")));
-void PendSV_Handler          ( void ) __attribute__ ((weak, alias("Dummy_Handler")));
-void SysTick_Handler         ( void ) __attribute__ ((weak, alias("Dummy_Handler")));
+void NMI_Handler(void) __attribute__((weak, alias("Dummy_Handler")));
+void HardFault_Handler(void) __attribute__((weak, alias("Dummy_Handler")));
+void MemManage_Handler(void) __attribute__((weak, alias("Dummy_Handler")));
+void BusFault_Handler(void) __attribute__((weak, alias("Dummy_Handler")));
+void UsageFault_Handler(void) __attribute__((weak, alias("Dummy_Handler")));
+void SVC_Handler(void) __attribute__((weak, alias("Dummy_Handler")));
+void DebugMon_Handler(void) __attribute__((weak, alias("Dummy_Handler")));
+void PendSV_Handler(void) __attribute__((weak, alias("Dummy_Handler")));
+void SysTick_Handler(void) __attribute__((weak, alias("Dummy_Handler")));
 
 /* Peripherals handlers */
-void PM_Handler              ( void ) __attribute__ ((weak, alias("Dummy_Handler")));
-void MCLK_Handler            ( void ) __attribute__ ((weak, alias("Dummy_Handler")));
-void OSCCTRL_0_Handler       ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* OSCCTRL_XOSCFAIL_0, OSCCTRL_XOSCRDY_0 */
-void OSCCTRL_1_Handler       ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* OSCCTRL_XOSCFAIL_1, OSCCTRL_XOSCRDY_1 */
-void OSCCTRL_2_Handler       ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* OSCCTRL_DFLLLOCKC, OSCCTRL_DFLLLOCKF, OSCCTRL_DFLLOOB, OSCCTRL_DFLLRCS, OSCCTRL_DFLLRDY */
-void OSCCTRL_3_Handler       ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* OSCCTRL_DPLLLCKF_0, OSCCTRL_DPLLLCKR_0, OSCCTRL_DPLLLDRTO_0, OSCCTRL_DPLLLTO_0 */
-void OSCCTRL_4_Handler       ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* OSCCTRL_DPLLLCKF_1, OSCCTRL_DPLLLCKR_1, OSCCTRL_DPLLLDRTO_1, OSCCTRL_DPLLLTO_1 */
-void OSC32KCTRL_Handler      ( void ) __attribute__ ((weak, alias("Dummy_Handler")));
-void SUPC_0_Handler          ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* SUPC_B12SRDY, SUPC_B33SRDY, SUPC_BOD12RDY, SUPC_BOD33RDY, SUPC_VCORERDY, SUPC_VREGRDY */
-void SUPC_1_Handler          ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* SUPC_BOD12DET, SUPC_BOD33DET */
-void WDT_Handler             ( void ) __attribute__ ((weak, alias("Dummy_Handler")));
-void RTC_Handler             ( void ) __attribute__ ((weak, alias("Dummy_Handler")));
-void EIC_0_Handler           ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* EIC_EXTINT_0 */
-void EIC_1_Handler           ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* EIC_EXTINT_1 */
-void EIC_2_Handler           ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* EIC_EXTINT_2 */
-void EIC_3_Handler           ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* EIC_EXTINT_3 */
-void EIC_4_Handler           ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* EIC_EXTINT_4 */
-void EIC_5_Handler           ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* EIC_EXTINT_5 */
-void EIC_6_Handler           ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* EIC_EXTINT_6 */
-void EIC_7_Handler           ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* EIC_EXTINT_7 */
-void EIC_8_Handler           ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* EIC_EXTINT_8 */
-void EIC_9_Handler           ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* EIC_EXTINT_9 */
-void EIC_10_Handler          ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* EIC_EXTINT_10 */
-void EIC_11_Handler          ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* EIC_EXTINT_11 */
-void EIC_12_Handler          ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* EIC_EXTINT_12 */
-void EIC_13_Handler          ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* EIC_EXTINT_13 */
-void EIC_14_Handler          ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* EIC_EXTINT_14 */
-void EIC_15_Handler          ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* EIC_EXTINT_15 */
-void FREQM_Handler           ( void ) __attribute__ ((weak, alias("Dummy_Handler")));
-void NVMCTRL_0_Handler       ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* NVMCTRL_0, NVMCTRL_1, NVMCTRL_2, NVMCTRL_3, NVMCTRL_4, NVMCTRL_5, NVMCTRL_6, NVMCTRL_7 */
-void NVMCTRL_1_Handler       ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* NVMCTRL_10, NVMCTRL_8, NVMCTRL_9 */
-void DMAC_0_Handler          ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* DMAC_SUSP_0, DMAC_TCMPL_0, DMAC_TERR_0 */
-void DMAC_1_Handler          ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* DMAC_SUSP_1, DMAC_TCMPL_1, DMAC_TERR_1 */
-void DMAC_2_Handler          ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* DMAC_SUSP_2, DMAC_TCMPL_2, DMAC_TERR_2 */
-void DMAC_3_Handler          ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* DMAC_SUSP_3, DMAC_TCMPL_3, DMAC_TERR_3 */
-void DMAC_4_Handler          ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* DMAC_SUSP_10, DMAC_SUSP_11, DMAC_SUSP_12, DMAC_SUSP_13, DMAC_SUSP_14, DMAC_SUSP_15, DMAC_SUSP_16, DMAC_SUSP_17, DMAC_SUSP_18, DMAC_SUSP_19, DMAC_SUSP_20, DMAC_SUSP_21, DMAC_SUSP_22, DMAC_SUSP_23, DMAC_SUSP_24, DMAC_SUSP_25, DMAC_SUSP_26, DMAC_SUSP_27, DMAC_SUSP_28, DMAC_SUSP_29, DMAC_SUSP_30, DMAC_SUSP_31, DMAC_SUSP_4, DMAC_SUSP_5, DMAC_SUSP_6, DMAC_SUSP_7, DMAC_SUSP_8, DMAC_SUSP_9, DMAC_TCMPL_10, DMAC_TCMPL_11, DMAC_TCMPL_12, DMAC_TCMPL_13, DMAC_TCMPL_14, DMAC_TCMPL_15, DMAC_TCMPL_16, DMAC_TCMPL_17, DMAC_TCMPL_18, DMAC_TCMPL_19, DMAC_TCMPL_20, DMAC_TCMPL_21, DMAC_TCMPL_22, DMAC_TCMPL_23, DMAC_TCMPL_24, DMAC_TCMPL_25, DMAC_TCMPL_26, DMAC_TCMPL_27, DMAC_TCMPL_28, DMAC_TCMPL_29, DMAC_TCMPL_30, DMAC_TCMPL_31, DMAC_TCMPL_4, DMAC_TCMPL_5, DMAC_TCMPL_6, DMAC_TCMPL_7, DMAC_TCMPL_8, DMAC_TCMPL_9, DMAC_TERR_10, DMAC_TERR_11, DMAC_TERR_12, DMAC_TERR_13, DMAC_TERR_14, DMAC_TERR_15, DMAC_TERR_16, DMAC_TERR_17, DMAC_TERR_18, DMAC_TERR_19, DMAC_TERR_20, DMAC_TERR_21, DMAC_TERR_22, DMAC_TERR_23, DMAC_TERR_24, DMAC_TERR_25, DMAC_TERR_26, DMAC_TERR_27, DMAC_TERR_28, DMAC_TERR_29, DMAC_TERR_30, DMAC_TERR_31, DMAC_TERR_4, DMAC_TERR_5, DMAC_TERR_6, DMAC_TERR_7, DMAC_TERR_8, DMAC_TERR_9 */
-void EVSYS_0_Handler         ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* EVSYS_EVD_0, EVSYS_OVR_0 */
-void EVSYS_1_Handler         ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* EVSYS_EVD_1, EVSYS_OVR_1 */
-void EVSYS_2_Handler         ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* EVSYS_EVD_2, EVSYS_OVR_2 */
-void EVSYS_3_Handler         ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* EVSYS_EVD_3, EVSYS_OVR_3 */
-void EVSYS_4_Handler         ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* EVSYS_EVD_10, EVSYS_EVD_11, EVSYS_EVD_4, EVSYS_EVD_5, EVSYS_EVD_6, EVSYS_EVD_7, EVSYS_EVD_8, EVSYS_EVD_9, EVSYS_OVR_10, EVSYS_OVR_11, EVSYS_OVR_4, EVSYS_OVR_5, EVSYS_OVR_6, EVSYS_OVR_7, EVSYS_OVR_8, EVSYS_OVR_9 */
-void PAC_Handler             ( void ) __attribute__ ((weak, alias("Dummy_Handler")));
-void TAL_0_Handler           ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* TAL_BRK */
-void TAL_1_Handler           ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* TAL_IPS_0, TAL_IPS_1 */
-void RAMECC_Handler          ( void ) __attribute__ ((weak, alias("Dummy_Handler")));
-void SERCOM0_0_Handler       ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* SERCOM0_0 */
-void SERCOM0_1_Handler       ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* SERCOM0_1 */
-void SERCOM0_2_Handler       ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* SERCOM0_2 */
-void SERCOM0_3_Handler       ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* SERCOM0_3, SERCOM0_4, SERCOM0_5, SERCOM0_6 */
-void SERCOM1_0_Handler       ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* SERCOM1_0 */
-void SERCOM1_1_Handler       ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* SERCOM1_1 */
-void SERCOM1_2_Handler       ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* SERCOM1_2 */
-void SERCOM1_3_Handler       ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* SERCOM1_3, SERCOM1_4, SERCOM1_5, SERCOM1_6 */
-void SERCOM2_0_Handler       ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* SERCOM2_0 */
-void SERCOM2_1_Handler       ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* SERCOM2_1 */
-void SERCOM2_2_Handler       ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* SERCOM2_2 */
-void SERCOM2_3_Handler       ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* SERCOM2_3, SERCOM2_4, SERCOM2_5, SERCOM2_6 */
-void SERCOM3_0_Handler       ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* SERCOM3_0 */
-void SERCOM3_1_Handler       ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* SERCOM3_1 */
-void SERCOM3_2_Handler       ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* SERCOM3_2 */
-void SERCOM3_3_Handler       ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* SERCOM3_3, SERCOM3_4, SERCOM3_5, SERCOM3_6 */
+void PM_Handler(void) __attribute__((weak, alias("Dummy_Handler")));
+void MCLK_Handler(void) __attribute__((weak, alias("Dummy_Handler")));
+void OSCCTRL_0_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* OSCCTRL_XOSCFAIL_0, OSCCTRL_XOSCRDY_0 */
+void OSCCTRL_1_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* OSCCTRL_XOSCFAIL_1, OSCCTRL_XOSCRDY_1 */
+void OSCCTRL_2_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* OSCCTRL_DFLLLOCKC, OSCCTRL_DFLLLOCKF, OSCCTRL_DFLLOOB, OSCCTRL_DFLLRCS, OSCCTRL_DFLLRDY */
+void OSCCTRL_3_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* OSCCTRL_DPLLLCKF_0, OSCCTRL_DPLLLCKR_0, OSCCTRL_DPLLLDRTO_0, OSCCTRL_DPLLLTO_0 */
+void OSCCTRL_4_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* OSCCTRL_DPLLLCKF_1, OSCCTRL_DPLLLCKR_1, OSCCTRL_DPLLLDRTO_1, OSCCTRL_DPLLLTO_1 */
+void OSC32KCTRL_Handler(void) __attribute__((weak, alias("Dummy_Handler")));
+void SUPC_0_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* SUPC_B12SRDY, SUPC_B33SRDY, SUPC_BOD12RDY, SUPC_BOD33RDY, SUPC_VCORERDY, SUPC_VREGRDY */
+void SUPC_1_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* SUPC_BOD12DET, SUPC_BOD33DET */
+void WDT_Handler(void) __attribute__((weak, alias("Dummy_Handler")));
+void RTC_Handler(void) __attribute__((weak, alias("Dummy_Handler")));
+void EIC_0_Handler(void) __attribute__((weak, alias("Dummy_Handler")));  /* EIC_EXTINT_0 */
+void EIC_1_Handler(void) __attribute__((weak, alias("Dummy_Handler")));  /* EIC_EXTINT_1 */
+void EIC_2_Handler(void) __attribute__((weak, alias("Dummy_Handler")));  /* EIC_EXTINT_2 */
+void EIC_3_Handler(void) __attribute__((weak, alias("Dummy_Handler")));  /* EIC_EXTINT_3 */
+void EIC_4_Handler(void) __attribute__((weak, alias("Dummy_Handler")));  /* EIC_EXTINT_4 */
+void EIC_5_Handler(void) __attribute__((weak, alias("Dummy_Handler")));  /* EIC_EXTINT_5 */
+void EIC_6_Handler(void) __attribute__((weak, alias("Dummy_Handler")));  /* EIC_EXTINT_6 */
+void EIC_7_Handler(void) __attribute__((weak, alias("Dummy_Handler")));  /* EIC_EXTINT_7 */
+void EIC_8_Handler(void) __attribute__((weak, alias("Dummy_Handler")));  /* EIC_EXTINT_8 */
+void EIC_9_Handler(void) __attribute__((weak, alias("Dummy_Handler")));  /* EIC_EXTINT_9 */
+void EIC_10_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* EIC_EXTINT_10 */
+void EIC_11_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* EIC_EXTINT_11 */
+void EIC_12_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* EIC_EXTINT_12 */
+void EIC_13_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* EIC_EXTINT_13 */
+void EIC_14_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* EIC_EXTINT_14 */
+void EIC_15_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* EIC_EXTINT_15 */
+void FREQM_Handler(void) __attribute__((weak, alias("Dummy_Handler")));
+void NVMCTRL_0_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* NVMCTRL_0, NVMCTRL_1, NVMCTRL_2, NVMCTRL_3, NVMCTRL_4, NVMCTRL_5, NVMCTRL_6, NVMCTRL_7 */
+void NVMCTRL_1_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* NVMCTRL_10, NVMCTRL_8, NVMCTRL_9 */
+void DMAC_0_Handler(void) __attribute__((weak, alias("Dummy_Handler")));    /* DMAC_SUSP_0, DMAC_TCMPL_0, DMAC_TERR_0 */
+void DMAC_1_Handler(void) __attribute__((weak, alias("Dummy_Handler")));    /* DMAC_SUSP_1, DMAC_TCMPL_1, DMAC_TERR_1 */
+void DMAC_2_Handler(void) __attribute__((weak, alias("Dummy_Handler")));    /* DMAC_SUSP_2, DMAC_TCMPL_2, DMAC_TERR_2 */
+void DMAC_3_Handler(void) __attribute__((weak, alias("Dummy_Handler")));    /* DMAC_SUSP_3, DMAC_TCMPL_3, DMAC_TERR_3 */
+void DMAC_4_Handler(void) __attribute__((weak, alias("Dummy_Handler")));    /* DMAC_SUSP_10, DMAC_SUSP_11, DMAC_SUSP_12, DMAC_SUSP_13, DMAC_SUSP_14, DMAC_SUSP_15, DMAC_SUSP_16, DMAC_SUSP_17, DMAC_SUSP_18, DMAC_SUSP_19, DMAC_SUSP_20, DMAC_SUSP_21, DMAC_SUSP_22, DMAC_SUSP_23, DMAC_SUSP_24, DMAC_SUSP_25, DMAC_SUSP_26, DMAC_SUSP_27, DMAC_SUSP_28, DMAC_SUSP_29, DMAC_SUSP_30, DMAC_SUSP_31, DMAC_SUSP_4, DMAC_SUSP_5, DMAC_SUSP_6, DMAC_SUSP_7, DMAC_SUSP_8, DMAC_SUSP_9, DMAC_TCMPL_10, DMAC_TCMPL_11, DMAC_TCMPL_12, DMAC_TCMPL_13, DMAC_TCMPL_14, DMAC_TCMPL_15, DMAC_TCMPL_16, DMAC_TCMPL_17, DMAC_TCMPL_18, DMAC_TCMPL_19, DMAC_TCMPL_20, DMAC_TCMPL_21, DMAC_TCMPL_22, DMAC_TCMPL_23, DMAC_TCMPL_24, DMAC_TCMPL_25, DMAC_TCMPL_26, DMAC_TCMPL_27, DMAC_TCMPL_28, DMAC_TCMPL_29, DMAC_TCMPL_30, DMAC_TCMPL_31, DMAC_TCMPL_4, DMAC_TCMPL_5, DMAC_TCMPL_6, DMAC_TCMPL_7, DMAC_TCMPL_8, DMAC_TCMPL_9, DMAC_TERR_10, DMAC_TERR_11, DMAC_TERR_12, DMAC_TERR_13, DMAC_TERR_14, DMAC_TERR_15, DMAC_TERR_16, DMAC_TERR_17,
+                                                                               DMAC_TERR_18, DMAC_TERR_19, DMAC_TERR_20, DMAC_TERR_21, DMAC_TERR_22, DMAC_TERR_23, DMAC_TERR_24, DMAC_TERR_25, DMAC_TERR_26, DMAC_TERR_27, DMAC_TERR_28, DMAC_TERR_29, DMAC_TERR_30, DMAC_TERR_31, DMAC_TERR_4, DMAC_TERR_5, DMAC_TERR_6, DMAC_TERR_7, DMAC_TERR_8, DMAC_TERR_9 */
+void EVSYS_0_Handler(void) __attribute__((weak, alias("Dummy_Handler")));   /* EVSYS_EVD_0, EVSYS_OVR_0 */
+void EVSYS_1_Handler(void) __attribute__((weak, alias("Dummy_Handler")));   /* EVSYS_EVD_1, EVSYS_OVR_1 */
+void EVSYS_2_Handler(void) __attribute__((weak, alias("Dummy_Handler")));   /* EVSYS_EVD_2, EVSYS_OVR_2 */
+void EVSYS_3_Handler(void) __attribute__((weak, alias("Dummy_Handler")));   /* EVSYS_EVD_3, EVSYS_OVR_3 */
+void EVSYS_4_Handler(void) __attribute__((weak, alias("Dummy_Handler")));   /* EVSYS_EVD_10, EVSYS_EVD_11, EVSYS_EVD_4, EVSYS_EVD_5, EVSYS_EVD_6, EVSYS_EVD_7, EVSYS_EVD_8, EVSYS_EVD_9, EVSYS_OVR_10, EVSYS_OVR_11, EVSYS_OVR_4, EVSYS_OVR_5, EVSYS_OVR_6, EVSYS_OVR_7, EVSYS_OVR_8, EVSYS_OVR_9 */
+void PAC_Handler(void) __attribute__((weak, alias("Dummy_Handler")));
+void TAL_0_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* TAL_BRK */
+void TAL_1_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* TAL_IPS_0, TAL_IPS_1 */
+void RAMECC_Handler(void) __attribute__((weak, alias("Dummy_Handler")));
+void SERCOM0_0_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* SERCOM0_0 */
+void SERCOM0_1_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* SERCOM0_1 */
+void SERCOM0_2_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* SERCOM0_2 */
+void SERCOM0_3_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* SERCOM0_3, SERCOM0_4, SERCOM0_5, SERCOM0_6 */
+void SERCOM1_0_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* SERCOM1_0 */
+void SERCOM1_1_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* SERCOM1_1 */
+void SERCOM1_2_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* SERCOM1_2 */
+void SERCOM1_3_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* SERCOM1_3, SERCOM1_4, SERCOM1_5, SERCOM1_6 */
+void SERCOM2_0_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* SERCOM2_0 */
+void SERCOM2_1_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* SERCOM2_1 */
+void SERCOM2_2_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* SERCOM2_2 */
+void SERCOM2_3_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* SERCOM2_3, SERCOM2_4, SERCOM2_5, SERCOM2_6 */
+void SERCOM3_0_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* SERCOM3_0 */
+void SERCOM3_1_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* SERCOM3_1 */
+void SERCOM3_2_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* SERCOM3_2 */
+void SERCOM3_3_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* SERCOM3_3, SERCOM3_4, SERCOM3_5, SERCOM3_6 */
 #ifdef ID_SERCOM4
-void SERCOM4_0_Handler       ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* SERCOM4_0 */
-void SERCOM4_1_Handler       ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* SERCOM4_1 */
-void SERCOM4_2_Handler       ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* SERCOM4_2 */
-void SERCOM4_3_Handler       ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* SERCOM4_3, SERCOM4_4, SERCOM4_5, SERCOM4_6 */
+void SERCOM4_0_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* SERCOM4_0 */
+void SERCOM4_1_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* SERCOM4_1 */
+void SERCOM4_2_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* SERCOM4_2 */
+void SERCOM4_3_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* SERCOM4_3, SERCOM4_4, SERCOM4_5, SERCOM4_6 */
 #endif
 #ifdef ID_SERCOM5
-void SERCOM5_0_Handler       ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* SERCOM5_0 */
-void SERCOM5_1_Handler       ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* SERCOM5_1 */
-void SERCOM5_2_Handler       ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* SERCOM5_2 */
-void SERCOM5_3_Handler       ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* SERCOM5_3, SERCOM5_4, SERCOM5_5, SERCOM5_6 */
+void SERCOM5_0_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* SERCOM5_0 */
+void SERCOM5_1_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* SERCOM5_1 */
+void SERCOM5_2_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* SERCOM5_2 */
+void SERCOM5_3_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* SERCOM5_3, SERCOM5_4, SERCOM5_5, SERCOM5_6 */
 #endif
 #ifdef ID_SERCOM6
-void SERCOM6_0_Handler       ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* SERCOM6_0 */
-void SERCOM6_1_Handler       ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* SERCOM6_1 */
-void SERCOM6_2_Handler       ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* SERCOM6_2 */
-void SERCOM6_3_Handler       ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* SERCOM6_3, SERCOM6_4, SERCOM6_5, SERCOM6_6 */
+void SERCOM6_0_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* SERCOM6_0 */
+void SERCOM6_1_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* SERCOM6_1 */
+void SERCOM6_2_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* SERCOM6_2 */
+void SERCOM6_3_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* SERCOM6_3, SERCOM6_4, SERCOM6_5, SERCOM6_6 */
 #endif
 #ifdef ID_SERCOM7
-void SERCOM7_0_Handler       ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* SERCOM7_0 */
-void SERCOM7_1_Handler       ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* SERCOM7_1 */
-void SERCOM7_2_Handler       ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* SERCOM7_2 */
-void SERCOM7_3_Handler       ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* SERCOM7_3, SERCOM7_4, SERCOM7_5, SERCOM7_6 */
+void SERCOM7_0_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* SERCOM7_0 */
+void SERCOM7_1_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* SERCOM7_1 */
+void SERCOM7_2_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* SERCOM7_2 */
+void SERCOM7_3_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* SERCOM7_3, SERCOM7_4, SERCOM7_5, SERCOM7_6 */
 #endif
 #ifdef ID_CAN0
-void CAN0_Handler            ( void ) __attribute__ ((weak, alias("Dummy_Handler")));
+void CAN0_Handler(void) __attribute__((weak, alias("Dummy_Handler")));
 #endif
 #ifdef ID_CAN1
-void CAN1_Handler            ( void ) __attribute__ ((weak, alias("Dummy_Handler")));
+void CAN1_Handler(void) __attribute__((weak, alias("Dummy_Handler")));
 #endif
 #ifdef ID_USB
-void USB_0_Handler           ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* USB_EORSM_DNRSM, USB_EORST_RST, USB_LPMSUSP_DDISC, USB_LPM_DCONN, USB_MSOF, USB_RAMACER, USB_RXSTP_TXSTP_0, USB_RXSTP_TXSTP_1, USB_RXSTP_TXSTP_2, USB_RXSTP_TXSTP_3, USB_RXSTP_TXSTP_4, USB_RXSTP_TXSTP_5, USB_RXSTP_TXSTP_6, USB_RXSTP_TXSTP_7, USB_STALL0_STALL_0, USB_STALL0_STALL_1, USB_STALL0_STALL_2, USB_STALL0_STALL_3, USB_STALL0_STALL_4, USB_STALL0_STALL_5, USB_STALL0_STALL_6, USB_STALL0_STALL_7, USB_STALL1_0, USB_STALL1_1, USB_STALL1_2, USB_STALL1_3, USB_STALL1_4, USB_STALL1_5, USB_STALL1_6, USB_STALL1_7, USB_SUSPEND, USB_TRFAIL0_TRFAIL_0, USB_TRFAIL0_TRFAIL_1, USB_TRFAIL0_TRFAIL_2, USB_TRFAIL0_TRFAIL_3, USB_TRFAIL0_TRFAIL_4, USB_TRFAIL0_TRFAIL_5, USB_TRFAIL0_TRFAIL_6, USB_TRFAIL0_TRFAIL_7, USB_TRFAIL1_PERR_0, USB_TRFAIL1_PERR_1, USB_TRFAIL1_PERR_2, USB_TRFAIL1_PERR_3, USB_TRFAIL1_PERR_4, USB_TRFAIL1_PERR_5, USB_TRFAIL1_PERR_6, USB_TRFAIL1_PERR_7, USB_UPRSM, USB_WAKEUP */
-void USB_1_Handler           ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* USB_SOF_HSOF */
-void USB_2_Handler           ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* USB_TRCPT0_0, USB_TRCPT0_1, USB_TRCPT0_2, USB_TRCPT0_3, USB_TRCPT0_4, USB_TRCPT0_5, USB_TRCPT0_6, USB_TRCPT0_7 */
-void USB_3_Handler           ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* USB_TRCPT1_0, USB_TRCPT1_1, USB_TRCPT1_2, USB_TRCPT1_3, USB_TRCPT1_4, USB_TRCPT1_5, USB_TRCPT1_6, USB_TRCPT1_7 */
+void USB_0_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* USB_EORSM_DNRSM, USB_EORST_RST, USB_LPMSUSP_DDISC, USB_LPM_DCONN, USB_MSOF, USB_RAMACER, USB_RXSTP_TXSTP_0, USB_RXSTP_TXSTP_1, USB_RXSTP_TXSTP_2, USB_RXSTP_TXSTP_3, USB_RXSTP_TXSTP_4, USB_RXSTP_TXSTP_5, USB_RXSTP_TXSTP_6, USB_RXSTP_TXSTP_7, USB_STALL0_STALL_0, USB_STALL0_STALL_1, USB_STALL0_STALL_2, USB_STALL0_STALL_3, USB_STALL0_STALL_4, USB_STALL0_STALL_5, USB_STALL0_STALL_6, USB_STALL0_STALL_7, USB_STALL1_0, USB_STALL1_1, USB_STALL1_2, USB_STALL1_3, USB_STALL1_4, USB_STALL1_5, USB_STALL1_6, USB_STALL1_7, USB_SUSPEND, USB_TRFAIL0_TRFAIL_0, USB_TRFAIL0_TRFAIL_1, USB_TRFAIL0_TRFAIL_2, USB_TRFAIL0_TRFAIL_3, USB_TRFAIL0_TRFAIL_4, USB_TRFAIL0_TRFAIL_5, USB_TRFAIL0_TRFAIL_6, USB_TRFAIL0_TRFAIL_7, USB_TRFAIL1_PERR_0, USB_TRFAIL1_PERR_1, USB_TRFAIL1_PERR_2, USB_TRFAIL1_PERR_3, USB_TRFAIL1_PERR_4, USB_TRFAIL1_PERR_5, USB_TRFAIL1_PERR_6, USB_TRFAIL1_PERR_7, USB_UPRSM, USB_WAKEUP */
+void USB_1_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* USB_SOF_HSOF */
+void USB_2_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* USB_TRCPT0_0, USB_TRCPT0_1, USB_TRCPT0_2, USB_TRCPT0_3, USB_TRCPT0_4, USB_TRCPT0_5, USB_TRCPT0_6, USB_TRCPT0_7 */
+void USB_3_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* USB_TRCPT1_0, USB_TRCPT1_1, USB_TRCPT1_2, USB_TRCPT1_3, USB_TRCPT1_4, USB_TRCPT1_5, USB_TRCPT1_6, USB_TRCPT1_7 */
 #endif
 #ifdef ID_GMAC
-void GMAC_Handler            ( void ) __attribute__ ((weak, alias("Dummy_Handler")));
-#endif
-void TCC0_0_Handler          ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* TCC0_CNT_A, TCC0_DFS_A, TCC0_ERR_A, TCC0_FAULT0_A, TCC0_FAULT1_A, TCC0_FAULTA_A, TCC0_FAULTB_A, TCC0_OVF, TCC0_TRG, TCC0_UFS_A */
-void TCC0_1_Handler          ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* TCC0_MC_0 */
-void TCC0_2_Handler          ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* TCC0_MC_1 */
-void TCC0_3_Handler          ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* TCC0_MC_2 */
-void TCC0_4_Handler          ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* TCC0_MC_3 */
-void TCC0_5_Handler          ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* TCC0_MC_4 */
-void TCC0_6_Handler          ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* TCC0_MC_5 */
-void TCC1_0_Handler          ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* TCC1_CNT_A, TCC1_DFS_A, TCC1_ERR_A, TCC1_FAULT0_A, TCC1_FAULT1_A, TCC1_FAULTA_A, TCC1_FAULTB_A, TCC1_OVF, TCC1_TRG, TCC1_UFS_A */
-void TCC1_1_Handler          ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* TCC1_MC_0 */
-void TCC1_2_Handler          ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* TCC1_MC_1 */
-void TCC1_3_Handler          ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* TCC1_MC_2 */
-void TCC1_4_Handler          ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* TCC1_MC_3 */
-void TCC2_0_Handler          ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* TCC2_CNT_A, TCC2_DFS_A, TCC2_ERR_A, TCC2_FAULT0_A, TCC2_FAULT1_A, TCC2_FAULTA_A, TCC2_FAULTB_A, TCC2_OVF, TCC2_TRG, TCC2_UFS_A */
-void TCC2_1_Handler          ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* TCC2_MC_0 */
-void TCC2_2_Handler          ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* TCC2_MC_1 */
-void TCC2_3_Handler          ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* TCC2_MC_2 */
+void GMAC_Handler(void) __attribute__((weak, alias("Dummy_Handler")));
+#endif
+void TCC0_0_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* TCC0_CNT_A, TCC0_DFS_A, TCC0_ERR_A, TCC0_FAULT0_A, TCC0_FAULT1_A, TCC0_FAULTA_A, TCC0_FAULTB_A, TCC0_OVF, TCC0_TRG, TCC0_UFS_A */
+void TCC0_1_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* TCC0_MC_0 */
+void TCC0_2_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* TCC0_MC_1 */
+void TCC0_3_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* TCC0_MC_2 */
+void TCC0_4_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* TCC0_MC_3 */
+void TCC0_5_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* TCC0_MC_4 */
+void TCC0_6_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* TCC0_MC_5 */
+void TCC1_0_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* TCC1_CNT_A, TCC1_DFS_A, TCC1_ERR_A, TCC1_FAULT0_A, TCC1_FAULT1_A, TCC1_FAULTA_A, TCC1_FAULTB_A, TCC1_OVF, TCC1_TRG, TCC1_UFS_A */
+void TCC1_1_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* TCC1_MC_0 */
+void TCC1_2_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* TCC1_MC_1 */
+void TCC1_3_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* TCC1_MC_2 */
+void TCC1_4_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* TCC1_MC_3 */
+void TCC2_0_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* TCC2_CNT_A, TCC2_DFS_A, TCC2_ERR_A, TCC2_FAULT0_A, TCC2_FAULT1_A, TCC2_FAULTA_A, TCC2_FAULTB_A, TCC2_OVF, TCC2_TRG, TCC2_UFS_A */
+void TCC2_1_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* TCC2_MC_0 */
+void TCC2_2_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* TCC2_MC_1 */
+void TCC2_3_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* TCC2_MC_2 */
 #ifdef ID_TCC3
-void TCC3_0_Handler          ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* TCC3_CNT_A, TCC3_DFS_A, TCC3_ERR_A, TCC3_FAULT0_A, TCC3_FAULT1_A, TCC3_FAULTA_A, TCC3_FAULTB_A, TCC3_OVF, TCC3_TRG, TCC3_UFS_A */
-void TCC3_1_Handler          ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* TCC3_MC_0 */
-void TCC3_2_Handler          ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* TCC3_MC_1 */
+void TCC3_0_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* TCC3_CNT_A, TCC3_DFS_A, TCC3_ERR_A, TCC3_FAULT0_A, TCC3_FAULT1_A, TCC3_FAULTA_A, TCC3_FAULTB_A, TCC3_OVF, TCC3_TRG, TCC3_UFS_A */
+void TCC3_1_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* TCC3_MC_0 */
+void TCC3_2_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* TCC3_MC_1 */
 #endif
 #ifdef ID_TCC4
-void TCC4_0_Handler          ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* TCC4_CNT_A, TCC4_DFS_A, TCC4_ERR_A, TCC4_FAULT0_A, TCC4_FAULT1_A, TCC4_FAULTA_A, TCC4_FAULTB_A, TCC4_OVF, TCC4_TRG, TCC4_UFS_A */
-void TCC4_1_Handler          ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* TCC4_MC_0 */
-void TCC4_2_Handler          ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* TCC4_MC_1 */
-#endif
-void TC0_Handler             ( void ) __attribute__ ((weak, alias("Dummy_Handler")));
-void TC1_Handler             ( void ) __attribute__ ((weak, alias("Dummy_Handler")));
-void TC2_Handler             ( void ) __attribute__ ((weak, alias("Dummy_Handler")));
-void TC3_Handler             ( void ) __attribute__ ((weak, alias("Dummy_Handler")));
+void TCC4_0_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* TCC4_CNT_A, TCC4_DFS_A, TCC4_ERR_A, TCC4_FAULT0_A, TCC4_FAULT1_A, TCC4_FAULTA_A, TCC4_FAULTB_A, TCC4_OVF, TCC4_TRG, TCC4_UFS_A */
+void TCC4_1_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* TCC4_MC_0 */
+void TCC4_2_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* TCC4_MC_1 */
+#endif
+void TC0_Handler(void) __attribute__((weak, alias("Dummy_Handler")));
+void TC1_Handler(void) __attribute__((weak, alias("Dummy_Handler")));
+void TC2_Handler(void) __attribute__((weak, alias("Dummy_Handler")));
+void TC3_Handler(void) __attribute__((weak, alias("Dummy_Handler")));
 #ifdef ID_TC4
-void TC4_Handler             ( void ) __attribute__ ((weak, alias("Dummy_Handler")));
+void TC4_Handler(void) __attribute__((weak, alias("Dummy_Handler")));
 #endif
 #ifdef ID_TC5
-void TC5_Handler             ( void ) __attribute__ ((weak, alias("Dummy_Handler")));
+void TC5_Handler(void) __attribute__((weak, alias("Dummy_Handler")));
 #endif
 #ifdef ID_TC6
-void TC6_Handler             ( void ) __attribute__ ((weak, alias("Dummy_Handler")));
+void TC6_Handler(void) __attribute__((weak, alias("Dummy_Handler")));
 #endif
 #ifdef ID_TC7
-void TC7_Handler             ( void ) __attribute__ ((weak, alias("Dummy_Handler")));
-#endif
-void PDEC_0_Handler          ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* PDEC_DIR_A, PDEC_ERR_A, PDEC_OVF, PDEC_VLC_A */
-void PDEC_1_Handler          ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* PDEC_MC_0 */
-void PDEC_2_Handler          ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* PDEC_MC_1 */
-void ADC0_0_Handler          ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* ADC0_OVERRUN, ADC0_WINMON */
-void ADC0_1_Handler          ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* ADC0_RESRDY */
-void ADC1_0_Handler          ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* ADC1_OVERRUN, ADC1_WINMON */
-void ADC1_1_Handler          ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* ADC1_RESRDY */
-void AC_Handler              ( void ) __attribute__ ((weak, alias("Dummy_Handler")));
-void DAC_0_Handler           ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* DAC_OVERRUN_A_0, DAC_OVERRUN_A_1, DAC_UNDERRUN_A_0, DAC_UNDERRUN_A_1 */
-void DAC_1_Handler           ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* DAC_EMPTY_0 */
-void DAC_2_Handler           ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* DAC_EMPTY_1 */
-void DAC_3_Handler           ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* DAC_RESRDY_0 */
-void DAC_4_Handler           ( void ) __attribute__ ((weak, alias("Dummy_Handler"))); /* DAC_RESRDY_1 */
+void TC7_Handler(void) __attribute__((weak, alias("Dummy_Handler")));
+#endif
+void PDEC_0_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* PDEC_DIR_A, PDEC_ERR_A, PDEC_OVF, PDEC_VLC_A */
+void PDEC_1_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* PDEC_MC_0 */
+void PDEC_2_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* PDEC_MC_1 */
+void ADC0_0_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* ADC0_OVERRUN, ADC0_WINMON */
+void ADC0_1_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* ADC0_RESRDY */
+void ADC1_0_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* ADC1_OVERRUN, ADC1_WINMON */
+void ADC1_1_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* ADC1_RESRDY */
+void AC_Handler(void) __attribute__((weak, alias("Dummy_Handler")));
+void DAC_0_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* DAC_OVERRUN_A_0, DAC_OVERRUN_A_1, DAC_UNDERRUN_A_0, DAC_UNDERRUN_A_1 */
+void DAC_1_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* DAC_EMPTY_0 */
+void DAC_2_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* DAC_EMPTY_1 */
+void DAC_3_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* DAC_RESRDY_0 */
+void DAC_4_Handler(void) __attribute__((weak, alias("Dummy_Handler"))); /* DAC_RESRDY_1 */
 #ifdef ID_I2S
-void I2S_Handler             ( void ) __attribute__ ((weak, alias("Dummy_Handler")));
+void I2S_Handler(void) __attribute__((weak, alias("Dummy_Handler")));
 #endif
-void PCC_Handler             ( void ) __attribute__ ((weak, alias("Dummy_Handler")));
-void AES_Handler             ( void ) __attribute__ ((weak, alias("Dummy_Handler")));
-void TRNG_Handler            ( void ) __attribute__ ((weak, alias("Dummy_Handler")));
+void PCC_Handler(void) __attribute__((weak, alias("Dummy_Handler")));
+void AES_Handler(void) __attribute__((weak, alias("Dummy_Handler")));
+void TRNG_Handler(void) __attribute__((weak, alias("Dummy_Handler")));
 #ifdef ID_ICM
-void ICM_Handler             ( void ) __attribute__ ((weak, alias("Dummy_Handler")));
+void ICM_Handler(void) __attribute__((weak, alias("Dummy_Handler")));
 #endif
 #ifdef ID_PUKCC
-void PUKCC_Handler           ( void ) __attribute__ ((weak, alias("Dummy_Handler")));
+void PUKCC_Handler(void) __attribute__((weak, alias("Dummy_Handler")));
 #endif
-void QSPI_Handler            ( void ) __attribute__ ((weak, alias("Dummy_Handler")));
+void QSPI_Handler(void) __attribute__((weak, alias("Dummy_Handler")));
 #ifdef ID_SDHC0
-void SDHC0_Handler           ( void ) __attribute__ ((weak, alias("Dummy_Handler")));
+void SDHC0_Handler(void) __attribute__((weak, alias("Dummy_Handler")));
 #endif
 #ifdef ID_SDHC1
-void SDHC1_Handler           ( void ) __attribute__ ((weak, alias("Dummy_Handler")));
+void SDHC1_Handler(void) __attribute__((weak, alias("Dummy_Handler")));
 #endif
 
 /* Exception Table */
-__attribute__ ((section(".vectors")))
-const DeviceVectors exception_table = {
+__attribute__((section(".vectors"))) const DeviceVectors exception_table = {
 
-        /* Configure Initial Stack Pointer, using linker-generated symbols */
-        .pvStack                = (void*) (&_estack),
+    /* Configure Initial Stack Pointer, using linker-generated symbols */
+    .pvStack = (void *)(&_estack),
 
-        .pfnReset_Handler       = (void*) Reset_Handler,
-        .pfnNMI_Handler         = (void*) NMI_Handler,
-        .pfnHardFault_Handler   = (void*) HardFault_Handler,
-        .pfnMemManage_Handler   = (void*) MemManage_Handler,
-        .pfnBusFault_Handler    = (void*) BusFault_Handler,
-        .pfnUsageFault_Handler  = (void*) UsageFault_Handler,
-        .pvReservedM9           = (void*) (0UL), /* Reserved */
-        .pvReservedM8           = (void*) (0UL), /* Reserved */
-        .pvReservedM7           = (void*) (0UL), /* Reserved */
-        .pvReservedM6           = (void*) (0UL), /* Reserved */
-        .pfnSVC_Handler         = (void*) SVC_Handler,
-        .pfnDebugMon_Handler    = (void*) DebugMon_Handler,
-        .pvReservedM3           = (void*) (0UL), /* Reserved */
-        .pfnPendSV_Handler      = (void*) PendSV_Handler,
-        .pfnSysTick_Handler     = (void*) SysTick_Handler,
+    .pfnReset_Handler      = (void *)Reset_Handler,
+    .pfnNMI_Handler        = (void *)NMI_Handler,
+    .pfnHardFault_Handler  = (void *)HardFault_Handler,
+    .pfnMemManage_Handler  = (void *)MemManage_Handler,
+    .pfnBusFault_Handler   = (void *)BusFault_Handler,
+    .pfnUsageFault_Handler = (void *)UsageFault_Handler,
+    .pvReservedM9          = (void *)(0UL), /* Reserved */
+    .pvReservedM8          = (void *)(0UL), /* Reserved */
+    .pvReservedM7          = (void *)(0UL), /* Reserved */
+    .pvReservedM6          = (void *)(0UL), /* Reserved */
+    .pfnSVC_Handler        = (void *)SVC_Handler,
+    .pfnDebugMon_Handler   = (void *)DebugMon_Handler,
+    .pvReservedM3          = (void *)(0UL), /* Reserved */
+    .pfnPendSV_Handler     = (void *)PendSV_Handler,
+    .pfnSysTick_Handler    = (void *)SysTick_Handler,
 
-        /* Configurable interrupts */
-        .pfnPM_Handler          = (void*) PM_Handler,             /*  0 Power Manager */
-        .pfnMCLK_Handler        = (void*) MCLK_Handler,           /*  1 Main Clock */
-        .pfnOSCCTRL_0_Handler   = (void*) OSCCTRL_0_Handler,      /*  2 OSCCTRL_XOSCFAIL_0, OSCCTRL_XOSCRDY_0 */
-        .pfnOSCCTRL_1_Handler   = (void*) OSCCTRL_1_Handler,      /*  3 OSCCTRL_XOSCFAIL_1, OSCCTRL_XOSCRDY_1 */
-        .pfnOSCCTRL_2_Handler   = (void*) OSCCTRL_2_Handler,      /*  4 OSCCTRL_DFLLLOCKC, OSCCTRL_DFLLLOCKF, OSCCTRL_DFLLOOB, OSCCTRL_DFLLRCS, OSCCTRL_DFLLRDY */
-        .pfnOSCCTRL_3_Handler   = (void*) OSCCTRL_3_Handler,      /*  5 OSCCTRL_DPLLLCKF_0, OSCCTRL_DPLLLCKR_0, OSCCTRL_DPLLLDRTO_0, OSCCTRL_DPLLLTO_0 */
-        .pfnOSCCTRL_4_Handler   = (void*) OSCCTRL_4_Handler,      /*  6 OSCCTRL_DPLLLCKF_1, OSCCTRL_DPLLLCKR_1, OSCCTRL_DPLLLDRTO_1, OSCCTRL_DPLLLTO_1 */
-        .pfnOSC32KCTRL_Handler  = (void*) OSC32KCTRL_Handler,     /*  7 32kHz Oscillators Control */
-        .pfnSUPC_0_Handler      = (void*) SUPC_0_Handler,         /*  8 SUPC_B12SRDY, SUPC_B33SRDY, SUPC_BOD12RDY, SUPC_BOD33RDY, SUPC_VCORERDY, SUPC_VREGRDY */
-        .pfnSUPC_1_Handler      = (void*) SUPC_1_Handler,         /*  9 SUPC_BOD12DET, SUPC_BOD33DET */
-        .pfnWDT_Handler         = (void*) WDT_Handler,            /* 10 Watchdog Timer */
-        .pfnRTC_Handler         = (void*) RTC_Handler,            /* 11 Real-Time Counter */
-        .pfnEIC_0_Handler       = (void*) EIC_0_Handler,          /* 12 EIC_EXTINT_0 */
-        .pfnEIC_1_Handler       = (void*) EIC_1_Handler,          /* 13 EIC_EXTINT_1 */
-        .pfnEIC_2_Handler       = (void*) EIC_2_Handler,          /* 14 EIC_EXTINT_2 */
-        .pfnEIC_3_Handler       = (void*) EIC_3_Handler,          /* 15 EIC_EXTINT_3 */
-        .pfnEIC_4_Handler       = (void*) EIC_4_Handler,          /* 16 EIC_EXTINT_4 */
-        .pfnEIC_5_Handler       = (void*) EIC_5_Handler,          /* 17 EIC_EXTINT_5 */
-        .pfnEIC_6_Handler       = (void*) EIC_6_Handler,          /* 18 EIC_EXTINT_6 */
-        .pfnEIC_7_Handler       = (void*) EIC_7_Handler,          /* 19 EIC_EXTINT_7 */
-        .pfnEIC_8_Handler       = (void*) EIC_8_Handler,          /* 20 EIC_EXTINT_8 */
-        .pfnEIC_9_Handler       = (void*) EIC_9_Handler,          /* 21 EIC_EXTINT_9 */
-        .pfnEIC_10_Handler      = (void*) EIC_10_Handler,         /* 22 EIC_EXTINT_10 */
-        .pfnEIC_11_Handler      = (void*) EIC_11_Handler,         /* 23 EIC_EXTINT_11 */
-        .pfnEIC_12_Handler      = (void*) EIC_12_Handler,         /* 24 EIC_EXTINT_12 */
-        .pfnEIC_13_Handler      = (void*) EIC_13_Handler,         /* 25 EIC_EXTINT_13 */
-        .pfnEIC_14_Handler      = (void*) EIC_14_Handler,         /* 26 EIC_EXTINT_14 */
-        .pfnEIC_15_Handler      = (void*) EIC_15_Handler,         /* 27 EIC_EXTINT_15 */
-        .pfnFREQM_Handler       = (void*) FREQM_Handler,          /* 28 Frequency Meter */
-        .pfnNVMCTRL_0_Handler   = (void*) NVMCTRL_0_Handler,      /* 29 NVMCTRL_0, NVMCTRL_1, NVMCTRL_2, NVMCTRL_3, NVMCTRL_4, NVMCTRL_5, NVMCTRL_6, NVMCTRL_7 */
-        .pfnNVMCTRL_1_Handler   = (void*) NVMCTRL_1_Handler,      /* 30 NVMCTRL_10, NVMCTRL_8, NVMCTRL_9 */
-        .pfnDMAC_0_Handler      = (void*) DMAC_0_Handler,         /* 31 DMAC_SUSP_0, DMAC_TCMPL_0, DMAC_TERR_0 */
-        .pfnDMAC_1_Handler      = (void*) DMAC_1_Handler,         /* 32 DMAC_SUSP_1, DMAC_TCMPL_1, DMAC_TERR_1 */
-        .pfnDMAC_2_Handler      = (void*) DMAC_2_Handler,         /* 33 DMAC_SUSP_2, DMAC_TCMPL_2, DMAC_TERR_2 */
-        .pfnDMAC_3_Handler      = (void*) DMAC_3_Handler,         /* 34 DMAC_SUSP_3, DMAC_TCMPL_3, DMAC_TERR_3 */
-        .pfnDMAC_4_Handler      = (void*) DMAC_4_Handler,         /* 35 DMAC_SUSP_10, DMAC_SUSP_11, DMAC_SUSP_12, DMAC_SUSP_13, DMAC_SUSP_14, DMAC_SUSP_15, DMAC_SUSP_16, DMAC_SUSP_17, DMAC_SUSP_18, DMAC_SUSP_19, DMAC_SUSP_20, DMAC_SUSP_21, DMAC_SUSP_22, DMAC_SUSP_23, DMAC_SUSP_24, DMAC_SUSP_25, DMAC_SUSP_26, DMAC_SUSP_27, DMAC_SUSP_28, DMAC_SUSP_29, DMAC_SUSP_30, DMAC_SUSP_31, DMAC_SUSP_4, DMAC_SUSP_5, DMAC_SUSP_6, DMAC_SUSP_7, DMAC_SUSP_8, DMAC_SUSP_9, DMAC_TCMPL_10, DMAC_TCMPL_11, DMAC_TCMPL_12, DMAC_TCMPL_13, DMAC_TCMPL_14, DMAC_TCMPL_15, DMAC_TCMPL_16, DMAC_TCMPL_17, DMAC_TCMPL_18, DMAC_TCMPL_19, DMAC_TCMPL_20, DMAC_TCMPL_21, DMAC_TCMPL_22, DMAC_TCMPL_23, DMAC_TCMPL_24, DMAC_TCMPL_25, DMAC_TCMPL_26, DMAC_TCMPL_27, DMAC_TCMPL_28, DMAC_TCMPL_29, DMAC_TCMPL_30, DMAC_TCMPL_31, DMAC_TCMPL_4, DMAC_TCMPL_5, DMAC_TCMPL_6, DMAC_TCMPL_7, DMAC_TCMPL_8, DMAC_TCMPL_9, DMAC_TERR_10, DMAC_TERR_11, DMAC_TERR_12, DMAC_TERR_13, DMAC_TERR_14, DMAC_TERR_15, DMAC_TERR_16, DMAC_TERR_17, DMAC_TERR_18, DMAC_TERR_19, DMAC_TERR_20, DMAC_TERR_21, DMAC_TERR_22, DMAC_TERR_23, DMAC_TERR_24, DMAC_TERR_25, DMAC_TERR_26, DMAC_TERR_27, DMAC_TERR_28, DMAC_TERR_29, DMAC_TERR_30, DMAC_TERR_31, DMAC_TERR_4, DMAC_TERR_5, DMAC_TERR_6, DMAC_TERR_7, DMAC_TERR_8, DMAC_TERR_9 */
-        .pfnEVSYS_0_Handler     = (void*) EVSYS_0_Handler,        /* 36 EVSYS_EVD_0, EVSYS_OVR_0 */
-        .pfnEVSYS_1_Handler     = (void*) EVSYS_1_Handler,        /* 37 EVSYS_EVD_1, EVSYS_OVR_1 */
-        .pfnEVSYS_2_Handler     = (void*) EVSYS_2_Handler,        /* 38 EVSYS_EVD_2, EVSYS_OVR_2 */
-        .pfnEVSYS_3_Handler     = (void*) EVSYS_3_Handler,        /* 39 EVSYS_EVD_3, EVSYS_OVR_3 */
-        .pfnEVSYS_4_Handler     = (void*) EVSYS_4_Handler,        /* 40 EVSYS_EVD_10, EVSYS_EVD_11, EVSYS_EVD_4, EVSYS_EVD_5, EVSYS_EVD_6, EVSYS_EVD_7, EVSYS_EVD_8, EVSYS_EVD_9, EVSYS_OVR_10, EVSYS_OVR_11, EVSYS_OVR_4, EVSYS_OVR_5, EVSYS_OVR_6, EVSYS_OVR_7, EVSYS_OVR_8, EVSYS_OVR_9 */
-        .pfnPAC_Handler         = (void*) PAC_Handler,            /* 41 Peripheral Access Controller */
-        .pfnTAL_0_Handler       = (void*) TAL_0_Handler,          /* 42 TAL_BRK */
-        .pfnTAL_1_Handler       = (void*) TAL_1_Handler,          /* 43 TAL_IPS_0, TAL_IPS_1 */
-        .pvReserved44           = (void*) (0UL),                  /* 44 Reserved */
-        .pfnRAMECC_Handler      = (void*) RAMECC_Handler,         /* 45 RAM ECC */
-        .pfnSERCOM0_0_Handler   = (void*) SERCOM0_0_Handler,      /* 46 SERCOM0_0 */
-        .pfnSERCOM0_1_Handler   = (void*) SERCOM0_1_Handler,      /* 47 SERCOM0_1 */
-        .pfnSERCOM0_2_Handler   = (void*) SERCOM0_2_Handler,      /* 48 SERCOM0_2 */
-        .pfnSERCOM0_3_Handler   = (void*) SERCOM0_3_Handler,      /* 49 SERCOM0_3, SERCOM0_4, SERCOM0_5, SERCOM0_6 */
-        .pfnSERCOM1_0_Handler   = (void*) SERCOM1_0_Handler,      /* 50 SERCOM1_0 */
-        .pfnSERCOM1_1_Handler   = (void*) SERCOM1_1_Handler,      /* 51 SERCOM1_1 */
-        .pfnSERCOM1_2_Handler   = (void*) SERCOM1_2_Handler,      /* 52 SERCOM1_2 */
-        .pfnSERCOM1_3_Handler   = (void*) SERCOM1_3_Handler,      /* 53 SERCOM1_3, SERCOM1_4, SERCOM1_5, SERCOM1_6 */
-        .pfnSERCOM2_0_Handler   = (void*) SERCOM2_0_Handler,      /* 54 SERCOM2_0 */
-        .pfnSERCOM2_1_Handler   = (void*) SERCOM2_1_Handler,      /* 55 SERCOM2_1 */
-        .pfnSERCOM2_2_Handler   = (void*) SERCOM2_2_Handler,      /* 56 SERCOM2_2 */
-        .pfnSERCOM2_3_Handler   = (void*) SERCOM2_3_Handler,      /* 57 SERCOM2_3, SERCOM2_4, SERCOM2_5, SERCOM2_6 */
-        .pfnSERCOM3_0_Handler   = (void*) SERCOM3_0_Handler,      /* 58 SERCOM3_0 */
-        .pfnSERCOM3_1_Handler   = (void*) SERCOM3_1_Handler,      /* 59 SERCOM3_1 */
-        .pfnSERCOM3_2_Handler   = (void*) SERCOM3_2_Handler,      /* 60 SERCOM3_2 */
-        .pfnSERCOM3_3_Handler   = (void*) SERCOM3_3_Handler,      /* 61 SERCOM3_3, SERCOM3_4, SERCOM3_5, SERCOM3_6 */
+    /* Configurable interrupts */
+    .pfnPM_Handler         = (void *)PM_Handler,         /*  0 Power Manager */
+    .pfnMCLK_Handler       = (void *)MCLK_Handler,       /*  1 Main Clock */
+    .pfnOSCCTRL_0_Handler  = (void *)OSCCTRL_0_Handler,  /*  2 OSCCTRL_XOSCFAIL_0, OSCCTRL_XOSCRDY_0 */
+    .pfnOSCCTRL_1_Handler  = (void *)OSCCTRL_1_Handler,  /*  3 OSCCTRL_XOSCFAIL_1, OSCCTRL_XOSCRDY_1 */
+    .pfnOSCCTRL_2_Handler  = (void *)OSCCTRL_2_Handler,  /*  4 OSCCTRL_DFLLLOCKC, OSCCTRL_DFLLLOCKF, OSCCTRL_DFLLOOB, OSCCTRL_DFLLRCS, OSCCTRL_DFLLRDY */
+    .pfnOSCCTRL_3_Handler  = (void *)OSCCTRL_3_Handler,  /*  5 OSCCTRL_DPLLLCKF_0, OSCCTRL_DPLLLCKR_0, OSCCTRL_DPLLLDRTO_0, OSCCTRL_DPLLLTO_0 */
+    .pfnOSCCTRL_4_Handler  = (void *)OSCCTRL_4_Handler,  /*  6 OSCCTRL_DPLLLCKF_1, OSCCTRL_DPLLLCKR_1, OSCCTRL_DPLLLDRTO_1, OSCCTRL_DPLLLTO_1 */
+    .pfnOSC32KCTRL_Handler = (void *)OSC32KCTRL_Handler, /*  7 32kHz Oscillators Control */
+    .pfnSUPC_0_Handler     = (void *)SUPC_0_Handler,     /*  8 SUPC_B12SRDY, SUPC_B33SRDY, SUPC_BOD12RDY, SUPC_BOD33RDY, SUPC_VCORERDY, SUPC_VREGRDY */
+    .pfnSUPC_1_Handler     = (void *)SUPC_1_Handler,     /*  9 SUPC_BOD12DET, SUPC_BOD33DET */
+    .pfnWDT_Handler        = (void *)WDT_Handler,        /* 10 Watchdog Timer */
+    .pfnRTC_Handler        = (void *)RTC_Handler,        /* 11 Real-Time Counter */
+    .pfnEIC_0_Handler      = (void *)EIC_0_Handler,      /* 12 EIC_EXTINT_0 */
+    .pfnEIC_1_Handler      = (void *)EIC_1_Handler,      /* 13 EIC_EXTINT_1 */
+    .pfnEIC_2_Handler      = (void *)EIC_2_Handler,      /* 14 EIC_EXTINT_2 */
+    .pfnEIC_3_Handler      = (void *)EIC_3_Handler,      /* 15 EIC_EXTINT_3 */
+    .pfnEIC_4_Handler      = (void *)EIC_4_Handler,      /* 16 EIC_EXTINT_4 */
+    .pfnEIC_5_Handler      = (void *)EIC_5_Handler,      /* 17 EIC_EXTINT_5 */
+    .pfnEIC_6_Handler      = (void *)EIC_6_Handler,      /* 18 EIC_EXTINT_6 */
+    .pfnEIC_7_Handler      = (void *)EIC_7_Handler,      /* 19 EIC_EXTINT_7 */
+    .pfnEIC_8_Handler      = (void *)EIC_8_Handler,      /* 20 EIC_EXTINT_8 */
+    .pfnEIC_9_Handler      = (void *)EIC_9_Handler,      /* 21 EIC_EXTINT_9 */
+    .pfnEIC_10_Handler     = (void *)EIC_10_Handler,     /* 22 EIC_EXTINT_10 */
+    .pfnEIC_11_Handler     = (void *)EIC_11_Handler,     /* 23 EIC_EXTINT_11 */
+    .pfnEIC_12_Handler     = (void *)EIC_12_Handler,     /* 24 EIC_EXTINT_12 */
+    .pfnEIC_13_Handler     = (void *)EIC_13_Handler,     /* 25 EIC_EXTINT_13 */
+    .pfnEIC_14_Handler     = (void *)EIC_14_Handler,     /* 26 EIC_EXTINT_14 */
+    .pfnEIC_15_Handler     = (void *)EIC_15_Handler,     /* 27 EIC_EXTINT_15 */
+    .pfnFREQM_Handler      = (void *)FREQM_Handler,      /* 28 Frequency Meter */
+    .pfnNVMCTRL_0_Handler  = (void *)NVMCTRL_0_Handler,  /* 29 NVMCTRL_0, NVMCTRL_1, NVMCTRL_2, NVMCTRL_3, NVMCTRL_4, NVMCTRL_5, NVMCTRL_6, NVMCTRL_7 */
+    .pfnNVMCTRL_1_Handler  = (void *)NVMCTRL_1_Handler,  /* 30 NVMCTRL_10, NVMCTRL_8, NVMCTRL_9 */
+    .pfnDMAC_0_Handler     = (void *)DMAC_0_Handler,     /* 31 DMAC_SUSP_0, DMAC_TCMPL_0, DMAC_TERR_0 */
+    .pfnDMAC_1_Handler     = (void *)DMAC_1_Handler,     /* 32 DMAC_SUSP_1, DMAC_TCMPL_1, DMAC_TERR_1 */
+    .pfnDMAC_2_Handler     = (void *)DMAC_2_Handler,     /* 33 DMAC_SUSP_2, DMAC_TCMPL_2, DMAC_TERR_2 */
+    .pfnDMAC_3_Handler     = (void *)DMAC_3_Handler,     /* 34 DMAC_SUSP_3, DMAC_TCMPL_3, DMAC_TERR_3 */
+    .pfnDMAC_4_Handler     = (void *)DMAC_4_Handler,   /* 35 DMAC_SUSP_10, DMAC_SUSP_11, DMAC_SUSP_12, DMAC_SUSP_13, DMAC_SUSP_14, DMAC_SUSP_15, DMAC_SUSP_16, DMAC_SUSP_17, DMAC_SUSP_18, DMAC_SUSP_19, DMAC_SUSP_20, DMAC_SUSP_21, DMAC_SUSP_22, DMAC_SUSP_23, DMAC_SUSP_24, DMAC_SUSP_25, DMAC_SUSP_26, DMAC_SUSP_27, DMAC_SUSP_28, DMAC_SUSP_29, DMAC_SUSP_30, DMAC_SUSP_31, DMAC_SUSP_4, DMAC_SUSP_5, DMAC_SUSP_6, DMAC_SUSP_7, DMAC_SUSP_8, DMAC_SUSP_9, DMAC_TCMPL_10, DMAC_TCMPL_11, DMAC_TCMPL_12, DMAC_TCMPL_13, DMAC_TCMPL_14, DMAC_TCMPL_15, DMAC_TCMPL_16, DMAC_TCMPL_17, DMAC_TCMPL_18, DMAC_TCMPL_19, DMAC_TCMPL_20, DMAC_TCMPL_21, DMAC_TCMPL_22, DMAC_TCMPL_23, DMAC_TCMPL_24, DMAC_TCMPL_25, DMAC_TCMPL_26, DMAC_TCMPL_27, DMAC_TCMPL_28, DMAC_TCMPL_29, DMAC_TCMPL_30, DMAC_TCMPL_31, DMAC_TCMPL_4, DMAC_TCMPL_5, DMAC_TCMPL_6, DMAC_TCMPL_7, DMAC_TCMPL_8, DMAC_TCMPL_9, DMAC_TERR_10, DMAC_TERR_11, DMAC_TERR_12, DMAC_TERR_13, DMAC_TERR_14, DMAC_TERR_15, DMAC_TERR_16, DMAC_TERR_17, DMAC_TERR_18, DMAC_TERR_19,
+                                                          DMAC_TERR_20, DMAC_TERR_21, DMAC_TERR_22, DMAC_TERR_23, DMAC_TERR_24, DMAC_TERR_25, DMAC_TERR_26, DMAC_TERR_27, DMAC_TERR_28, DMAC_TERR_29, DMAC_TERR_30, DMAC_TERR_31, DMAC_TERR_4, DMAC_TERR_5, DMAC_TERR_6, DMAC_TERR_7, DMAC_TERR_8, DMAC_TERR_9 */
+    .pfnEVSYS_0_Handler   = (void *)EVSYS_0_Handler,   /* 36 EVSYS_EVD_0, EVSYS_OVR_0 */
+    .pfnEVSYS_1_Handler   = (void *)EVSYS_1_Handler,   /* 37 EVSYS_EVD_1, EVSYS_OVR_1 */
+    .pfnEVSYS_2_Handler   = (void *)EVSYS_2_Handler,   /* 38 EVSYS_EVD_2, EVSYS_OVR_2 */
+    .pfnEVSYS_3_Handler   = (void *)EVSYS_3_Handler,   /* 39 EVSYS_EVD_3, EVSYS_OVR_3 */
+    .pfnEVSYS_4_Handler   = (void *)EVSYS_4_Handler,   /* 40 EVSYS_EVD_10, EVSYS_EVD_11, EVSYS_EVD_4, EVSYS_EVD_5, EVSYS_EVD_6, EVSYS_EVD_7, EVSYS_EVD_8, EVSYS_EVD_9, EVSYS_OVR_10, EVSYS_OVR_11, EVSYS_OVR_4, EVSYS_OVR_5, EVSYS_OVR_6, EVSYS_OVR_7, EVSYS_OVR_8, EVSYS_OVR_9 */
+    .pfnPAC_Handler       = (void *)PAC_Handler,       /* 41 Peripheral Access Controller */
+    .pfnTAL_0_Handler     = (void *)TAL_0_Handler,     /* 42 TAL_BRK */
+    .pfnTAL_1_Handler     = (void *)TAL_1_Handler,     /* 43 TAL_IPS_0, TAL_IPS_1 */
+    .pvReserved44         = (void *)(0UL),             /* 44 Reserved */
+    .pfnRAMECC_Handler    = (void *)RAMECC_Handler,    /* 45 RAM ECC */
+    .pfnSERCOM0_0_Handler = (void *)SERCOM0_0_Handler, /* 46 SERCOM0_0 */
+    .pfnSERCOM0_1_Handler = (void *)SERCOM0_1_Handler, /* 47 SERCOM0_1 */
+    .pfnSERCOM0_2_Handler = (void *)SERCOM0_2_Handler, /* 48 SERCOM0_2 */
+    .pfnSERCOM0_3_Handler = (void *)SERCOM0_3_Handler, /* 49 SERCOM0_3, SERCOM0_4, SERCOM0_5, SERCOM0_6 */
+    .pfnSERCOM1_0_Handler = (void *)SERCOM1_0_Handler, /* 50 SERCOM1_0 */
+    .pfnSERCOM1_1_Handler = (void *)SERCOM1_1_Handler, /* 51 SERCOM1_1 */
+    .pfnSERCOM1_2_Handler = (void *)SERCOM1_2_Handler, /* 52 SERCOM1_2 */
+    .pfnSERCOM1_3_Handler = (void *)SERCOM1_3_Handler, /* 53 SERCOM1_3, SERCOM1_4, SERCOM1_5, SERCOM1_6 */
+    .pfnSERCOM2_0_Handler = (void *)SERCOM2_0_Handler, /* 54 SERCOM2_0 */
+    .pfnSERCOM2_1_Handler = (void *)SERCOM2_1_Handler, /* 55 SERCOM2_1 */
+    .pfnSERCOM2_2_Handler = (void *)SERCOM2_2_Handler, /* 56 SERCOM2_2 */
+    .pfnSERCOM2_3_Handler = (void *)SERCOM2_3_Handler, /* 57 SERCOM2_3, SERCOM2_4, SERCOM2_5, SERCOM2_6 */
+    .pfnSERCOM3_0_Handler = (void *)SERCOM3_0_Handler, /* 58 SERCOM3_0 */
+    .pfnSERCOM3_1_Handler = (void *)SERCOM3_1_Handler, /* 59 SERCOM3_1 */
+    .pfnSERCOM3_2_Handler = (void *)SERCOM3_2_Handler, /* 60 SERCOM3_2 */
+    .pfnSERCOM3_3_Handler = (void *)SERCOM3_3_Handler, /* 61 SERCOM3_3, SERCOM3_4, SERCOM3_5, SERCOM3_6 */
 #ifdef ID_SERCOM4
-        .pfnSERCOM4_0_Handler   = (void*) SERCOM4_0_Handler,      /* 62 SERCOM4_0 */
-        .pfnSERCOM4_1_Handler   = (void*) SERCOM4_1_Handler,      /* 63 SERCOM4_1 */
-        .pfnSERCOM4_2_Handler   = (void*) SERCOM4_2_Handler,      /* 64 SERCOM4_2 */
-        .pfnSERCOM4_3_Handler   = (void*) SERCOM4_3_Handler,      /* 65 SERCOM4_3, SERCOM4_4, SERCOM4_5, SERCOM4_6 */
+    .pfnSERCOM4_0_Handler = (void *)SERCOM4_0_Handler, /* 62 SERCOM4_0 */
+    .pfnSERCOM4_1_Handler = (void *)SERCOM4_1_Handler, /* 63 SERCOM4_1 */
+    .pfnSERCOM4_2_Handler = (void *)SERCOM4_2_Handler, /* 64 SERCOM4_2 */
+    .pfnSERCOM4_3_Handler = (void *)SERCOM4_3_Handler, /* 65 SERCOM4_3, SERCOM4_4, SERCOM4_5, SERCOM4_6 */
 #else
-        .pvReserved62           = (void*) (0UL),                  /* 62 Reserved */
-        .pvReserved63           = (void*) (0UL),                  /* 63 Reserved */
-        .pvReserved64           = (void*) (0UL),                  /* 64 Reserved */
-        .pvReserved65           = (void*) (0UL),                  /* 65 Reserved */
+    .pvReserved62  = (void *)(0UL), /* 62 Reserved */
+    .pvReserved63  = (void *)(0UL), /* 63 Reserved */
+    .pvReserved64  = (void *)(0UL), /* 64 Reserved */
+    .pvReserved65  = (void *)(0UL), /* 65 Reserved */
 #endif
 #ifdef ID_SERCOM5
-        .pfnSERCOM5_0_Handler   = (void*) SERCOM5_0_Handler,      /* 66 SERCOM5_0 */
-        .pfnSERCOM5_1_Handler   = (void*) SERCOM5_1_Handler,      /* 67 SERCOM5_1 */
-        .pfnSERCOM5_2_Handler   = (void*) SERCOM5_2_Handler,      /* 68 SERCOM5_2 */
-        .pfnSERCOM5_3_Handler   = (void*) SERCOM5_3_Handler,      /* 69 SERCOM5_3, SERCOM5_4, SERCOM5_5, SERCOM5_6 */
+    .pfnSERCOM5_0_Handler = (void *)SERCOM5_0_Handler, /* 66 SERCOM5_0 */
+    .pfnSERCOM5_1_Handler = (void *)SERCOM5_1_Handler, /* 67 SERCOM5_1 */
+    .pfnSERCOM5_2_Handler = (void *)SERCOM5_2_Handler, /* 68 SERCOM5_2 */
+    .pfnSERCOM5_3_Handler = (void *)SERCOM5_3_Handler, /* 69 SERCOM5_3, SERCOM5_4, SERCOM5_5, SERCOM5_6 */
 #else
-        .pvReserved66           = (void*) (0UL),                  /* 66 Reserved */
-        .pvReserved67           = (void*) (0UL),                  /* 67 Reserved */
-        .pvReserved68           = (void*) (0UL),                  /* 68 Reserved */
-        .pvReserved69           = (void*) (0UL),                  /* 69 Reserved */
+    .pvReserved66  = (void *)(0UL), /* 66 Reserved */
+    .pvReserved67  = (void *)(0UL), /* 67 Reserved */
+    .pvReserved68  = (void *)(0UL), /* 68 Reserved */
+    .pvReserved69  = (void *)(0UL), /* 69 Reserved */
 #endif
 #ifdef ID_SERCOM6
-        .pfnSERCOM6_0_Handler   = (void*) SERCOM6_0_Handler,      /* 70 SERCOM6_0 */
-        .pfnSERCOM6_1_Handler   = (void*) SERCOM6_1_Handler,      /* 71 SERCOM6_1 */
-        .pfnSERCOM6_2_Handler   = (void*) SERCOM6_2_Handler,      /* 72 SERCOM6_2 */
-        .pfnSERCOM6_3_Handler   = (void*) SERCOM6_3_Handler,      /* 73 SERCOM6_3, SERCOM6_4, SERCOM6_5, SERCOM6_6 */
+    .pfnSERCOM6_0_Handler = (void *)SERCOM6_0_Handler, /* 70 SERCOM6_0 */
+    .pfnSERCOM6_1_Handler = (void *)SERCOM6_1_Handler, /* 71 SERCOM6_1 */
+    .pfnSERCOM6_2_Handler = (void *)SERCOM6_2_Handler, /* 72 SERCOM6_2 */
+    .pfnSERCOM6_3_Handler = (void *)SERCOM6_3_Handler, /* 73 SERCOM6_3, SERCOM6_4, SERCOM6_5, SERCOM6_6 */
 #else
-        .pvReserved70           = (void*) (0UL),                  /* 70 Reserved */
-        .pvReserved71           = (void*) (0UL),                  /* 71 Reserved */
-        .pvReserved72           = (void*) (0UL),                  /* 72 Reserved */
-        .pvReserved73           = (void*) (0UL),                  /* 73 Reserved */
+    .pvReserved70  = (void *)(0UL), /* 70 Reserved */
+    .pvReserved71  = (void *)(0UL), /* 71 Reserved */
+    .pvReserved72  = (void *)(0UL), /* 72 Reserved */
+    .pvReserved73  = (void *)(0UL), /* 73 Reserved */
 #endif
 #ifdef ID_SERCOM7
-        .pfnSERCOM7_0_Handler   = (void*) SERCOM7_0_Handler,      /* 74 SERCOM7_0 */
-        .pfnSERCOM7_1_Handler   = (void*) SERCOM7_1_Handler,      /* 75 SERCOM7_1 */
-        .pfnSERCOM7_2_Handler   = (void*) SERCOM7_2_Handler,      /* 76 SERCOM7_2 */
-        .pfnSERCOM7_3_Handler   = (void*) SERCOM7_3_Handler,      /* 77 SERCOM7_3, SERCOM7_4, SERCOM7_5, SERCOM7_6 */
+    .pfnSERCOM7_0_Handler = (void *)SERCOM7_0_Handler, /* 74 SERCOM7_0 */
+    .pfnSERCOM7_1_Handler = (void *)SERCOM7_1_Handler, /* 75 SERCOM7_1 */
+    .pfnSERCOM7_2_Handler = (void *)SERCOM7_2_Handler, /* 76 SERCOM7_2 */
+    .pfnSERCOM7_3_Handler = (void *)SERCOM7_3_Handler, /* 77 SERCOM7_3, SERCOM7_4, SERCOM7_5, SERCOM7_6 */
 #else
-        .pvReserved74           = (void*) (0UL),                  /* 74 Reserved */
-        .pvReserved75           = (void*) (0UL),                  /* 75 Reserved */
-        .pvReserved76           = (void*) (0UL),                  /* 76 Reserved */
-        .pvReserved77           = (void*) (0UL),                  /* 77 Reserved */
+    .pvReserved74  = (void *)(0UL), /* 74 Reserved */
+    .pvReserved75  = (void *)(0UL), /* 75 Reserved */
+    .pvReserved76  = (void *)(0UL), /* 76 Reserved */
+    .pvReserved77  = (void *)(0UL), /* 77 Reserved */
 #endif
 #ifdef ID_CAN0
-        .pfnCAN0_Handler        = (void*) CAN0_Handler,           /* 78 Control Area Network 0 */
+    .pfnCAN0_Handler = (void *)CAN0_Handler, /* 78 Control Area Network 0 */
 #else
-        .pvReserved78           = (void*) (0UL),                  /* 78 Reserved */
+    .pvReserved78  = (void *)(0UL), /* 78 Reserved */
 #endif
 #ifdef ID_CAN1
-        .pfnCAN1_Handler        = (void*) CAN1_Handler,           /* 79 Control Area Network 1 */
+    .pfnCAN1_Handler = (void *)CAN1_Handler, /* 79 Control Area Network 1 */
 #else
-        .pvReserved79           = (void*) (0UL),                  /* 79 Reserved */
+    .pvReserved79  = (void *)(0UL), /* 79 Reserved */
 #endif
 #ifdef ID_USB
-        .pfnUSB_0_Handler       = (void*) USB_0_Handler,          /* 80 USB_EORSM_DNRSM, USB_EORST_RST, USB_LPMSUSP_DDISC, USB_LPM_DCONN, USB_MSOF, USB_RAMACER, USB_RXSTP_TXSTP_0, USB_RXSTP_TXSTP_1, USB_RXSTP_TXSTP_2, USB_RXSTP_TXSTP_3, USB_RXSTP_TXSTP_4, USB_RXSTP_TXSTP_5, USB_RXSTP_TXSTP_6, USB_RXSTP_TXSTP_7, USB_STALL0_STALL_0, USB_STALL0_STALL_1, USB_STALL0_STALL_2, USB_STALL0_STALL_3, USB_STALL0_STALL_4, USB_STALL0_STALL_5, USB_STALL0_STALL_6, USB_STALL0_STALL_7, USB_STALL1_0, USB_STALL1_1, USB_STALL1_2, USB_STALL1_3, USB_STALL1_4, USB_STALL1_5, USB_STALL1_6, USB_STALL1_7, USB_SUSPEND, USB_TRFAIL0_TRFAIL_0, USB_TRFAIL0_TRFAIL_1, USB_TRFAIL0_TRFAIL_2, USB_TRFAIL0_TRFAIL_3, USB_TRFAIL0_TRFAIL_4, USB_TRFAIL0_TRFAIL_5, USB_TRFAIL0_TRFAIL_6, USB_TRFAIL0_TRFAIL_7, USB_TRFAIL1_PERR_0, USB_TRFAIL1_PERR_1, USB_TRFAIL1_PERR_2, USB_TRFAIL1_PERR_3, USB_TRFAIL1_PERR_4, USB_TRFAIL1_PERR_5, USB_TRFAIL1_PERR_6, USB_TRFAIL1_PERR_7, USB_UPRSM, USB_WAKEUP */
-        .pfnUSB_1_Handler       = (void*) USB_1_Handler,          /* 81 USB_SOF_HSOF */
-        .pfnUSB_2_Handler       = (void*) USB_2_Handler,          /* 82 USB_TRCPT0_0, USB_TRCPT0_1, USB_TRCPT0_2, USB_TRCPT0_3, USB_TRCPT0_4, USB_TRCPT0_5, USB_TRCPT0_6, USB_TRCPT0_7 */
-        .pfnUSB_3_Handler       = (void*) USB_3_Handler,          /* 83 USB_TRCPT1_0, USB_TRCPT1_1, USB_TRCPT1_2, USB_TRCPT1_3, USB_TRCPT1_4, USB_TRCPT1_5, USB_TRCPT1_6, USB_TRCPT1_7 */
+    .pfnUSB_0_Handler = (void *)USB_0_Handler, /* 80 USB_EORSM_DNRSM, USB_EORST_RST, USB_LPMSUSP_DDISC, USB_LPM_DCONN, USB_MSOF, USB_RAMACER, USB_RXSTP_TXSTP_0, USB_RXSTP_TXSTP_1, USB_RXSTP_TXSTP_2, USB_RXSTP_TXSTP_3, USB_RXSTP_TXSTP_4, USB_RXSTP_TXSTP_5, USB_RXSTP_TXSTP_6, USB_RXSTP_TXSTP_7, USB_STALL0_STALL_0, USB_STALL0_STALL_1, USB_STALL0_STALL_2, USB_STALL0_STALL_3, USB_STALL0_STALL_4, USB_STALL0_STALL_5, USB_STALL0_STALL_6, USB_STALL0_STALL_7, USB_STALL1_0, USB_STALL1_1, USB_STALL1_2, USB_STALL1_3, USB_STALL1_4, USB_STALL1_5, USB_STALL1_6, USB_STALL1_7, USB_SUSPEND, USB_TRFAIL0_TRFAIL_0, USB_TRFAIL0_TRFAIL_1, USB_TRFAIL0_TRFAIL_2, USB_TRFAIL0_TRFAIL_3, USB_TRFAIL0_TRFAIL_4, USB_TRFAIL0_TRFAIL_5, USB_TRFAIL0_TRFAIL_6, USB_TRFAIL0_TRFAIL_7, USB_TRFAIL1_PERR_0, USB_TRFAIL1_PERR_1, USB_TRFAIL1_PERR_2, USB_TRFAIL1_PERR_3, USB_TRFAIL1_PERR_4, USB_TRFAIL1_PERR_5, USB_TRFAIL1_PERR_6, USB_TRFAIL1_PERR_7, USB_UPRSM, USB_WAKEUP */
+    .pfnUSB_1_Handler = (void *)USB_1_Handler, /* 81 USB_SOF_HSOF */
+    .pfnUSB_2_Handler = (void *)USB_2_Handler, /* 82 USB_TRCPT0_0, USB_TRCPT0_1, USB_TRCPT0_2, USB_TRCPT0_3, USB_TRCPT0_4, USB_TRCPT0_5, USB_TRCPT0_6, USB_TRCPT0_7 */
+    .pfnUSB_3_Handler = (void *)USB_3_Handler, /* 83 USB_TRCPT1_0, USB_TRCPT1_1, USB_TRCPT1_2, USB_TRCPT1_3, USB_TRCPT1_4, USB_TRCPT1_5, USB_TRCPT1_6, USB_TRCPT1_7 */
 #else
-        .pvReserved80           = (void*) (0UL),                  /* 80 Reserved */
-        .pvReserved81           = (void*) (0UL),                  /* 81 Reserved */
-        .pvReserved82           = (void*) (0UL),                  /* 82 Reserved */
-        .pvReserved83           = (void*) (0UL),                  /* 83 Reserved */
+    .pvReserved80  = (void *)(0UL), /* 80 Reserved */
+    .pvReserved81  = (void *)(0UL), /* 81 Reserved */
+    .pvReserved82  = (void *)(0UL), /* 82 Reserved */
+    .pvReserved83  = (void *)(0UL), /* 83 Reserved */
 #endif
 #ifdef ID_GMAC
-        .pfnGMAC_Handler        = (void*) GMAC_Handler,           /* 84 Ethernet MAC */
+    .pfnGMAC_Handler = (void *)GMAC_Handler, /* 84 Ethernet MAC */
 #else
-        .pvReserved84           = (void*) (0UL),                  /* 84 Reserved */
-#endif
-        .pfnTCC0_0_Handler      = (void*) TCC0_0_Handler,         /* 85 TCC0_CNT_A, TCC0_DFS_A, TCC0_ERR_A, TCC0_FAULT0_A, TCC0_FAULT1_A, TCC0_FAULTA_A, TCC0_FAULTB_A, TCC0_OVF, TCC0_TRG, TCC0_UFS_A */
-        .pfnTCC0_1_Handler      = (void*) TCC0_1_Handler,         /* 86 TCC0_MC_0 */
-        .pfnTCC0_2_Handler      = (void*) TCC0_2_Handler,         /* 87 TCC0_MC_1 */
-        .pfnTCC0_3_Handler      = (void*) TCC0_3_Handler,         /* 88 TCC0_MC_2 */
-        .pfnTCC0_4_Handler      = (void*) TCC0_4_Handler,         /* 89 TCC0_MC_3 */
-        .pfnTCC0_5_Handler      = (void*) TCC0_5_Handler,         /* 90 TCC0_MC_4 */
-        .pfnTCC0_6_Handler      = (void*) TCC0_6_Handler,         /* 91 TCC0_MC_5 */
-        .pfnTCC1_0_Handler      = (void*) TCC1_0_Handler,         /* 92 TCC1_CNT_A, TCC1_DFS_A, TCC1_ERR_A, TCC1_FAULT0_A, TCC1_FAULT1_A, TCC1_FAULTA_A, TCC1_FAULTB_A, TCC1_OVF, TCC1_TRG, TCC1_UFS_A */
-        .pfnTCC1_1_Handler      = (void*) TCC1_1_Handler,         /* 93 TCC1_MC_0 */
-        .pfnTCC1_2_Handler      = (void*) TCC1_2_Handler,         /* 94 TCC1_MC_1 */
-        .pfnTCC1_3_Handler      = (void*) TCC1_3_Handler,         /* 95 TCC1_MC_2 */
-        .pfnTCC1_4_Handler      = (void*) TCC1_4_Handler,         /* 96 TCC1_MC_3 */
-        .pfnTCC2_0_Handler      = (void*) TCC2_0_Handler,         /* 97 TCC2_CNT_A, TCC2_DFS_A, TCC2_ERR_A, TCC2_FAULT0_A, TCC2_FAULT1_A, TCC2_FAULTA_A, TCC2_FAULTB_A, TCC2_OVF, TCC2_TRG, TCC2_UFS_A */
-        .pfnTCC2_1_Handler      = (void*) TCC2_1_Handler,         /* 98 TCC2_MC_0 */
-        .pfnTCC2_2_Handler      = (void*) TCC2_2_Handler,         /* 99 TCC2_MC_1 */
-        .pfnTCC2_3_Handler      = (void*) TCC2_3_Handler,         /* 100 TCC2_MC_2 */
+    .pvReserved84  = (void *)(0UL), /* 84 Reserved */
+#endif
+    .pfnTCC0_0_Handler = (void *)TCC0_0_Handler, /* 85 TCC0_CNT_A, TCC0_DFS_A, TCC0_ERR_A, TCC0_FAULT0_A, TCC0_FAULT1_A, TCC0_FAULTA_A, TCC0_FAULTB_A, TCC0_OVF, TCC0_TRG, TCC0_UFS_A */
+    .pfnTCC0_1_Handler = (void *)TCC0_1_Handler, /* 86 TCC0_MC_0 */
+    .pfnTCC0_2_Handler = (void *)TCC0_2_Handler, /* 87 TCC0_MC_1 */
+    .pfnTCC0_3_Handler = (void *)TCC0_3_Handler, /* 88 TCC0_MC_2 */
+    .pfnTCC0_4_Handler = (void *)TCC0_4_Handler, /* 89 TCC0_MC_3 */
+    .pfnTCC0_5_Handler = (void *)TCC0_5_Handler, /* 90 TCC0_MC_4 */
+    .pfnTCC0_6_Handler = (void *)TCC0_6_Handler, /* 91 TCC0_MC_5 */
+    .pfnTCC1_0_Handler = (void *)TCC1_0_Handler, /* 92 TCC1_CNT_A, TCC1_DFS_A, TCC1_ERR_A, TCC1_FAULT0_A, TCC1_FAULT1_A, TCC1_FAULTA_A, TCC1_FAULTB_A, TCC1_OVF, TCC1_TRG, TCC1_UFS_A */
+    .pfnTCC1_1_Handler = (void *)TCC1_1_Handler, /* 93 TCC1_MC_0 */
+    .pfnTCC1_2_Handler = (void *)TCC1_2_Handler, /* 94 TCC1_MC_1 */
+    .pfnTCC1_3_Handler = (void *)TCC1_3_Handler, /* 95 TCC1_MC_2 */
+    .pfnTCC1_4_Handler = (void *)TCC1_4_Handler, /* 96 TCC1_MC_3 */
+    .pfnTCC2_0_Handler = (void *)TCC2_0_Handler, /* 97 TCC2_CNT_A, TCC2_DFS_A, TCC2_ERR_A, TCC2_FAULT0_A, TCC2_FAULT1_A, TCC2_FAULTA_A, TCC2_FAULTB_A, TCC2_OVF, TCC2_TRG, TCC2_UFS_A */
+    .pfnTCC2_1_Handler = (void *)TCC2_1_Handler, /* 98 TCC2_MC_0 */
+    .pfnTCC2_2_Handler = (void *)TCC2_2_Handler, /* 99 TCC2_MC_1 */
+    .pfnTCC2_3_Handler = (void *)TCC2_3_Handler, /* 100 TCC2_MC_2 */
 #ifdef ID_TCC3
-        .pfnTCC3_0_Handler      = (void*) TCC3_0_Handler,         /* 101 TCC3_CNT_A, TCC3_DFS_A, TCC3_ERR_A, TCC3_FAULT0_A, TCC3_FAULT1_A, TCC3_FAULTA_A, TCC3_FAULTB_A, TCC3_OVF, TCC3_TRG, TCC3_UFS_A */
-        .pfnTCC3_1_Handler      = (void*) TCC3_1_Handler,         /* 102 TCC3_MC_0 */
-        .pfnTCC3_2_Handler      = (void*) TCC3_2_Handler,         /* 103 TCC3_MC_1 */
+    .pfnTCC3_0_Handler = (void *)TCC3_0_Handler, /* 101 TCC3_CNT_A, TCC3_DFS_A, TCC3_ERR_A, TCC3_FAULT0_A, TCC3_FAULT1_A, TCC3_FAULTA_A, TCC3_FAULTB_A, TCC3_OVF, TCC3_TRG, TCC3_UFS_A */
+    .pfnTCC3_1_Handler = (void *)TCC3_1_Handler, /* 102 TCC3_MC_0 */
+    .pfnTCC3_2_Handler = (void *)TCC3_2_Handler, /* 103 TCC3_MC_1 */
 #else
-        .pvReserved101          = (void*) (0UL),                  /* 101 Reserved */
-        .pvReserved102          = (void*) (0UL),                  /* 102 Reserved */
-        .pvReserved103          = (void*) (0UL),                  /* 103 Reserved */
+    .pvReserved101 = (void *)(0UL), /* 101 Reserved */
+    .pvReserved102 = (void *)(0UL), /* 102 Reserved */
+    .pvReserved103 = (void *)(0UL), /* 103 Reserved */
 #endif
 #ifdef ID_TCC4
-        .pfnTCC4_0_Handler      = (void*) TCC4_0_Handler,         /* 104 TCC4_CNT_A, TCC4_DFS_A, TCC4_ERR_A, TCC4_FAULT0_A, TCC4_FAULT1_A, TCC4_FAULTA_A, TCC4_FAULTB_A, TCC4_OVF, TCC4_TRG, TCC4_UFS_A */
-        .pfnTCC4_1_Handler      = (void*) TCC4_1_Handler,         /* 105 TCC4_MC_0 */
-        .pfnTCC4_2_Handler      = (void*) TCC4_2_Handler,         /* 106 TCC4_MC_1 */
+    .pfnTCC4_0_Handler = (void *)TCC4_0_Handler, /* 104 TCC4_CNT_A, TCC4_DFS_A, TCC4_ERR_A, TCC4_FAULT0_A, TCC4_FAULT1_A, TCC4_FAULTA_A, TCC4_FAULTB_A, TCC4_OVF, TCC4_TRG, TCC4_UFS_A */
+    .pfnTCC4_1_Handler = (void *)TCC4_1_Handler, /* 105 TCC4_MC_0 */
+    .pfnTCC4_2_Handler = (void *)TCC4_2_Handler, /* 106 TCC4_MC_1 */
 #else
-        .pvReserved104          = (void*) (0UL),                  /* 104 Reserved */
-        .pvReserved105          = (void*) (0UL),                  /* 105 Reserved */
-        .pvReserved106          = (void*) (0UL),                  /* 106 Reserved */
-#endif
-        .pfnTC0_Handler         = (void*) TC0_Handler,            /* 107 Basic Timer Counter 0 */
-        .pfnTC1_Handler         = (void*) TC1_Handler,            /* 108 Basic Timer Counter 1 */
-        .pfnTC2_Handler         = (void*) TC2_Handler,            /* 109 Basic Timer Counter 2 */
-        .pfnTC3_Handler         = (void*) TC3_Handler,            /* 110 Basic Timer Counter 3 */
+    .pvReserved104 = (void *)(0UL), /* 104 Reserved */
+    .pvReserved105 = (void *)(0UL), /* 105 Reserved */
+    .pvReserved106 = (void *)(0UL), /* 106 Reserved */
+#endif
+    .pfnTC0_Handler = (void *)TC0_Handler, /* 107 Basic Timer Counter 0 */
+    .pfnTC1_Handler = (void *)TC1_Handler, /* 108 Basic Timer Counter 1 */
+    .pfnTC2_Handler = (void *)TC2_Handler, /* 109 Basic Timer Counter 2 */
+    .pfnTC3_Handler = (void *)TC3_Handler, /* 110 Basic Timer Counter 3 */
 #ifdef ID_TC4
-        .pfnTC4_Handler         = (void*) TC4_Handler,            /* 111 Basic Timer Counter 4 */
+    .pfnTC4_Handler = (void *)TC4_Handler, /* 111 Basic Timer Counter 4 */
 #else
-        .pvReserved111          = (void*) (0UL),                  /* 111 Reserved */
+    .pvReserved111 = (void *)(0UL), /* 111 Reserved */
 #endif
 #ifdef ID_TC5
-        .pfnTC5_Handler         = (void*) TC5_Handler,            /* 112 Basic Timer Counter 5 */
+    .pfnTC5_Handler = (void *)TC5_Handler, /* 112 Basic Timer Counter 5 */
 #else
-        .pvReserved112          = (void*) (0UL),                  /* 112 Reserved */
+    .pvReserved112 = (void *)(0UL), /* 112 Reserved */
 #endif
 #ifdef ID_TC6
-        .pfnTC6_Handler         = (void*) TC6_Handler,            /* 113 Basic Timer Counter 6 */
+    .pfnTC6_Handler = (void *)TC6_Handler, /* 113 Basic Timer Counter 6 */
 #else
-        .pvReserved113          = (void*) (0UL),                  /* 113 Reserved */
+    .pvReserved113 = (void *)(0UL), /* 113 Reserved */
 #endif
 #ifdef ID_TC7
-        .pfnTC7_Handler         = (void*) TC7_Handler,            /* 114 Basic Timer Counter 7 */
+    .pfnTC7_Handler = (void *)TC7_Handler, /* 114 Basic Timer Counter 7 */
 #else
-        .pvReserved114          = (void*) (0UL),                  /* 114 Reserved */
-#endif
-        .pfnPDEC_0_Handler      = (void*) PDEC_0_Handler,         /* 115 PDEC_DIR_A, PDEC_ERR_A, PDEC_OVF, PDEC_VLC_A */
-        .pfnPDEC_1_Handler      = (void*) PDEC_1_Handler,         /* 116 PDEC_MC_0 */
-        .pfnPDEC_2_Handler      = (void*) PDEC_2_Handler,         /* 117 PDEC_MC_1 */
-        .pfnADC0_0_Handler      = (void*) ADC0_0_Handler,         /* 118 ADC0_OVERRUN, ADC0_WINMON */
-        .pfnADC0_1_Handler      = (void*) ADC0_1_Handler,         /* 119 ADC0_RESRDY */
-        .pfnADC1_0_Handler      = (void*) ADC1_0_Handler,         /* 120 ADC1_OVERRUN, ADC1_WINMON */
-        .pfnADC1_1_Handler      = (void*) ADC1_1_Handler,         /* 121 ADC1_RESRDY */
-        .pfnAC_Handler          = (void*) AC_Handler,             /* 122 Analog Comparators */
-        .pfnDAC_0_Handler       = (void*) DAC_0_Handler,          /* 123 DAC_OVERRUN_A_0, DAC_OVERRUN_A_1, DAC_UNDERRUN_A_0, DAC_UNDERRUN_A_1 */
-        .pfnDAC_1_Handler       = (void*) DAC_1_Handler,          /* 124 DAC_EMPTY_0 */
-        .pfnDAC_2_Handler       = (void*) DAC_2_Handler,          /* 125 DAC_EMPTY_1 */
-        .pfnDAC_3_Handler       = (void*) DAC_3_Handler,          /* 126 DAC_RESRDY_0 */
-        .pfnDAC_4_Handler       = (void*) DAC_4_Handler,          /* 127 DAC_RESRDY_1 */
+    .pvReserved114 = (void *)(0UL), /* 114 Reserved */
+#endif
+    .pfnPDEC_0_Handler = (void *)PDEC_0_Handler, /* 115 PDEC_DIR_A, PDEC_ERR_A, PDEC_OVF, PDEC_VLC_A */
+    .pfnPDEC_1_Handler = (void *)PDEC_1_Handler, /* 116 PDEC_MC_0 */
+    .pfnPDEC_2_Handler = (void *)PDEC_2_Handler, /* 117 PDEC_MC_1 */
+    .pfnADC0_0_Handler = (void *)ADC0_0_Handler, /* 118 ADC0_OVERRUN, ADC0_WINMON */
+    .pfnADC0_1_Handler = (void *)ADC0_1_Handler, /* 119 ADC0_RESRDY */
+    .pfnADC1_0_Handler = (void *)ADC1_0_Handler, /* 120 ADC1_OVERRUN, ADC1_WINMON */
+    .pfnADC1_1_Handler = (void *)ADC1_1_Handler, /* 121 ADC1_RESRDY */
+    .pfnAC_Handler     = (void *)AC_Handler,     /* 122 Analog Comparators */
+    .pfnDAC_0_Handler  = (void *)DAC_0_Handler,  /* 123 DAC_OVERRUN_A_0, DAC_OVERRUN_A_1, DAC_UNDERRUN_A_0, DAC_UNDERRUN_A_1 */
+    .pfnDAC_1_Handler  = (void *)DAC_1_Handler,  /* 124 DAC_EMPTY_0 */
+    .pfnDAC_2_Handler  = (void *)DAC_2_Handler,  /* 125 DAC_EMPTY_1 */
+    .pfnDAC_3_Handler  = (void *)DAC_3_Handler,  /* 126 DAC_RESRDY_0 */
+    .pfnDAC_4_Handler  = (void *)DAC_4_Handler,  /* 127 DAC_RESRDY_1 */
 #ifdef ID_I2S
-        .pfnI2S_Handler         = (void*) I2S_Handler,            /* 128 Inter-IC Sound Interface */
+    .pfnI2S_Handler = (void *)I2S_Handler, /* 128 Inter-IC Sound Interface */
 #else
-        .pvReserved128          = (void*) (0UL),                  /* 128 Reserved */
+    .pvReserved128 = (void *)(0UL), /* 128 Reserved */
 #endif
-        .pfnPCC_Handler         = (void*) PCC_Handler,            /* 129 Parallel Capture Controller */
-        .pfnAES_Handler         = (void*) AES_Handler,            /* 130 Advanced Encryption Standard */
-        .pfnTRNG_Handler        = (void*) TRNG_Handler,           /* 131 True Random Generator */
+    .pfnPCC_Handler  = (void *)PCC_Handler,  /* 129 Parallel Capture Controller */
+    .pfnAES_Handler  = (void *)AES_Handler,  /* 130 Advanced Encryption Standard */
+    .pfnTRNG_Handler = (void *)TRNG_Handler, /* 131 True Random Generator */
 #ifdef ID_ICM
-        .pfnICM_Handler         = (void*) ICM_Handler,            /* 132 Integrity Check Monitor */
+    .pfnICM_Handler = (void *)ICM_Handler, /* 132 Integrity Check Monitor */
 #else
-        .pvReserved132          = (void*) (0UL),                  /* 132 Reserved */
+    .pvReserved132 = (void *)(0UL), /* 132 Reserved */
 #endif
 #ifdef ID_PUKCC
-        .pfnPUKCC_Handler       = (void*) PUKCC_Handler,          /* 133 PUblic-Key Cryptography Controller */
+    .pfnPUKCC_Handler = (void *)PUKCC_Handler, /* 133 PUblic-Key Cryptography Controller */
 #else
-        .pvReserved133          = (void*) (0UL),                  /* 133 Reserved */
+    .pvReserved133 = (void *)(0UL), /* 133 Reserved */
 #endif
-        .pfnQSPI_Handler        = (void*) QSPI_Handler,           /* 134 Quad SPI interface */
+    .pfnQSPI_Handler = (void *)QSPI_Handler, /* 134 Quad SPI interface */
 #ifdef ID_SDHC0
-        .pfnSDHC0_Handler       = (void*) SDHC0_Handler,          /* 135 SD/MMC Host Controller 0 */
+    .pfnSDHC0_Handler = (void *)SDHC0_Handler, /* 135 SD/MMC Host Controller 0 */
 #else
-        .pvReserved135          = (void*) (0UL),                  /* 135 Reserved */
+    .pvReserved135 = (void *)(0UL), /* 135 Reserved */
 #endif
 #ifdef ID_SDHC1
-        .pfnSDHC1_Handler       = (void*) SDHC1_Handler           /* 136 SD/MMC Host Controller 1 */
+    .pfnSDHC1_Handler = (void *)SDHC1_Handler /* 136 SD/MMC Host Controller 1 */
 #else
-        .pvReserved136          = (void*) (0UL)                   /* 136 Reserved */
+    .pvReserved136 = (void *)(0UL)  /* 136 Reserved */
 #endif
 };
 
@@ -499,61 +500,60 @@ const DeviceVectors exception_table = {
  * \brief This is the code that gets called on processor reset.
  * To initialize the device, and call the main() routine.
  */
-void Reset_Handler(void)
-{
+void Reset_Handler(void) {
 #ifdef KEYBOARD_massdrop_ctrl
-        /* WARNING: This is only for CTRL bootloader release "v2.18Jun 22 2018 17:28:08" for bootloader_jump support */
-        if (*MAGIC_ADDR == BOOTLOADER_MAGIC) {
-                /* At this point, the bootloader's memory is initialized properly, so undo the jump to here, then jump back */
-                *MAGIC_ADDR = 0x00000000;           /* Change value to prevent potential bootloader entrance loop */
-                __set_MSP(0x20008818);              /* MSP according to bootloader */
-                SCB->VTOR = 0x00000000;             /* Vector table back to bootloader's */
-                asm("bx %0"::"r"(0x00001267));      /* Jump past bootloader RCAUSE check using THUMB */
-        }
-#endif
-        uint32_t *pSrc, *pDest;
+    /* WARNING: This is only for CTRL bootloader release "v2.18Jun 22 2018 17:28:08" for bootloader_jump support */
+    if (*MAGIC_ADDR == BOOTLOADER_MAGIC) {
+        /* At this point, the bootloader's memory is initialized properly, so undo the jump to here, then jump back */
+        *MAGIC_ADDR = 0x00000000;       /* Change value to prevent potential bootloader entrance loop */
+        __set_MSP(0x20008818);          /* MSP according to bootloader */
+        SCB->VTOR = 0x00000000;         /* Vector table back to bootloader's */
+        asm("bx %0" ::"r"(0x00001267)); /* Jump past bootloader RCAUSE check using THUMB */
+    }
+#endif
+    uint32_t *pSrc, *pDest;
 
-        /* Initialize the relocate segment */
-        pSrc = &_etext;
-        pDest = &_srelocate;
+    /* Initialize the relocate segment */
+    pSrc  = &_etext;
+    pDest = &_srelocate;
 
-        if (pSrc != pDest) {
-                for (; pDest < &_erelocate;) {
-                        *pDest++ = *pSrc++;
-                }
+    if (pSrc != pDest) {
+        for (; pDest < &_erelocate;) {
+            *pDest++ = *pSrc++;
         }
+    }
 
-        /* Clear the zero segment */
-        for (pDest = &_szero; pDest < &_ezero;) {
-                *pDest++ = 0;
-        }
+    /* Clear the zero segment */
+    for (pDest = &_szero; pDest < &_ezero;) {
+        *pDest++ = 0;
+    }
 
-        /* Set the vector table base address */
-        pSrc = (uint32_t *) & _sfixed;
-        SCB->VTOR = ((uint32_t) pSrc & SCB_VTOR_TBLOFF_Msk);
+    /* Set the vector table base address */
+    pSrc      = (uint32_t *)&_sfixed;
+    SCB->VTOR = ((uint32_t)pSrc & SCB_VTOR_TBLOFF_Msk);
 
 #if __FPU_USED
-        /* Enable FPU */
-        SCB->CPACR |=  (0xFu << 20);
-        __DSB();
-        __ISB();
+    /* Enable FPU */
+    SCB->CPACR |= (0xFu << 20);
+    __DSB();
+    __ISB();
 #endif
 
-        /* Initialize the C library */
-        __libc_init_array();
+    /* Initialize the C library */
+    __libc_init_array();
 
-        /* Branch to main function */
-        main();
+    /* Branch to main function */
+    main();
 
-        /* Infinite loop */
-        while (1);
+    /* Infinite loop */
+    while (1)
+        ;
 }
 
 /**
  * \brief Default interrupt handler for unused IRQs.
  */
-void Dummy_Handler(void)
-{
-        while (1) {
-        }
+void Dummy_Handler(void) {
+    while (1) {
+    }
 }
diff --git a/tmk_core/protocol/arm_atsam/usb/compiler.h b/tmk_core/protocol/arm_atsam/usb/compiler.h
index b2ccfd73e..6ba232234 100644
--- a/tmk_core/protocol/arm_atsam/usb/compiler.h
+++ b/tmk_core/protocol/arm_atsam/usb/compiler.h
@@ -43,7 +43,7 @@
  */
 
 #ifndef UTILS_COMPILER_H_INCLUDED
-#define UTILS_COMPILER_H_INCLUDED
+#    define UTILS_COMPILER_H_INCLUDED
 
 /**
  * \defgroup group_sam0_utils Compiler abstraction layer and code utilities
@@ -54,38 +54,38 @@
  * @{
  */
 
-#if (defined __ICCARM__)
-#  include <intrinsics.h>
-#endif
+#    if (defined __ICCARM__)
+#        include <intrinsics.h>
+#    endif
 
-#include <stddef.h>
+#    include <stddef.h>
 //#include <parts.h>
 //#include <status_codes.h>
 //#include <preprocessor.h>
 //#include <io.h>
 
-#ifndef __ASSEMBLY__
+#    ifndef __ASSEMBLY__
 
-#include <stdio.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdlib.h>
+#        include <stdio.h>
+#        include <stdbool.h>
+#        include <stdint.h>
+#        include <stdlib.h>
 
 /**
  * \def UNUSED
  * \brief Marking \a v as a unused parameter or value.
  */
-#define UNUSED(v)          (void)(v)
+#        define UNUSED(v) (void)(v)
 
 /**
  * \def barrier
  * \brief Memory barrier
  */
-#ifdef __GNUC__
-#  define barrier()        asm volatile("" ::: "memory")
-#else
-#  define barrier()        asm ("")
-#endif
+#        ifdef __GNUC__
+#            define barrier() asm volatile("" ::: "memory")
+#        else
+#            define barrier() asm("")
+#        endif
 
 /**
  * \brief Emit the compiler pragma \a arg.
@@ -93,38 +93,37 @@
  * \param[in] arg  The pragma directive as it would appear after \e \#pragma
  *             (i.e. not stringified).
  */
-#define COMPILER_PRAGMA(arg)          _Pragma(#arg)
+#        define COMPILER_PRAGMA(arg) _Pragma(#        arg)
 
 /**
  * \def COMPILER_PACK_SET(alignment)
  * \brief Set maximum alignment for subsequent struct and union definitions to \a alignment.
  */
-#define COMPILER_PACK_SET(alignment)  COMPILER_PRAGMA(pack(alignment))
+#        define COMPILER_PACK_SET(alignment) COMPILER_PRAGMA(pack(alignment))
 
 /**
  * \def COMPILER_PACK_RESET()
  * \brief Set default alignment for subsequent struct and union definitions.
  */
-#define COMPILER_PACK_RESET()         COMPILER_PRAGMA(pack())
-
+#        define COMPILER_PACK_RESET() COMPILER_PRAGMA(pack())
 
 /**
  * \brief Set aligned boundary.
  */
-#if (defined __GNUC__) || (defined __CC_ARM)
-#   define COMPILER_ALIGNED(a)        __attribute__((__aligned__(a)))
-#elif (defined __ICCARM__)
-#   define COMPILER_ALIGNED(a)        COMPILER_PRAGMA(data_alignment = a)
-#endif
+#        if (defined __GNUC__) || (defined __CC_ARM)
+#            define COMPILER_ALIGNED(a) __attribute__((__aligned__(a)))
+#        elif (defined __ICCARM__)
+#            define COMPILER_ALIGNED(a) COMPILER_PRAGMA(data_alignment = a)
+#        endif
 
 /**
  * \brief Set word-aligned boundary.
  */
-#if (defined __GNUC__) || defined(__CC_ARM)
-#define COMPILER_WORD_ALIGNED         __attribute__((__aligned__(4)))
-#elif (defined __ICCARM__)
-#define COMPILER_WORD_ALIGNED         COMPILER_PRAGMA(data_alignment = 4)
-#endif
+#        if (defined __GNUC__) || defined(__CC_ARM)
+#            define COMPILER_WORD_ALIGNED __attribute__((__aligned__(4)))
+#        elif (defined __ICCARM__)
+#            define COMPILER_WORD_ALIGNED COMPILER_PRAGMA(data_alignment = 4)
+#        endif
 
 /**
  * \def __always_inline
@@ -134,15 +133,15 @@
  * heuristics and inline the function no matter how big it thinks it
  * becomes.
  */
-#if !defined(__always_inline)
-#if defined(__CC_ARM)
-#  define __always_inline             __forceinline
-#elif (defined __GNUC__)
-#  define __always_inline             __attribute__((__always_inline__))
-#elif (defined __ICCARM__)
-#  define __always_inline             _Pragma("inline=forced")
-#endif
-#endif
+#        if !defined(__always_inline)
+#            if defined(__CC_ARM)
+#                define __always_inline __forceinline
+#            elif (defined __GNUC__)
+#                define __always_inline __attribute__((__always_inline__))
+#            elif (defined __ICCARM__)
+#                define __always_inline _Pragma("inline=forced")
+#            endif
+#        endif
 
 /**
  * \def __no_inline
@@ -152,14 +151,13 @@
  * heuristics and not inline the function no matter how small it thinks it
  * becomes.
  */
-#if defined(__CC_ARM)
-#  define __no_inline                 __attribute__((noinline))
-#elif (defined __GNUC__)
-#  define __no_inline                 __attribute__((noinline))
-#elif (defined __ICCARM__)
-#  define __no_inline                 _Pragma("inline=never")
-#endif
-
+#        if defined(__CC_ARM)
+#            define __no_inline __attribute__((noinline))
+#        elif (defined __GNUC__)
+#            define __no_inline __attribute__((noinline))
+#        elif (defined __ICCARM__)
+#            define __no_inline _Pragma("inline=never")
+#        endif
 
 /** \brief This macro is used to test fatal errors.
  *
@@ -170,212 +168,201 @@
  *
  * \param[in] expr  Expression to evaluate and supposed to be nonzero.
  */
-#if defined(_ASSERT_ENABLE_)
-#  if defined(TEST_SUITE_DEFINE_ASSERT_MACRO)
-#    include "unit_test/suite.h"
-#  else
-#    undef TEST_SUITE_DEFINE_ASSERT_MACRO
-#    define Assert(expr) \
-        {\
-           if (!(expr)) asm("BKPT #0");\
-        }
-#  endif
-#else
-#  define Assert(expr) ((void) 0)
-#endif
+#        if defined(_ASSERT_ENABLE_)
+#            if defined(TEST_SUITE_DEFINE_ASSERT_MACRO)
+#                include "unit_test/suite.h"
+#            else
+#                undef TEST_SUITE_DEFINE_ASSERT_MACRO
+#                define Assert(expr)                 \
+                    {                                \
+                        if (!(expr)) asm("BKPT #0"); \
+                    }
+#            endif
+#        else
+#            define Assert(expr) ((void)0)
+#        endif
 
 /* Define WEAK attribute */
-#if defined   ( __CC_ARM   )
-#   define WEAK __attribute__ ((weak))
-#elif defined ( __ICCARM__ )
-#   define WEAK __weak
-#elif defined (  __GNUC__  )
-#   define WEAK __attribute__ ((weak))
-#endif
+#        if defined(__CC_ARM)
+#            define WEAK __attribute__((weak))
+#        elif defined(__ICCARM__)
+#            define WEAK __weak
+#        elif defined(__GNUC__)
+#            define WEAK __attribute__((weak))
+#        endif
 
 /* Define NO_INIT attribute */
-#if defined   ( __CC_ARM   )
-#   define NO_INIT __attribute__((zero_init))
-#elif defined ( __ICCARM__ )
-#   define NO_INIT __no_init
-#elif defined (  __GNUC__  )
-#   define NO_INIT __attribute__((section(".no_init")))
-#endif
+#        if defined(__CC_ARM)
+#            define NO_INIT __attribute__((zero_init))
+#        elif defined(__ICCARM__)
+#            define NO_INIT __no_init
+#        elif defined(__GNUC__)
+#            define NO_INIT __attribute__((section(".no_init")))
+#        endif
 
 //#include "interrupt.h"
 
 /** \name Usual Types
  * @{ */
-#ifndef __cplusplus
-#  if !defined(__bool_true_false_are_defined)
-typedef unsigned char           bool;
-#  endif
-#endif
-typedef uint16_t                le16_t;
-typedef uint16_t                be16_t;
-typedef uint32_t                le32_t;
-typedef uint32_t                be32_t;
-typedef uint32_t                iram_size_t;
+#        ifndef __cplusplus
+#            if !defined(__bool_true_false_are_defined)
+typedef unsigned char bool;
+#            endif
+#        endif
+typedef uint16_t le16_t;
+typedef uint16_t be16_t;
+typedef uint32_t le32_t;
+typedef uint32_t be32_t;
+typedef uint32_t iram_size_t;
 /** @} */
 
 /** \name Aliasing Aggregate Types
  * @{ */
 
 /** 16-bit union. */
-typedef union
-{
-  int16_t  s16;
-  uint16_t u16;
-  int8_t   s8[2];
-  uint8_t  u8[2];
+typedef union {
+    int16_t  s16;
+    uint16_t u16;
+    int8_t   s8[2];
+    uint8_t  u8[2];
 } Union16;
 
 /** 32-bit union. */
-typedef union
-{
-  int32_t  s32;
-  uint32_t u32;
-  int16_t  s16[2];
-  uint16_t u16[2];
-  int8_t   s8[4];
-  uint8_t  u8[4];
+typedef union {
+    int32_t  s32;
+    uint32_t u32;
+    int16_t  s16[2];
+    uint16_t u16[2];
+    int8_t   s8[4];
+    uint8_t  u8[4];
 } Union32;
 
 /** 64-bit union. */
-typedef union
-{
-  int64_t  s64;
-  uint64_t u64;
-  int32_t  s32[2];
-  uint32_t u32[2];
-  int16_t  s16[4];
-  uint16_t u16[4];
-  int8_t   s8[8];
-  uint8_t  u8[8];
+typedef union {
+    int64_t  s64;
+    uint64_t u64;
+    int32_t  s32[2];
+    uint32_t u32[2];
+    int16_t  s16[4];
+    uint16_t u16[4];
+    int8_t   s8[8];
+    uint8_t  u8[8];
 } Union64;
 
 /** Union of pointers to 64-, 32-, 16- and 8-bit unsigned integers. */
-typedef union
-{
-  int64_t  *s64ptr;
-  uint64_t *u64ptr;
-  int32_t  *s32ptr;
-  uint32_t *u32ptr;
-  int16_t  *s16ptr;
-  uint16_t *u16ptr;
-  int8_t   *s8ptr;
-  uint8_t  *u8ptr;
+typedef union {
+    int64_t * s64ptr;
+    uint64_t *u64ptr;
+    int32_t * s32ptr;
+    uint32_t *u32ptr;
+    int16_t * s16ptr;
+    uint16_t *u16ptr;
+    int8_t *  s8ptr;
+    uint8_t * u8ptr;
 } UnionPtr;
 
 /** Union of pointers to volatile 64-, 32-, 16- and 8-bit unsigned integers. */
-typedef union
-{
-  volatile int64_t  *s64ptr;
-  volatile uint64_t *u64ptr;
-  volatile int32_t  *s32ptr;
-  volatile uint32_t *u32ptr;
-  volatile int16_t  *s16ptr;
-  volatile uint16_t *u16ptr;
-  volatile int8_t   *s8ptr;
-  volatile uint8_t  *u8ptr;
+typedef union {
+    volatile int64_t * s64ptr;
+    volatile uint64_t *u64ptr;
+    volatile int32_t * s32ptr;
+    volatile uint32_t *u32ptr;
+    volatile int16_t * s16ptr;
+    volatile uint16_t *u16ptr;
+    volatile int8_t *  s8ptr;
+    volatile uint8_t * u8ptr;
 } UnionVPtr;
 
 /** Union of pointers to constant 64-, 32-, 16- and 8-bit unsigned integers. */
-typedef union
-{
-  const int64_t  *s64ptr;
-  const uint64_t *u64ptr;
-  const int32_t  *s32ptr;
-  const uint32_t *u32ptr;
-  const int16_t  *s16ptr;
-  const uint16_t *u16ptr;
-  const int8_t   *s8ptr;
-  const uint8_t  *u8ptr;
+typedef union {
+    const int64_t * s64ptr;
+    const uint64_t *u64ptr;
+    const int32_t * s32ptr;
+    const uint32_t *u32ptr;
+    const int16_t * s16ptr;
+    const uint16_t *u16ptr;
+    const int8_t *  s8ptr;
+    const uint8_t * u8ptr;
 } UnionCPtr;
 
 /** Union of pointers to constant volatile 64-, 32-, 16- and 8-bit unsigned integers. */
-typedef union
-{
-  const volatile int64_t  *s64ptr;
-  const volatile uint64_t *u64ptr;
-  const volatile int32_t  *s32ptr;
-  const volatile uint32_t *u32ptr;
-  const volatile int16_t  *s16ptr;
-  const volatile uint16_t *u16ptr;
-  const volatile int8_t   *s8ptr;
-  const volatile uint8_t  *u8ptr;
+typedef union {
+    const volatile int64_t * s64ptr;
+    const volatile uint64_t *u64ptr;
+    const volatile int32_t * s32ptr;
+    const volatile uint32_t *u32ptr;
+    const volatile int16_t * s16ptr;
+    const volatile uint16_t *u16ptr;
+    const volatile int8_t *  s8ptr;
+    const volatile uint8_t * u8ptr;
 } UnionCVPtr;
 
 /** Structure of pointers to 64-, 32-, 16- and 8-bit unsigned integers. */
-typedef struct
-{
-  int64_t  *s64ptr;
-  uint64_t *u64ptr;
-  int32_t  *s32ptr;
-  uint32_t *u32ptr;
-  int16_t  *s16ptr;
-  uint16_t *u16ptr;
-  int8_t   *s8ptr;
-  uint8_t  *u8ptr;
+typedef struct {
+    int64_t * s64ptr;
+    uint64_t *u64ptr;
+    int32_t * s32ptr;
+    uint32_t *u32ptr;
+    int16_t * s16ptr;
+    uint16_t *u16ptr;
+    int8_t *  s8ptr;
+    uint8_t * u8ptr;
 } StructPtr;
 
 /** Structure of pointers to volatile 64-, 32-, 16- and 8-bit unsigned integers. */
-typedef struct
-{
-  volatile int64_t  *s64ptr;
-  volatile uint64_t *u64ptr;
-  volatile int32_t  *s32ptr;
-  volatile uint32_t *u32ptr;
-  volatile int16_t  *s16ptr;
-  volatile uint16_t *u16ptr;
-  volatile int8_t   *s8ptr;
-  volatile uint8_t  *u8ptr;
+typedef struct {
+    volatile int64_t * s64ptr;
+    volatile uint64_t *u64ptr;
+    volatile int32_t * s32ptr;
+    volatile uint32_t *u32ptr;
+    volatile int16_t * s16ptr;
+    volatile uint16_t *u16ptr;
+    volatile int8_t *  s8ptr;
+    volatile uint8_t * u8ptr;
 } StructVPtr;
 
 /** Structure of pointers to constant 64-, 32-, 16- and 8-bit unsigned integers. */
-typedef struct
-{
-  const int64_t  *s64ptr;
-  const uint64_t *u64ptr;
-  const int32_t  *s32ptr;
-  const uint32_t *u32ptr;
-  const int16_t  *s16ptr;
-  const uint16_t *u16ptr;
-  const int8_t   *s8ptr;
-  const uint8_t  *u8ptr;
+typedef struct {
+    const int64_t * s64ptr;
+    const uint64_t *u64ptr;
+    const int32_t * s32ptr;
+    const uint32_t *u32ptr;
+    const int16_t * s16ptr;
+    const uint16_t *u16ptr;
+    const int8_t *  s8ptr;
+    const uint8_t * u8ptr;
 } StructCPtr;
 
 /** Structure of pointers to constant volatile 64-, 32-, 16- and 8-bit unsigned integers. */
-typedef struct
-{
-  const volatile int64_t  *s64ptr;
-  const volatile uint64_t *u64ptr;
-  const volatile int32_t  *s32ptr;
-  const volatile uint32_t *u32ptr;
-  const volatile int16_t  *s16ptr;
-  const volatile uint16_t *u16ptr;
-  const volatile int8_t   *s8ptr;
-  const volatile uint8_t  *u8ptr;
+typedef struct {
+    const volatile int64_t * s64ptr;
+    const volatile uint64_t *u64ptr;
+    const volatile int32_t * s32ptr;
+    const volatile uint32_t *u32ptr;
+    const volatile int16_t * s16ptr;
+    const volatile uint16_t *u16ptr;
+    const volatile int8_t *  s8ptr;
+    const volatile uint8_t * u8ptr;
 } StructCVPtr;
 
 /** @} */
 
-#endif  /* #ifndef __ASSEMBLY__ */
+#    endif /* #ifndef __ASSEMBLY__ */
 
 /** \name Usual Constants
  * @{ */
-//kmod #define DISABLE   0
-//kmod #define ENABLE    1
-
-#ifndef __cplusplus
-#  if !defined(__bool_true_false_are_defined)
-#    define false     0
-#    define true      1
-#  endif
-#endif
+// kmod #define DISABLE   0
+// kmod #define ENABLE    1
+
+#    ifndef __cplusplus
+#        if !defined(__bool_true_false_are_defined)
+#            define false 0
+#            define true 1
+#        endif
+#    endif
 /** @} */
 
-#ifndef __ASSEMBLY__
+#    ifndef __ASSEMBLY__
 
 /** \name Optimization Control
  * @{ */
@@ -384,17 +371,17 @@ typedef struct
  * \def likely(exp)
  * \brief The expression \a exp is likely to be true
  */
-#if !defined(likely) || defined(__DOXYGEN__)
-#   define likely(exp)    (exp)
-#endif
+#        if !defined(likely) || defined(__DOXYGEN__)
+#            define likely(exp) (exp)
+#        endif
 
 /**
  * \def unlikely(exp)
  * \brief The expression \a exp is unlikely to be true
  */
-#if !defined(unlikely) || defined(__DOXYGEN__)
-#   define unlikely(exp)  (exp)
-#endif
+#        if !defined(unlikely) || defined(__DOXYGEN__)
+#            define unlikely(exp) (exp)
+#        endif
 
 /**
  * \def is_constant(exp)
@@ -404,11 +391,11 @@ typedef struct
  *
  * \return true if \a exp is constant, false otherwise.
  */
-#if (defined __GNUC__) || (defined __CC_ARM)
-#   define is_constant(exp)       __builtin_constant_p(exp)
-#else
-#   define is_constant(exp)       (0)
-#endif
+#        if (defined __GNUC__) || (defined __CC_ARM)
+#            define is_constant(exp) __builtin_constant_p(exp)
+#        else
+#            define is_constant(exp) (0)
+#        endif
 
 /** @} */
 
@@ -422,7 +409,7 @@ typedef struct
  *
  * \return Read bits.
  */
-#define Rd_bits( value, mask)        ((value) & (mask))
+#        define Rd_bits(value, mask) ((value) & (mask))
 
 /** \brief Writes the bits of a C lvalue specified by a given bit-mask.
  *
@@ -432,8 +419,7 @@ typedef struct
  *
  * \return Resulting value with written bits.
  */
-#define Wr_bits(lvalue, mask, bits)  ((lvalue) = ((lvalue) & ~(mask)) |\
-                                                 ((bits  ) &  (mask)))
+#        define Wr_bits(lvalue, mask, bits) ((lvalue) = ((lvalue) & ~(mask)) | ((bits) & (mask)))
 
 /** \brief Tests the bits of a value specified by a given bit-mask.
  *
@@ -442,7 +428,7 @@ typedef struct
  *
  * \return \c 1 if at least one of the tested bits is set, else \c 0.
  */
-#define Tst_bits( value, mask)  (Rd_bits(value, mask) != 0)
+#        define Tst_bits(value, mask) (Rd_bits(value, mask) != 0)
 
 /** \brief Clears the bits of a C lvalue specified by a given bit-mask.
  *
@@ -451,7 +437,7 @@ typedef struct
  *
  * \return Resulting value with cleared bits.
  */
-#define Clr_bits(lvalue, mask)  ((lvalue) &= ~(mask))
+#        define Clr_bits(lvalue, mask) ((lvalue) &= ~(mask))
 
 /** \brief Sets the bits of a C lvalue specified by a given bit-mask.
  *
@@ -460,7 +446,7 @@ typedef struct
  *
  * \return Resulting value with set bits.
  */
-#define Set_bits(lvalue, mask)  ((lvalue) |=  (mask))
+#        define Set_bits(lvalue, mask) ((lvalue) |= (mask))
 
 /** \brief Toggles the bits of a C lvalue specified by a given bit-mask.
  *
@@ -469,7 +455,7 @@ typedef struct
  *
  * \return Resulting value with toggled bits.
  */
-#define Tgl_bits(lvalue, mask)  ((lvalue) ^=  (mask))
+#        define Tgl_bits(lvalue, mask) ((lvalue) ^= (mask))
 
 /** \brief Reads the bit-field of a value specified by a given bit-mask.
  *
@@ -478,7 +464,7 @@ typedef struct
  *
  * \return Read bit-field.
  */
-#define Rd_bitfield( value, mask)           (Rd_bits( value, mask) >> ctz(mask))
+#        define Rd_bitfield(value, mask) (Rd_bits(value, mask) >> ctz(mask))
 
 /** \brief Writes the bit-field of a C lvalue specified by a given bit-mask.
  *
@@ -488,11 +474,10 @@ typedef struct
  *
  * \return Resulting value with written bit-field.
  */
-#define Wr_bitfield(lvalue, mask, bitfield) (Wr_bits(lvalue, mask, (uint32_t)(bitfield) << ctz(mask)))
+#        define Wr_bitfield(lvalue, mask, bitfield) (Wr_bits(lvalue, mask, (uint32_t)(bitfield) << ctz(mask)))
 
 /** @} */
 
-
 /** \name Zero-Bit Counting
  *
  * Under GCC, __builtin_clz and __builtin_ctz behave like macros when
@@ -513,43 +498,11 @@ typedef struct
  *
  * \return The count of leading zero bits in \a u.
  */
-#if (defined __GNUC__) || (defined __CC_ARM)
-#   define clz(u)              ((u) ? __builtin_clz(u) : 32)
-#else
-#   define clz(u)              (((u) == 0)          ? 32 : \
-                                ((u) & (1ul << 31)) ?  0 : \
-                                ((u) & (1ul << 30)) ?  1 : \
-                                ((u) & (1ul << 29)) ?  2 : \
-                                ((u) & (1ul << 28)) ?  3 : \
-                                ((u) & (1ul << 27)) ?  4 : \
-                                ((u) & (1ul << 26)) ?  5 : \
-                                ((u) & (1ul << 25)) ?  6 : \
-                                ((u) & (1ul << 24)) ?  7 : \
-                                ((u) & (1ul << 23)) ?  8 : \
-                                ((u) & (1ul << 22)) ?  9 : \
-                                ((u) & (1ul << 21)) ? 10 : \
-                                ((u) & (1ul << 20)) ? 11 : \
-                                ((u) & (1ul << 19)) ? 12 : \
-                                ((u) & (1ul << 18)) ? 13 : \
-                                ((u) & (1ul << 17)) ? 14 : \
-                                ((u) & (1ul << 16)) ? 15 : \
-                                ((u) & (1ul << 15)) ? 16 : \
-                                ((u) & (1ul << 14)) ? 17 : \
-                                ((u) & (1ul << 13)) ? 18 : \
-                                ((u) & (1ul << 12)) ? 19 : \
-                                ((u) & (1ul << 11)) ? 20 : \
-                                ((u) & (1ul << 10)) ? 21 : \
-                                ((u) & (1ul <<  9)) ? 22 : \
-                                ((u) & (1ul <<  8)) ? 23 : \
-                                ((u) & (1ul <<  7)) ? 24 : \
-                                ((u) & (1ul <<  6)) ? 25 : \
-                                ((u) & (1ul <<  5)) ? 26 : \
-                                ((u) & (1ul <<  4)) ? 27 : \
-                                ((u) & (1ul <<  3)) ? 28 : \
-                                ((u) & (1ul <<  2)) ? 29 : \
-                                ((u) & (1ul <<  1)) ? 30 : \
-                                31)
-#endif
+#        if (defined __GNUC__) || (defined __CC_ARM)
+#            define clz(u) ((u) ? __builtin_clz(u) : 32)
+#        else
+#            define clz(u) (((u) == 0) ? 32 : ((u) & (1ul << 31)) ? 0 : ((u) & (1ul << 30)) ? 1 : ((u) & (1ul << 29)) ? 2 : ((u) & (1ul << 28)) ? 3 : ((u) & (1ul << 27)) ? 4 : ((u) & (1ul << 26)) ? 5 : ((u) & (1ul << 25)) ? 6 : ((u) & (1ul << 24)) ? 7 : ((u) & (1ul << 23)) ? 8 : ((u) & (1ul << 22)) ? 9 : ((u) & (1ul << 21)) ? 10 : ((u) & (1ul << 20)) ? 11 : ((u) & (1ul << 19)) ? 12 : ((u) & (1ul << 18)) ? 13 : ((u) & (1ul << 17)) ? 14 : ((u) & (1ul << 16)) ? 15 : ((u) & (1ul << 15)) ? 16 : ((u) & (1ul << 14)) ? 17 : ((u) & (1ul << 13)) ? 18 : ((u) & (1ul << 12)) ? 19 : ((u) & (1ul << 11)) ? 20 : ((u) & (1ul << 10)) ? 21 : ((u) & (1ul << 9)) ? 22 : ((u) & (1ul << 8)) ? 23 : ((u) & (1ul << 7)) ? 24 : ((u) & (1ul << 6)) ? 25 : ((u) & (1ul << 5)) ? 26 : ((u) & (1ul << 4)) ? 27 : ((u) & (1ul << 3)) ? 28 : ((u) & (1ul << 2)) ? 29 : ((u) & (1ul << 1)) ? 30 : 31)
+#        endif
 
 /** \brief Counts the trailing zero bits of the given value considered as a 32-bit integer.
  *
@@ -557,47 +510,14 @@ typedef struct
  *
  * \return The count of trailing zero bits in \a u.
  */
-#if (defined __GNUC__) || (defined __CC_ARM)
-#   define ctz(u)              ((u) ? __builtin_ctz(u) : 32)
-#else
-#   define ctz(u)              ((u) & (1ul <<  0) ?  0 : \
-                                (u) & (1ul <<  1) ?  1 : \
-                                (u) & (1ul <<  2) ?  2 : \
-                                (u) & (1ul <<  3) ?  3 : \
-                                (u) & (1ul <<  4) ?  4 : \
-                                (u) & (1ul <<  5) ?  5 : \
-                                (u) & (1ul <<  6) ?  6 : \
-                                (u) & (1ul <<  7) ?  7 : \
-                                (u) & (1ul <<  8) ?  8 : \
-                                (u) & (1ul <<  9) ?  9 : \
-                                (u) & (1ul << 10) ? 10 : \
-                                (u) & (1ul << 11) ? 11 : \
-                                (u) & (1ul << 12) ? 12 : \
-                                (u) & (1ul << 13) ? 13 : \
-                                (u) & (1ul << 14) ? 14 : \
-                                (u) & (1ul << 15) ? 15 : \
-                                (u) & (1ul << 16) ? 16 : \
-                                (u) & (1ul << 17) ? 17 : \
-                                (u) & (1ul << 18) ? 18 : \
-                                (u) & (1ul << 19) ? 19 : \
-                                (u) & (1ul << 20) ? 20 : \
-                                (u) & (1ul << 21) ? 21 : \
-                                (u) & (1ul << 22) ? 22 : \
-                                (u) & (1ul << 23) ? 23 : \
-                                (u) & (1ul << 24) ? 24 : \
-                                (u) & (1ul << 25) ? 25 : \
-                                (u) & (1ul << 26) ? 26 : \
-                                (u) & (1ul << 27) ? 27 : \
-                                (u) & (1ul << 28) ? 28 : \
-                                (u) & (1ul << 29) ? 29 : \
-                                (u) & (1ul << 30) ? 30 : \
-                                (u) & (1ul << 31) ? 31 : \
-                                32)
-#endif
+#        if (defined __GNUC__) || (defined __CC_ARM)
+#            define ctz(u) ((u) ? __builtin_ctz(u) : 32)
+#        else
+#            define ctz(u) ((u) & (1ul << 0) ? 0 : (u) & (1ul << 1) ? 1 : (u) & (1ul << 2) ? 2 : (u) & (1ul << 3) ? 3 : (u) & (1ul << 4) ? 4 : (u) & (1ul << 5) ? 5 : (u) & (1ul << 6) ? 6 : (u) & (1ul << 7) ? 7 : (u) & (1ul << 8) ? 8 : (u) & (1ul << 9) ? 9 : (u) & (1ul << 10) ? 10 : (u) & (1ul << 11) ? 11 : (u) & (1ul << 12) ? 12 : (u) & (1ul << 13) ? 13 : (u) & (1ul << 14) ? 14 : (u) & (1ul << 15) ? 15 : (u) & (1ul << 16) ? 16 : (u) & (1ul << 17) ? 17 : (u) & (1ul << 18) ? 18 : (u) & (1ul << 19) ? 19 : (u) & (1ul << 20) ? 20 : (u) & (1ul << 21) ? 21 : (u) & (1ul << 22) ? 22 : (u) & (1ul << 23) ? 23 : (u) & (1ul << 24) ? 24 : (u) & (1ul << 25) ? 25 : (u) & (1ul << 26) ? 26 : (u) & (1ul << 27) ? 27 : (u) & (1ul << 28) ? 28 : (u) & (1ul << 29) ? 29 : (u) & (1ul << 30) ? 30 : (u) & (1ul << 31) ? 31 : 32)
+#        endif
 
 /** @} */
 
-
 /** \name Bit Reversing
  * @{ */
 
@@ -607,7 +527,7 @@ typedef struct
  *
  * \return Value resulting from \a u8 with reversed bits.
  */
-#define bit_reverse8(u8)    ((U8)(bit_reverse32((U8)(u8)) >> 24))
+#        define bit_reverse8(u8) ((U8)(bit_reverse32((U8)(u8)) >> 24))
 
 /** \brief Reverses the bits of \a u16.
  *
@@ -615,7 +535,7 @@ typedef struct
  *
  * \return Value resulting from \a u16 with reversed bits.
  */
-#define bit_reverse16(u16)  ((uint16_t)(bit_reverse32((uint16_t)(u16)) >> 16))
+#        define bit_reverse16(u16) ((uint16_t)(bit_reverse32((uint16_t)(u16)) >> 16))
 
 /** \brief Reverses the bits of \a u32.
  *
@@ -623,7 +543,7 @@ typedef struct
  *
  * \return Value resulting from \a u32 with reversed bits.
  */
-#define bit_reverse32(u32)   __RBIT(u32)
+#        define bit_reverse32(u32) __RBIT(u32)
 
 /** \brief Reverses the bits of \a u64.
  *
@@ -631,12 +551,10 @@ typedef struct
  *
  * \return Value resulting from \a u64 with reversed bits.
  */
-#define bit_reverse64(u64)  ((uint64_t)(((uint64_t)bit_reverse32((uint64_t)(u64) >> 32)) |\
-                                   ((uint64_t)bit_reverse32((uint64_t)(u64)) << 32)))
+#        define bit_reverse64(u64) ((uint64_t)(((uint64_t)bit_reverse32((uint64_t)(u64) >> 32)) | ((uint64_t)bit_reverse32((uint64_t)(u64)) << 32)))
 
 /** @} */
 
-
 /** \name Alignment
  * @{ */
 
@@ -647,7 +565,7 @@ typedef struct
  *
  * \return \c 1 if the number \a val is aligned with the \a n boundary, else \c 0.
  */
-#define Test_align(val, n) (!Tst_bits( val, (n) - 1     )   )
+#        define Test_align(val, n) (!Tst_bits(val, (n)-1))
 
 /** \brief Gets alignment of the number \a val with respect to the \a n boundary.
  *
@@ -656,7 +574,7 @@ typedef struct
  *
  * \return Alignment of the number \a val with respect to the \a n boundary.
  */
-#define Get_align(val, n) (  Rd_bits( val, (n) - 1     )   )
+#        define Get_align(val, n) (Rd_bits(val, (n)-1))
 
 /** \brief Sets alignment of the lvalue number \a lval to \a alg with respect to the \a n boundary.
  *
@@ -666,7 +584,7 @@ typedef struct
  *
  * \return New value of \a lval resulting from its alignment set to \a alg with respect to the \a n boundary.
  */
-#define Set_align(lval, n, alg) (  Wr_bits(lval, (n) - 1, alg)   )
+#        define Set_align(lval, n, alg) (Wr_bits(lval, (n)-1, alg))
 
 /** \brief Aligns the number \a val with the upper \a n boundary.
  *
@@ -675,7 +593,7 @@ typedef struct
  *
  * \return Value resulting from the number \a val aligned with the upper \a n boundary.
  */
-#define Align_up(  val, n) (((val) + ((n) - 1)) & ~((n) - 1))
+#        define Align_up(val, n) (((val) + ((n)-1)) & ~((n)-1))
 
 /** \brief Aligns the number \a val with the lower \a n boundary.
  *
@@ -684,11 +602,10 @@ typedef struct
  *
  * \return Value resulting from the number \a val aligned with the lower \a n boundary.
  */
-#define Align_down(val, n) ( (val)              & ~((n) - 1))
+#        define Align_down(val, n) ((val) & ~((n)-1))
 
 /** @} */
 
-
 /** \name Mathematics
  *
  * The same considerations as for clz and ctz apply here but GCC does not
@@ -710,9 +627,9 @@ typedef struct
  *
  * \note More optimized if only used with values known at compile time.
  */
-#define Abs(a)              (((a) <  0 ) ? -(a) : (a))
+#        define Abs(a) (((a) < 0) ? -(a) : (a))
 
-#ifndef __cplusplus
+#        ifndef __cplusplus
 /** \brief Takes the minimal value of \a a and \a b.
  *
  * \param[in] a Input value.
@@ -722,7 +639,7 @@ typedef struct
  *
  * \note More optimized if only used with values known at compile time.
  */
-#define Min(a, b)           (((a) < (b)) ?  (a) : (b))
+#            define Min(a, b) (((a) < (b)) ? (a) : (b))
 
 /** \brief Takes the maximal value of \a a and \a b.
  *
@@ -733,7 +650,7 @@ typedef struct
  *
  * \note More optimized if only used with values known at compile time.
  */
-#define Max(a, b)           (((a) > (b)) ?  (a) : (b))
+#            define Max(a, b) (((a) > (b)) ? (a) : (b))
 
 /** \brief Takes the minimal value of \a a and \a b.
  *
@@ -744,7 +661,7 @@ typedef struct
  *
  * \note More optimized if only used with values unknown at compile time.
  */
-#define min(a, b)   Min(a, b)
+#            define min(a, b) Min(a, b)
 
 /** \brief Takes the maximal value of \a a and \a b.
  *
@@ -755,12 +672,11 @@ typedef struct
  *
  * \note More optimized if only used with values unknown at compile time.
  */
-#define max(a, b)   Max(a, b)
-#endif
+#            define max(a, b) Max(a, b)
+#        endif
 
 /** @} */
 
-
 /** \brief Calls the routine at address \a addr.
  *
  * It generates a long call opcode.
@@ -772,38 +688,36 @@ typedef struct
  *
  * \note It may be used as a long jump opcode in some special cases.
  */
-#define Long_call(addr)                   ((*(void (*)(void))(addr))())
-
+#        define Long_call(addr) ((*(void (*)(void))(addr))())
 
 /** \name MCU Endianism Handling
  *  ARM is MCU little endian.
  *
  * @{ */
-#define  BE16(x)        swap16(x)
-#define  LE16(x)        (x)
-
-#define  le16_to_cpu(x) (x)
-#define  cpu_to_le16(x) (x)
-#define  LE16_TO_CPU(x) (x)
-#define  CPU_TO_LE16(x) (x)
-
-#define  be16_to_cpu(x) swap16(x)
-#define  cpu_to_be16(x) swap16(x)
-#define  BE16_TO_CPU(x) swap16(x)
-#define  CPU_TO_BE16(x) swap16(x)
-
-#define  le32_to_cpu(x) (x)
-#define  cpu_to_le32(x) (x)
-#define  LE32_TO_CPU(x) (x)
-#define  CPU_TO_LE32(x) (x)
-
-#define  be32_to_cpu(x) swap32(x)
-#define  cpu_to_be32(x) swap32(x)
-#define  BE32_TO_CPU(x) swap32(x)
-#define  CPU_TO_BE32(x) swap32(x)
+#        define BE16(x) swap16(x)
+#        define LE16(x) (x)
+
+#        define le16_to_cpu(x) (x)
+#        define cpu_to_le16(x) (x)
+#        define LE16_TO_CPU(x) (x)
+#        define CPU_TO_LE16(x) (x)
+
+#        define be16_to_cpu(x) swap16(x)
+#        define cpu_to_be16(x) swap16(x)
+#        define BE16_TO_CPU(x) swap16(x)
+#        define CPU_TO_BE16(x) swap16(x)
+
+#        define le32_to_cpu(x) (x)
+#        define cpu_to_le32(x) (x)
+#        define LE32_TO_CPU(x) (x)
+#        define CPU_TO_LE32(x) (x)
+
+#        define be32_to_cpu(x) swap32(x)
+#        define cpu_to_be32(x) swap32(x)
+#        define BE32_TO_CPU(x) swap32(x)
+#        define CPU_TO_BE32(x) swap32(x)
 /** @} */
 
-
 /** \name Endianism Conversion
  *
  * The same considerations as for clz and ctz apply here but GCC's
@@ -824,8 +738,7 @@ typedef struct
  *
  * \note More optimized if only used with values known at compile time.
  */
-#define Swap16(u16) ((uint16_t)(((uint16_t)(u16) >> 8) |\
-                           ((uint16_t)(u16) << 8)))
+#        define Swap16(u16) ((uint16_t)(((uint16_t)(u16) >> 8) | ((uint16_t)(u16) << 8)))
 
 /** \brief Toggles the endianism of \a u32 (by swapping its bytes).
  *
@@ -835,8 +748,7 @@ typedef struct
  *
  * \note More optimized if only used with values known at compile time.
  */
-#define Swap32(u32) ((uint32_t)(((uint32_t)Swap16((uint32_t)(u32) >> 16)) |\
-                           ((uint32_t)Swap16((uint32_t)(u32)) << 16)))
+#        define Swap32(u32) ((uint32_t)(((uint32_t)Swap16((uint32_t)(u32) >> 16)) | ((uint32_t)Swap16((uint32_t)(u32)) << 16)))
 
 /** \brief Toggles the endianism of \a u64 (by swapping its bytes).
  *
@@ -846,8 +758,7 @@ typedef struct
  *
  * \note More optimized if only used with values known at compile time.
  */
-#define Swap64(u64) ((uint64_t)(((uint64_t)Swap32((uint64_t)(u64) >> 32)) |\
-                           ((uint64_t)Swap32((uint64_t)(u64)) << 32)))
+#        define Swap64(u64) ((uint64_t)(((uint64_t)Swap32((uint64_t)(u64) >> 32)) | ((uint64_t)Swap32((uint64_t)(u64)) << 32)))
 
 /** \brief Toggles the endianism of \a u16 (by swapping its bytes).
  *
@@ -857,7 +768,7 @@ typedef struct
  *
  * \note More optimized if only used with values unknown at compile time.
  */
-#define swap16(u16) Swap16(u16)
+#        define swap16(u16) Swap16(u16)
 
 /** \brief Toggles the endianism of \a u32 (by swapping its bytes).
  *
@@ -867,11 +778,11 @@ typedef struct
  *
  * \note More optimized if only used with values unknown at compile time.
  */
-#if (defined __GNUC__)
-#  define swap32(u32) ((uint32_t)__builtin_bswap32((uint32_t)(u32)))
-#else
-#  define swap32(u32) Swap32(u32)
-#endif
+#        if (defined __GNUC__)
+#            define swap32(u32) ((uint32_t)__builtin_bswap32((uint32_t)(u32)))
+#        else
+#            define swap32(u32) Swap32(u32)
+#        endif
 
 /** \brief Toggles the endianism of \a u64 (by swapping its bytes).
  *
@@ -881,30 +792,28 @@ typedef struct
  *
  * \note More optimized if only used with values unknown at compile time.
  */
-#if (defined __GNUC__)
-#  define swap64(u64) ((uint64_t)__builtin_bswap64((uint64_t)(u64)))
-#else
-#  define swap64(u64) ((uint64_t)(((uint64_t)swap32((uint64_t)(u64) >> 32)) |\
-                         ((uint64_t)swap32((uint64_t)(u64)) << 32)))
-#endif
+#        if (defined __GNUC__)
+#            define swap64(u64) ((uint64_t)__builtin_bswap64((uint64_t)(u64)))
+#        else
+#            define swap64(u64) ((uint64_t)(((uint64_t)swap32((uint64_t)(u64) >> 32)) | ((uint64_t)swap32((uint64_t)(u64)) << 32)))
+#        endif
 
 /** @} */
 
-
 /** \name Target Abstraction
  *
  * @{ */
 
-#define _GLOBEXT_           extern      /**< extern storage-class specifier. */
-#define _CONST_TYPE_        const       /**< const type qualifier. */
-#define _MEM_TYPE_SLOW_                 /**< Slow memory type. */
-#define _MEM_TYPE_MEDFAST_              /**< Fairly fast memory type. */
-#define _MEM_TYPE_FAST_                 /**< Fast memory type. */
+#        define _GLOBEXT_ extern   /**< extern storage-class specifier. */
+#        define _CONST_TYPE_ const /**< const type qualifier. */
+#        define _MEM_TYPE_SLOW_    /**< Slow memory type. */
+#        define _MEM_TYPE_MEDFAST_ /**< Fairly fast memory type. */
+#        define _MEM_TYPE_FAST_    /**< Fast memory type. */
 
-#define memcmp_ram2ram      memcmp      /**< Target-specific memcmp of RAM to RAM. */
-#define memcmp_code2ram     memcmp      /**< Target-specific memcmp of RAM to NVRAM. */
-#define memcpy_ram2ram      memcpy      /**< Target-specific memcpy from RAM to RAM. */
-#define memcpy_code2ram     memcpy      /**< Target-specific memcpy from NVRAM to RAM. */
+#        define memcmp_ram2ram memcmp  /**< Target-specific memcmp of RAM to RAM. */
+#        define memcmp_code2ram memcmp /**< Target-specific memcmp of RAM to NVRAM. */
+#        define memcpy_ram2ram memcpy  /**< Target-specific memcpy from RAM to RAM. */
+#        define memcpy_code2ram memcpy /**< Target-specific memcpy from NVRAM to RAM. */
 
 /** @} */
 
@@ -917,159 +826,162 @@ typedef struct
  *
  * \return (\a a / \a b) rounded up to the nearest integer.
  */
-#define div_ceil(a, b)      (((a) + (b) - 1) / (b))
+#        define div_ceil(a, b) (((a) + (b)-1) / (b))
 
-#endif  /* #ifndef __ASSEMBLY__ */
-#ifdef __ICCARM__
+#    endif /* #ifndef __ASSEMBLY__ */
+#    ifdef __ICCARM__
 /** \name Compiler Keywords
  *
  * Port of some keywords from GCC to IAR Embedded Workbench.
  *
  * @{ */
 
-#define __asm__             asm
-#define __inline__          inline
-#define __volatile__
+#        define __asm__ asm
+#        define __inline__ inline
+#        define __volatile__
 
 /** @} */
 
-#endif
+#    endif
 
-#define FUNC_PTR                            void *
+#    define FUNC_PTR void *
 /**
  * \def unused
  * \brief Marking \a v as a unused parameter or value.
  */
-#define unused(v)          do { (void)(v); } while(0)
+#    define unused(v)  \
+        do {           \
+            (void)(v); \
+        } while (0)
 
 /* Define RAMFUNC attribute */
-#if defined   ( __CC_ARM   ) /* Keil uVision 4 */
-#   define RAMFUNC __attribute__ ((section(".ramfunc")))
-#elif defined ( __ICCARM__ ) /* IAR Ewarm 5.41+ */
-#   define RAMFUNC __ramfunc
-#elif defined (  __GNUC__  ) /* GCC CS3 2009q3-68 */
-#   define RAMFUNC __attribute__ ((section(".ramfunc")))
-#endif
+#    if defined(__CC_ARM) /* Keil uVision 4 */
+#        define RAMFUNC __attribute__((section(".ramfunc")))
+#    elif defined(__ICCARM__) /* IAR Ewarm 5.41+ */
+#        define RAMFUNC __ramfunc
+#    elif defined(__GNUC__) /* GCC CS3 2009q3-68 */
+#        define RAMFUNC __attribute__((section(".ramfunc")))
+#    endif
 
 /* Define OPTIMIZE_HIGH attribute */
-#if defined   ( __CC_ARM   ) /* Keil uVision 4 */
-#   define OPTIMIZE_HIGH _Pragma("O3")
-#elif defined ( __ICCARM__ ) /* IAR Ewarm 5.41+ */
-#   define OPTIMIZE_HIGH _Pragma("optimize=high")
-#elif defined (  __GNUC__  ) /* GCC CS3 2009q3-68 */
-#   define OPTIMIZE_HIGH __attribute__((optimize("s")))
-#endif
-//kmod #define PASS      0
-//kmod #define FAIL      1
-//kmod #define LOW       0
-//kmod #define HIGH      1
-
-typedef int8_t                  S8 ;  //!< 8-bit signed integer.
-typedef uint8_t                 U8 ;  //!< 8-bit unsigned integer.
-typedef int16_t                 S16;  //!< 16-bit signed integer.
-typedef uint16_t                U16;  //!< 16-bit unsigned integer.
-typedef int32_t                 S32;  //!< 32-bit signed integer.
-typedef uint32_t                U32;  //!< 32-bit unsigned integer.
-typedef int64_t                 S64;  //!< 64-bit signed integer.
-typedef uint64_t                U64;  //!< 64-bit unsigned integer.
-typedef float                   F32;  //!< 32-bit floating-point number.
-typedef double                  F64;  //!< 64-bit floating-point number.
-
-#define  MSB(u16)       (((U8  *)&(u16))[1]) //!< Most significant byte of \a u16.
-#define  LSB(u16)       (((U8  *)&(u16))[0]) //!< Least significant byte of \a u16.
-
-#define  MSH(u32)       (((U16 *)&(u32))[1]) //!< Most significant half-word of \a u32.
-#define  LSH(u32)       (((U16 *)&(u32))[0]) //!< Least significant half-word of \a u32.
-#define  MSB0W(u32)     (((U8  *)&(u32))[3]) //!< Most significant byte of 1st rank of \a u32.
-#define  MSB1W(u32)     (((U8  *)&(u32))[2]) //!< Most significant byte of 2nd rank of \a u32.
-#define  MSB2W(u32)     (((U8  *)&(u32))[1]) //!< Most significant byte of 3rd rank of \a u32.
-#define  MSB3W(u32)     (((U8  *)&(u32))[0]) //!< Most significant byte of 4th rank of \a u32.
-#define  LSB3W(u32)     MSB0W(u32)           //!< Least significant byte of 4th rank of \a u32.
-#define  LSB2W(u32)     MSB1W(u32)           //!< Least significant byte of 3rd rank of \a u32.
-#define  LSB1W(u32)     MSB2W(u32)           //!< Least significant byte of 2nd rank of \a u32.
-#define  LSB0W(u32)     MSB3W(u32)           //!< Least significant byte of 1st rank of \a u32.
-
-#define  MSW(u64)       (((U32 *)&(u64))[1]) //!< Most significant word of \a u64.
-#define  LSW(u64)       (((U32 *)&(u64))[0]) //!< Least significant word of \a u64.
-#define  MSH0(u64)      (((U16 *)&(u64))[3]) //!< Most significant half-word of 1st rank of \a u64.
-#define  MSH1(u64)      (((U16 *)&(u64))[2]) //!< Most significant half-word of 2nd rank of \a u64.
-#define  MSH2(u64)      (((U16 *)&(u64))[1]) //!< Most significant half-word of 3rd rank of \a u64.
-#define  MSH3(u64)      (((U16 *)&(u64))[0]) //!< Most significant half-word of 4th rank of \a u64.
-#define  LSH3(u64)      MSH0(u64)            //!< Least significant half-word of 4th rank of \a u64.
-#define  LSH2(u64)      MSH1(u64)            //!< Least significant half-word of 3rd rank of \a u64.
-#define  LSH1(u64)      MSH2(u64)            //!< Least significant half-word of 2nd rank of \a u64.
-#define  LSH0(u64)      MSH3(u64)            //!< Least significant half-word of 1st rank of \a u64.
-#define  MSB0D(u64)     (((U8  *)&(u64))[7]) //!< Most significant byte of 1st rank of \a u64.
-#define  MSB1D(u64)     (((U8  *)&(u64))[6]) //!< Most significant byte of 2nd rank of \a u64.
-#define  MSB2D(u64)     (((U8  *)&(u64))[5]) //!< Most significant byte of 3rd rank of \a u64.
-#define  MSB3D(u64)     (((U8  *)&(u64))[4]) //!< Most significant byte of 4th rank of \a u64.
-#define  MSB4D(u64)     (((U8  *)&(u64))[3]) //!< Most significant byte of 5th rank of \a u64.
-#define  MSB5D(u64)     (((U8  *)&(u64))[2]) //!< Most significant byte of 6th rank of \a u64.
-#define  MSB6D(u64)     (((U8  *)&(u64))[1]) //!< Most significant byte of 7th rank of \a u64.
-#define  MSB7D(u64)     (((U8  *)&(u64))[0]) //!< Most significant byte of 8th rank of \a u64.
-#define  LSB7D(u64)     MSB0D(u64)           //!< Least significant byte of 8th rank of \a u64.
-#define  LSB6D(u64)     MSB1D(u64)           //!< Least significant byte of 7th rank of \a u64.
-#define  LSB5D(u64)     MSB2D(u64)           //!< Least significant byte of 6th rank of \a u64.
-#define  LSB4D(u64)     MSB3D(u64)           //!< Least significant byte of 5th rank of \a u64.
-#define  LSB3D(u64)     MSB4D(u64)           //!< Least significant byte of 4th rank of \a u64.
-#define  LSB2D(u64)     MSB5D(u64)           //!< Least significant byte of 3rd rank of \a u64.
-#define  LSB1D(u64)     MSB6D(u64)           //!< Least significant byte of 2nd rank of \a u64.
-#define  LSB0D(u64)     MSB7D(u64)           //!< Least significant byte of 1st rank of \a u64.
-
-#define LSB0(u32)           LSB0W(u32)  //!< Least significant byte of 1st rank of \a u32.
-#define LSB1(u32)           LSB1W(u32)  //!< Least significant byte of 2nd rank of \a u32.
-#define LSB2(u32)           LSB2W(u32)  //!< Least significant byte of 3rd rank of \a u32.
-#define LSB3(u32)           LSB3W(u32)  //!< Least significant byte of 4th rank of \a u32.
-#define MSB3(u32)           MSB3W(u32)  //!< Most significant byte of 4th rank of \a u32.
-#define MSB2(u32)           MSB2W(u32)  //!< Most significant byte of 3rd rank of \a u32.
-#define MSB1(u32)           MSB1W(u32)  //!< Most significant byte of 2nd rank of \a u32.
-#define MSB0(u32)           MSB0W(u32)  //!< Most significant byte of 1st rank of \a u32.
-
-#if defined(__ICCARM__)
-#define SHORTENUM           __packed
-#elif defined(__GNUC__)
-#define SHORTENUM           __attribute__((packed))
-#endif
+#    if defined(__CC_ARM) /* Keil uVision 4 */
+#        define OPTIMIZE_HIGH _Pragma("O3")
+#    elif defined(__ICCARM__) /* IAR Ewarm 5.41+ */
+#        define OPTIMIZE_HIGH _Pragma("optimize=high")
+#    elif defined(__GNUC__) /* GCC CS3 2009q3-68 */
+#        define OPTIMIZE_HIGH __attribute__((optimize("s")))
+#    endif
+// kmod #define PASS      0
+// kmod #define FAIL      1
+// kmod #define LOW       0
+// kmod #define HIGH      1
+
+typedef int8_t   S8;   //!< 8-bit signed integer.
+typedef uint8_t  U8;   //!< 8-bit unsigned integer.
+typedef int16_t  S16;  //!< 16-bit signed integer.
+typedef uint16_t U16;  //!< 16-bit unsigned integer.
+typedef int32_t  S32;  //!< 32-bit signed integer.
+typedef uint32_t U32;  //!< 32-bit unsigned integer.
+typedef int64_t  S64;  //!< 64-bit signed integer.
+typedef uint64_t U64;  //!< 64-bit unsigned integer.
+typedef float    F32;  //!< 32-bit floating-point number.
+typedef double   F64;  //!< 64-bit floating-point number.
+
+#    define MSB(u16) (((U8 *)&(u16))[1])  //!< Most significant byte of \a u16.
+#    define LSB(u16) (((U8 *)&(u16))[0])  //!< Least significant byte of \a u16.
+
+#    define MSH(u32) (((U16 *)&(u32))[1])   //!< Most significant half-word of \a u32.
+#    define LSH(u32) (((U16 *)&(u32))[0])   //!< Least significant half-word of \a u32.
+#    define MSB0W(u32) (((U8 *)&(u32))[3])  //!< Most significant byte of 1st rank of \a u32.
+#    define MSB1W(u32) (((U8 *)&(u32))[2])  //!< Most significant byte of 2nd rank of \a u32.
+#    define MSB2W(u32) (((U8 *)&(u32))[1])  //!< Most significant byte of 3rd rank of \a u32.
+#    define MSB3W(u32) (((U8 *)&(u32))[0])  //!< Most significant byte of 4th rank of \a u32.
+#    define LSB3W(u32) MSB0W(u32)           //!< Least significant byte of 4th rank of \a u32.
+#    define LSB2W(u32) MSB1W(u32)           //!< Least significant byte of 3rd rank of \a u32.
+#    define LSB1W(u32) MSB2W(u32)           //!< Least significant byte of 2nd rank of \a u32.
+#    define LSB0W(u32) MSB3W(u32)           //!< Least significant byte of 1st rank of \a u32.
+
+#    define MSW(u64) (((U32 *)&(u64))[1])   //!< Most significant word of \a u64.
+#    define LSW(u64) (((U32 *)&(u64))[0])   //!< Least significant word of \a u64.
+#    define MSH0(u64) (((U16 *)&(u64))[3])  //!< Most significant half-word of 1st rank of \a u64.
+#    define MSH1(u64) (((U16 *)&(u64))[2])  //!< Most significant half-word of 2nd rank of \a u64.
+#    define MSH2(u64) (((U16 *)&(u64))[1])  //!< Most significant half-word of 3rd rank of \a u64.
+#    define MSH3(u64) (((U16 *)&(u64))[0])  //!< Most significant half-word of 4th rank of \a u64.
+#    define LSH3(u64) MSH0(u64)             //!< Least significant half-word of 4th rank of \a u64.
+#    define LSH2(u64) MSH1(u64)             //!< Least significant half-word of 3rd rank of \a u64.
+#    define LSH1(u64) MSH2(u64)             //!< Least significant half-word of 2nd rank of \a u64.
+#    define LSH0(u64) MSH3(u64)             //!< Least significant half-word of 1st rank of \a u64.
+#    define MSB0D(u64) (((U8 *)&(u64))[7])  //!< Most significant byte of 1st rank of \a u64.
+#    define MSB1D(u64) (((U8 *)&(u64))[6])  //!< Most significant byte of 2nd rank of \a u64.
+#    define MSB2D(u64) (((U8 *)&(u64))[5])  //!< Most significant byte of 3rd rank of \a u64.
+#    define MSB3D(u64) (((U8 *)&(u64))[4])  //!< Most significant byte of 4th rank of \a u64.
+#    define MSB4D(u64) (((U8 *)&(u64))[3])  //!< Most significant byte of 5th rank of \a u64.
+#    define MSB5D(u64) (((U8 *)&(u64))[2])  //!< Most significant byte of 6th rank of \a u64.
+#    define MSB6D(u64) (((U8 *)&(u64))[1])  //!< Most significant byte of 7th rank of \a u64.
+#    define MSB7D(u64) (((U8 *)&(u64))[0])  //!< Most significant byte of 8th rank of \a u64.
+#    define LSB7D(u64) MSB0D(u64)           //!< Least significant byte of 8th rank of \a u64.
+#    define LSB6D(u64) MSB1D(u64)           //!< Least significant byte of 7th rank of \a u64.
+#    define LSB5D(u64) MSB2D(u64)           //!< Least significant byte of 6th rank of \a u64.
+#    define LSB4D(u64) MSB3D(u64)           //!< Least significant byte of 5th rank of \a u64.
+#    define LSB3D(u64) MSB4D(u64)           //!< Least significant byte of 4th rank of \a u64.
+#    define LSB2D(u64) MSB5D(u64)           //!< Least significant byte of 3rd rank of \a u64.
+#    define LSB1D(u64) MSB6D(u64)           //!< Least significant byte of 2nd rank of \a u64.
+#    define LSB0D(u64) MSB7D(u64)           //!< Least significant byte of 1st rank of \a u64.
+
+#    define LSB0(u32) LSB0W(u32)  //!< Least significant byte of 1st rank of \a u32.
+#    define LSB1(u32) LSB1W(u32)  //!< Least significant byte of 2nd rank of \a u32.
+#    define LSB2(u32) LSB2W(u32)  //!< Least significant byte of 3rd rank of \a u32.
+#    define LSB3(u32) LSB3W(u32)  //!< Least significant byte of 4th rank of \a u32.
+#    define MSB3(u32) MSB3W(u32)  //!< Most significant byte of 4th rank of \a u32.
+#    define MSB2(u32) MSB2W(u32)  //!< Most significant byte of 3rd rank of \a u32.
+#    define MSB1(u32) MSB1W(u32)  //!< Most significant byte of 2nd rank of \a u32.
+#    define MSB0(u32) MSB0W(u32)  //!< Most significant byte of 1st rank of \a u32.
+
+#    if defined(__ICCARM__)
+#        define SHORTENUM __packed
+#    elif defined(__GNUC__)
+#        define SHORTENUM __attribute__((packed))
+#    endif
 
 /* No operation */
-#if defined(__ICCARM__)
-#define nop()               __no_operation()
-#elif defined(__GNUC__)
-#define nop()               (__NOP())
-#endif
-
-#define FLASH_DECLARE(x)  const x
-#define FLASH_EXTERN(x) extern const x
-#define PGM_READ_BYTE(x) *(x)
-#define PGM_READ_WORD(x) *(x)
-#define MEMCPY_ENDIAN memcpy
-#define PGM_READ_BLOCK(dst, src, len) memcpy((dst), (src), (len))
+#    if defined(__ICCARM__)
+#        define nop() __no_operation()
+#    elif defined(__GNUC__)
+#        define nop() (__NOP())
+#    endif
+
+#    define FLASH_DECLARE(x) const x
+#    define FLASH_EXTERN(x) extern const x
+#    define PGM_READ_BYTE(x) *(x)
+#    define PGM_READ_WORD(x) *(x)
+#    define MEMCPY_ENDIAN memcpy
+#    define PGM_READ_BLOCK(dst, src, len) memcpy((dst), (src), (len))
 
 /*Defines the Flash Storage for the request and response of MAC*/
-#define CMD_ID_OCTET    (0)
+#    define CMD_ID_OCTET (0)
 
 /* Converting of values from CPU endian to little endian. */
-#define CPU_ENDIAN_TO_LE16(x)   (x)
-#define CPU_ENDIAN_TO_LE32(x)   (x)
-#define CPU_ENDIAN_TO_LE64(x)   (x)
+#    define CPU_ENDIAN_TO_LE16(x) (x)
+#    define CPU_ENDIAN_TO_LE32(x) (x)
+#    define CPU_ENDIAN_TO_LE64(x) (x)
 
 /* Converting of values from little endian to CPU endian. */
-#define LE16_TO_CPU_ENDIAN(x)   (x)
-#define LE32_TO_CPU_ENDIAN(x)   (x)
-#define LE64_TO_CPU_ENDIAN(x)   (x)
+#    define LE16_TO_CPU_ENDIAN(x) (x)
+#    define LE32_TO_CPU_ENDIAN(x) (x)
+#    define LE64_TO_CPU_ENDIAN(x) (x)
 
 /* Converting of constants from little endian to CPU endian. */
-#define CLE16_TO_CPU_ENDIAN(x)  (x)
-#define CLE32_TO_CPU_ENDIAN(x)  (x)
-#define CLE64_TO_CPU_ENDIAN(x)  (x)
+#    define CLE16_TO_CPU_ENDIAN(x) (x)
+#    define CLE32_TO_CPU_ENDIAN(x) (x)
+#    define CLE64_TO_CPU_ENDIAN(x) (x)
 
 /* Converting of constants from CPU endian to little endian. */
-#define CCPU_ENDIAN_TO_LE16(x)  (x)
-#define CCPU_ENDIAN_TO_LE32(x)  (x)
-#define CCPU_ENDIAN_TO_LE64(x)  (x)
+#    define CCPU_ENDIAN_TO_LE16(x) (x)
+#    define CCPU_ENDIAN_TO_LE32(x) (x)
+#    define CCPU_ENDIAN_TO_LE64(x) (x)
 
-#define ADDR_COPY_DST_SRC_16(dst, src)  ((dst) = (src))
-#define ADDR_COPY_DST_SRC_64(dst, src)  ((dst) = (src))
+#    define ADDR_COPY_DST_SRC_16(dst, src) ((dst) = (src))
+#    define ADDR_COPY_DST_SRC_64(dst, src) ((dst) = (src))
 
 /**
  * @brief Converts a 64-Bit value into  a 8 Byte array
@@ -1078,14 +990,12 @@ typedef double                  F64;  //!< 64-bit floating-point number.
  * @param[out] data Pointer to the 8 Byte array to be updated with 64-Bit value
  * @ingroup apiPalApi
  */
-static inline void convert_64_bit_to_byte_array(uint64_t value, uint8_t *data)
-{
+static inline void convert_64_bit_to_byte_array(uint64_t value, uint8_t *data) {
     uint8_t index = 0;
 
-    while (index < 8)
-    {
+    while (index < 8) {
         data[index++] = value & 0xFF;
-        value = value >> 8;
+        value         = value >> 8;
     }
 }
 
@@ -1096,22 +1006,19 @@ static inline void convert_64_bit_to_byte_array(uint64_t value, uint8_t *data)
  * @param[out] data Pointer to the 2 Byte array to be updated with 16-Bit value
  * @ingroup apiPalApi
  */
-static inline void convert_16_bit_to_byte_array(uint16_t value, uint8_t *data)
-{
+static inline void convert_16_bit_to_byte_array(uint16_t value, uint8_t *data) {
     data[0] = value & 0xFF;
     data[1] = (value >> 8) & 0xFF;
 }
 
 /* Converts a 16-Bit value into a 2 Byte array */
-static inline void convert_spec_16_bit_to_byte_array(uint16_t value, uint8_t *data)
-{
+static inline void convert_spec_16_bit_to_byte_array(uint16_t value, uint8_t *data) {
     data[0] = value & 0xFF;
     data[1] = (value >> 8) & 0xFF;
 }
 
 /* Converts a 16-Bit value into a 2 Byte array */
-static inline void convert_16_bit_to_byte_address(uint16_t value, uint8_t *data)
-{
+static inline void convert_16_bit_to_byte_address(uint16_t value, uint8_t *data) {
     data[0] = value & 0xFF;
     data[1] = (value >> 8) & 0xFF;
 }
@@ -1124,24 +1031,18 @@ static inline void convert_16_bit_to_byte_address(uint16_t value, uint8_t *data)
  * @return 16-Bit value
  * @ingroup apiPalApi
  */
-static inline uint16_t convert_byte_array_to_16_bit(uint8_t *data)
-{
-    return (data[0] | ((uint16_t)data[1] << 8));
-}
+static inline uint16_t convert_byte_array_to_16_bit(uint8_t *data) { return (data[0] | ((uint16_t)data[1] << 8)); }
 
 /* Converts a 4 Byte array into a 32-Bit value */
-static inline uint32_t convert_byte_array_to_32_bit(uint8_t *data)
-{
-    union
-    {
+static inline uint32_t convert_byte_array_to_32_bit(uint8_t *data) {
+    union {
         uint32_t u32;
-        uint8_t u8[4];
+        uint8_t  u8[4];
     } long_addr;
 
     uint8_t index;
 
-    for (index = 0; index < 4; index++)
-    {
+    for (index = 0; index < 4; index++) {
         long_addr.u8[index] = *data++;
     }
 
@@ -1156,18 +1057,15 @@ static inline uint32_t convert_byte_array_to_32_bit(uint8_t *data)
  * @return 64-Bit value
  * @ingroup apiPalApi
  */
-static inline uint64_t convert_byte_array_to_64_bit(uint8_t *data)
-{
-    union
-    {
+static inline uint64_t convert_byte_array_to_64_bit(uint8_t *data) {
+    union {
         uint64_t u64;
-        uint8_t u8[8];
+        uint8_t  u8[8];
     } long_addr;
 
     uint8_t index;
 
-    for (index = 0; index < 8; index++)
-    {
+    for (index = 0; index < 8; index++) {
         long_addr.u8[index] = *data++;
     }
 
diff --git a/tmk_core/protocol/arm_atsam/usb/conf_usb.h b/tmk_core/protocol/arm_atsam/usb/conf_usb.h
index c91caffe0..f23c2a80d 100644
--- a/tmk_core/protocol/arm_atsam/usb/conf_usb.h
+++ b/tmk_core/protocol/arm_atsam/usb/conf_usb.h
@@ -50,29 +50,29 @@
 #include "compiler.h"
 #include "udi_device_conf.h"
 
-#define  UDI_CDC_DEFAULT_RATE           115200
-#define  UDI_CDC_DEFAULT_STOPBITS       CDC_STOP_BITS_1
-#define  UDI_CDC_DEFAULT_PARITY         CDC_PAR_NONE
-#define  UDI_CDC_DEFAULT_DATABITS       8
+#define UDI_CDC_DEFAULT_RATE 115200
+#define UDI_CDC_DEFAULT_STOPBITS CDC_STOP_BITS_1
+#define UDI_CDC_DEFAULT_PARITY CDC_PAR_NONE
+#define UDI_CDC_DEFAULT_DATABITS 8
 
 //! Device definition (mandatory)
-#define  USB_DEVICE_VENDOR_ID           VENDOR_ID
-#define  USB_DEVICE_PRODUCT_ID          PRODUCT_ID
-#define  USB_DEVICE_VERSION             DEVICE_VER
-#define  USB_DEVICE_POWER               500 // Consumption on Vbus line (mA)
-#define  USB_DEVICE_ATTR                (USB_CONFIG_ATTR_REMOTE_WAKEUP|USB_CONFIG_ATTR_BUS_POWERED)
+#define USB_DEVICE_VENDOR_ID VENDOR_ID
+#define USB_DEVICE_PRODUCT_ID PRODUCT_ID
+#define USB_DEVICE_VERSION DEVICE_VER
+#define USB_DEVICE_POWER 500  // Consumption on Vbus line (mA)
+#define USB_DEVICE_ATTR (USB_CONFIG_ATTR_REMOTE_WAKEUP | USB_CONFIG_ATTR_BUS_POWERED)
 //                                      (USB_CONFIG_ATTR_REMOTE_WAKEUP|USB_CONFIG_ATTR_BUS_POWERED)
 //                                      (USB_CONFIG_ATTR_REMOTE_WAKEUP|USB_CONFIG_ATTR_SELF_POWERED)
 //                                      (USB_CONFIG_ATTR_SELF_POWERED)
 //                                      (USB_CONFIG_ATTR_BUS_POWERED)
 
 //! USB Device string definitions (Optional)
-#define  USB_DEVICE_MANUFACTURE_NAME      MANUFACTURER
-#define  USB_DEVICE_PRODUCT_NAME          PRODUCT
-#define  USB_DEVICE_SERIAL_NAME           SERIAL_NUM
+#define USB_DEVICE_MANUFACTURE_NAME MANUFACTURER
+#define USB_DEVICE_PRODUCT_NAME PRODUCT
+#define USB_DEVICE_SERIAL_NAME SERIAL_NUM
 
-//Comment out USB_DEVICE_SERIAL_USE_BOOTLOADER_SERIAL to prevent ROM lookup of factory programmed serial number
-#define  USB_DEVICE_SERIAL_USE_BOOTLOADER_SERIAL
+// Comment out USB_DEVICE_SERIAL_USE_BOOTLOADER_SERIAL to prevent ROM lookup of factory programmed serial number
+#define USB_DEVICE_SERIAL_USE_BOOTLOADER_SERIAL
 
 /**
  * Device speeds support
@@ -82,9 +82,9 @@
 //#define  USB_DEVICE_LOW_SPEED
 
 //! To authorize the High speed
-#if (UC3A3||UC3A4)
+#if (UC3A3 || UC3A4)
 //#define  USB_DEVICE_HS_SUPPORT
-#elif (SAM3XA||SAM3U)
+#elif (SAM3XA || SAM3U)
 //#define  USB_DEVICE_HS_SUPPORT
 #endif
 //@}
@@ -93,13 +93,13 @@
  * USB Device Callbacks definitions (Optional)
  * @{
  */
-#define  UDC_VBUS_EVENT(b_vbus_high)
-#define  UDC_SOF_EVENT()                  main_sof_action()
-#define  UDC_SUSPEND_EVENT()              main_suspend_action()
-#define  UDC_RESUME_EVENT()               main_resume_action()
+#define UDC_VBUS_EVENT(b_vbus_high)
+#define UDC_SOF_EVENT() main_sof_action()
+#define UDC_SUSPEND_EVENT() main_suspend_action()
+#define UDC_RESUME_EVENT() main_resume_action()
 //! Mandatory when USB_DEVICE_ATTR authorizes remote wakeup feature
-#define  UDC_REMOTEWAKEUP_ENABLE()        main_remotewakeup_enable()
-#define  UDC_REMOTEWAKEUP_DISABLE()       main_remotewakeup_disable()
+#define UDC_REMOTEWAKEUP_ENABLE() main_remotewakeup_enable()
+#define UDC_REMOTEWAKEUP_DISABLE() main_remotewakeup_disable()
 //! When a extra string descriptor must be supported
 //! other than manufacturer, product and serial string
 // #define  UDC_GET_EXTRA_STRING()
@@ -107,7 +107,6 @@
 
 //@}
 
-
 /**
  * USB Interface Configuration
  * @{
@@ -118,42 +117,40 @@
  */
 //! Interface callback definition
 #ifdef KBD
-#define  UDI_HID_KBD_ENABLE_EXT()       main_kbd_enable()
-#define  UDI_HID_KBD_DISABLE_EXT()      main_kbd_disable()
+#    define UDI_HID_KBD_ENABLE_EXT() main_kbd_enable()
+#    define UDI_HID_KBD_DISABLE_EXT() main_kbd_disable()
 //#define  UDI_HID_KBD_CHANGE_LED(value)  ui_kbd_led(value)
 #endif
 
 #ifdef NKRO
-#define  UDI_HID_NKRO_ENABLE_EXT()       main_nkro_enable()
-#define  UDI_HID_NKRO_DISABLE_EXT()      main_nkro_disable()
+#    define UDI_HID_NKRO_ENABLE_EXT() main_nkro_enable()
+#    define UDI_HID_NKRO_DISABLE_EXT() main_nkro_disable()
 //#define  UDI_HID_NKRO_CHANGE_LED(value)   ui_kbd_led(value)
 #endif
 
 #ifdef EXK
-#define  UDI_HID_EXK_ENABLE_EXT()       main_exk_enable()
-#define  UDI_HID_EXK_DISABLE_EXT()      main_exk_disable()
+#    define UDI_HID_EXK_ENABLE_EXT() main_exk_enable()
+#    define UDI_HID_EXK_DISABLE_EXT() main_exk_disable()
 #endif
 
 #ifdef CON
-#define  UDI_HID_CON_ENABLE_EXT()       main_con_enable()
-#define  UDI_HID_CON_DISABLE_EXT()      main_con_disable()
+#    define UDI_HID_CON_ENABLE_EXT() main_con_enable()
+#    define UDI_HID_CON_DISABLE_EXT() main_con_disable()
 #endif
 
 #ifdef MOU
-#define  UDI_HID_MOU_ENABLE_EXT()       main_mou_enable()
-#define  UDI_HID_MOU_DISABLE_EXT()      main_mou_disable()
+#    define UDI_HID_MOU_ENABLE_EXT() main_mou_enable()
+#    define UDI_HID_MOU_DISABLE_EXT() main_mou_disable()
 #endif
 
 #ifdef RAW
-#define  UDI_HID_RAW_ENABLE_EXT()       main_raw_enable()
-#define  UDI_HID_RAW_DISABLE_EXT()      main_raw_disable()
+#    define UDI_HID_RAW_ENABLE_EXT() main_raw_enable()
+#    define UDI_HID_RAW_DISABLE_EXT() main_raw_disable()
 #endif
 
-
 //@}
 //@}
 
-
 /**
  * USB Device Driver Configuration
  * @{
@@ -165,4 +162,4 @@
 #include "usb_main.h"
 #include "ui.h"
 
-#endif // _CONF_USB_H_
+#endif  // _CONF_USB_H_
diff --git a/tmk_core/protocol/arm_atsam/usb/main_usb.c b/tmk_core/protocol/arm_atsam/usb/main_usb.c
index 0f676ab63..82ab123fd 100644
--- a/tmk_core/protocol/arm_atsam/usb/main_usb.c
+++ b/tmk_core/protocol/arm_atsam/usb/main_usb.c
@@ -21,112 +21,72 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 uint8_t keyboard_protocol = 1;
 
-void main_suspend_action(void)
-{
-    ui_powerdown();
-}
+void main_suspend_action(void) { ui_powerdown(); }
 
-void main_resume_action(void)
-{
-    ui_wakeup();
-}
+void main_resume_action(void) { ui_wakeup(); }
 
-void main_sof_action(void)
-{
-    ui_process(udd_get_frame_number());
-}
+void main_sof_action(void) { ui_process(udd_get_frame_number()); }
 
-void main_remotewakeup_enable(void)
-{
-    ui_wakeup_enable();
-}
+void main_remotewakeup_enable(void) { ui_wakeup_enable(); }
 
-void main_remotewakeup_disable(void)
-{
-    ui_wakeup_disable();
-}
+void main_remotewakeup_disable(void) { ui_wakeup_disable(); }
 
 #ifdef KBD
 volatile bool main_b_kbd_enable = false;
-bool main_kbd_enable(void)
-{
+bool          main_kbd_enable(void) {
     main_b_kbd_enable = true;
     return true;
 }
 
-void main_kbd_disable(void)
-{
-    main_b_kbd_enable = false;
-}
+void main_kbd_disable(void) { main_b_kbd_enable = false; }
 #endif
 
 #ifdef NKRO
 volatile bool main_b_nkro_enable = false;
-bool main_nkro_enable(void)
-{
+bool          main_nkro_enable(void) {
     main_b_nkro_enable = true;
     return true;
 }
 
-void main_nkro_disable(void)
-{
-    main_b_nkro_enable = false;
-}
+void main_nkro_disable(void) { main_b_nkro_enable = false; }
 #endif
 
 #ifdef EXK
 volatile bool main_b_exk_enable = false;
-bool main_exk_enable(void)
-{
+bool          main_exk_enable(void) {
     main_b_exk_enable = true;
     return true;
 }
 
-void main_exk_disable(void)
-{
-    main_b_exk_enable = false;
-}
+void main_exk_disable(void) { main_b_exk_enable = false; }
 #endif
 
 #ifdef CON
 volatile bool main_b_con_enable = false;
-bool main_con_enable(void)
-{
+bool          main_con_enable(void) {
     main_b_con_enable = true;
     return true;
 }
 
-void main_con_disable(void)
-{
-    main_b_con_enable = false;
-}
+void main_con_disable(void) { main_b_con_enable = false; }
 #endif
 
 #ifdef MOU
 volatile bool main_b_mou_enable = false;
-bool main_mou_enable(void)
-{
+bool          main_mou_enable(void) {
     main_b_mou_enable = true;
     return true;
 }
 
-void main_mou_disable(void)
-{
-    main_b_mou_enable = false;
-}
+void main_mou_disable(void) { main_b_mou_enable = false; }
 #endif
 
 #ifdef RAW
 volatile bool main_b_raw_enable = false;
-bool main_raw_enable(void)
-{
+bool          main_raw_enable(void) {
     main_b_raw_enable = true;
     return true;
 }
 
-void main_raw_disable(void)
-{
-    main_b_raw_enable = false;
-}
+void main_raw_disable(void) { main_b_raw_enable = false; }
 #endif
-
diff --git a/tmk_core/protocol/arm_atsam/usb/status_codes.h b/tmk_core/protocol/arm_atsam/usb/status_codes.h
index f56d2faed..a7a1230be 100644
--- a/tmk_core/protocol/arm_atsam/usb/status_codes.h
+++ b/tmk_core/protocol/arm_atsam/usb/status_codes.h
@@ -61,18 +61,18 @@
  */
 
 /** Mask to retrieve the error category of a status code. */
-#define STATUS_CATEGORY_MASK  0xF0
+#define STATUS_CATEGORY_MASK 0xF0
 
 /** Mask to retrieve the error code within the category of a status code. */
-#define STATUS_ERROR_MASK     0x0F
+#define STATUS_ERROR_MASK 0x0F
 
 /** Status code error categories. */
 enum status_categories {
-    STATUS_CATEGORY_OK                = 0x00,
-    STATUS_CATEGORY_COMMON            = 0x10,
-    STATUS_CATEGORY_ANALOG            = 0x30,
-    STATUS_CATEGORY_COM               = 0x40,
-    STATUS_CATEGORY_IO                = 0x50,
+    STATUS_CATEGORY_OK     = 0x00,
+    STATUS_CATEGORY_COMMON = 0x10,
+    STATUS_CATEGORY_ANALOG = 0x30,
+    STATUS_CATEGORY_COM    = 0x40,
+    STATUS_CATEGORY_IO     = 0x50,
 };
 
 /**
@@ -85,37 +85,37 @@ enum status_categories {
  * at the same time.
  */
 enum status_code {
-    STATUS_OK                         = STATUS_CATEGORY_OK     | 0x00,
-    STATUS_VALID_DATA                 = STATUS_CATEGORY_OK     | 0x01,
-    STATUS_NO_CHANGE                  = STATUS_CATEGORY_OK     | 0x02,
-    STATUS_ABORTED                    = STATUS_CATEGORY_OK     | 0x04,
-    STATUS_BUSY                       = STATUS_CATEGORY_OK     | 0x05,
-    STATUS_SUSPEND                    = STATUS_CATEGORY_OK     | 0x06,
-
-    STATUS_ERR_IO                     = STATUS_CATEGORY_COMMON | 0x00,
-    STATUS_ERR_REQ_FLUSHED            = STATUS_CATEGORY_COMMON | 0x01,
-    STATUS_ERR_TIMEOUT                = STATUS_CATEGORY_COMMON | 0x02,
-    STATUS_ERR_BAD_DATA               = STATUS_CATEGORY_COMMON | 0x03,
-    STATUS_ERR_NOT_FOUND              = STATUS_CATEGORY_COMMON | 0x04,
-    STATUS_ERR_UNSUPPORTED_DEV        = STATUS_CATEGORY_COMMON | 0x05,
-    STATUS_ERR_NO_MEMORY              = STATUS_CATEGORY_COMMON | 0x06,
-    STATUS_ERR_INVALID_ARG            = STATUS_CATEGORY_COMMON | 0x07,
-    STATUS_ERR_BAD_ADDRESS            = STATUS_CATEGORY_COMMON | 0x08,
-    STATUS_ERR_BAD_FORMAT             = STATUS_CATEGORY_COMMON | 0x0A,
-    STATUS_ERR_BAD_FRQ                = STATUS_CATEGORY_COMMON | 0x0B,
-    STATUS_ERR_DENIED                 = STATUS_CATEGORY_COMMON | 0x0c,
-    STATUS_ERR_ALREADY_INITIALIZED    = STATUS_CATEGORY_COMMON | 0x0d,
-    STATUS_ERR_OVERFLOW               = STATUS_CATEGORY_COMMON | 0x0e,
-    STATUS_ERR_NOT_INITIALIZED        = STATUS_CATEGORY_COMMON | 0x0f,
+    STATUS_OK         = STATUS_CATEGORY_OK | 0x00,
+    STATUS_VALID_DATA = STATUS_CATEGORY_OK | 0x01,
+    STATUS_NO_CHANGE  = STATUS_CATEGORY_OK | 0x02,
+    STATUS_ABORTED    = STATUS_CATEGORY_OK | 0x04,
+    STATUS_BUSY       = STATUS_CATEGORY_OK | 0x05,
+    STATUS_SUSPEND    = STATUS_CATEGORY_OK | 0x06,
+
+    STATUS_ERR_IO                  = STATUS_CATEGORY_COMMON | 0x00,
+    STATUS_ERR_REQ_FLUSHED         = STATUS_CATEGORY_COMMON | 0x01,
+    STATUS_ERR_TIMEOUT             = STATUS_CATEGORY_COMMON | 0x02,
+    STATUS_ERR_BAD_DATA            = STATUS_CATEGORY_COMMON | 0x03,
+    STATUS_ERR_NOT_FOUND           = STATUS_CATEGORY_COMMON | 0x04,
+    STATUS_ERR_UNSUPPORTED_DEV     = STATUS_CATEGORY_COMMON | 0x05,
+    STATUS_ERR_NO_MEMORY           = STATUS_CATEGORY_COMMON | 0x06,
+    STATUS_ERR_INVALID_ARG         = STATUS_CATEGORY_COMMON | 0x07,
+    STATUS_ERR_BAD_ADDRESS         = STATUS_CATEGORY_COMMON | 0x08,
+    STATUS_ERR_BAD_FORMAT          = STATUS_CATEGORY_COMMON | 0x0A,
+    STATUS_ERR_BAD_FRQ             = STATUS_CATEGORY_COMMON | 0x0B,
+    STATUS_ERR_DENIED              = STATUS_CATEGORY_COMMON | 0x0c,
+    STATUS_ERR_ALREADY_INITIALIZED = STATUS_CATEGORY_COMMON | 0x0d,
+    STATUS_ERR_OVERFLOW            = STATUS_CATEGORY_COMMON | 0x0e,
+    STATUS_ERR_NOT_INITIALIZED     = STATUS_CATEGORY_COMMON | 0x0f,
 
     STATUS_ERR_SAMPLERATE_UNAVAILABLE = STATUS_CATEGORY_ANALOG | 0x00,
     STATUS_ERR_RESOLUTION_UNAVAILABLE = STATUS_CATEGORY_ANALOG | 0x01,
 
-    STATUS_ERR_BAUDRATE_UNAVAILABLE   = STATUS_CATEGORY_COM    | 0x00,
-    STATUS_ERR_PACKET_COLLISION       = STATUS_CATEGORY_COM    | 0x01,
-    STATUS_ERR_PROTOCOL               = STATUS_CATEGORY_COM    | 0x02,
+    STATUS_ERR_BAUDRATE_UNAVAILABLE = STATUS_CATEGORY_COM | 0x00,
+    STATUS_ERR_PACKET_COLLISION     = STATUS_CATEGORY_COM | 0x01,
+    STATUS_ERR_PROTOCOL             = STATUS_CATEGORY_COM | 0x02,
 
-    STATUS_ERR_PIN_MUX_INVALID        = STATUS_CATEGORY_IO     | 0x00,
+    STATUS_ERR_PIN_MUX_INVALID = STATUS_CATEGORY_IO | 0x00,
 };
 typedef enum status_code status_code_genare_t;
 
@@ -123,21 +123,21 @@ typedef enum status_code status_code_genare_t;
   Status codes used by MAC stack.
  */
 enum status_code_wireless {
-    //STATUS_OK               =  0, //!< Success
-    ERR_IO_ERROR            =  -1, //!< I/O error
-    ERR_FLUSHED             =  -2, //!< Request flushed from queue
-    ERR_TIMEOUT             =  -3, //!< Operation timed out
-    ERR_BAD_DATA            =  -4, //!< Data integrity check failed
-    ERR_PROTOCOL            =  -5, //!< Protocol error
-    ERR_UNSUPPORTED_DEV     =  -6, //!< Unsupported device
-    ERR_NO_MEMORY           =  -7, //!< Insufficient memory
-    ERR_INVALID_ARG         =  -8, //!< Invalid argument
-    ERR_BAD_ADDRESS         =  -9, //!< Bad address
-    ERR_BUSY                =  -10, //!< Resource is busy
-    ERR_BAD_FORMAT          =  -11, //!< Data format not recognized
-    ERR_NO_TIMER            =  -12, //!< No timer available
-    ERR_TIMER_ALREADY_RUNNING   =  -13, //!< Timer already running
-    ERR_TIMER_NOT_RUNNING   =  -14, //!< Timer not running
+    // STATUS_OK               =  0, //!< Success
+    ERR_IO_ERROR              = -1,   //!< I/O error
+    ERR_FLUSHED               = -2,   //!< Request flushed from queue
+    ERR_TIMEOUT               = -3,   //!< Operation timed out
+    ERR_BAD_DATA              = -4,   //!< Data integrity check failed
+    ERR_PROTOCOL              = -5,   //!< Protocol error
+    ERR_UNSUPPORTED_DEV       = -6,   //!< Unsupported device
+    ERR_NO_MEMORY             = -7,   //!< Insufficient memory
+    ERR_INVALID_ARG           = -8,   //!< Invalid argument
+    ERR_BAD_ADDRESS           = -9,   //!< Bad address
+    ERR_BUSY                  = -10,  //!< Resource is busy
+    ERR_BAD_FORMAT            = -11,  //!< Data format not recognized
+    ERR_NO_TIMER              = -12,  //!< No timer available
+    ERR_TIMER_ALREADY_RUNNING = -13,  //!< Timer already running
+    ERR_TIMER_NOT_RUNNING     = -14,  //!< Timer not running
 
     /**
      * \brief Operation in progress
@@ -148,7 +148,7 @@ enum status_code_wireless {
      * \note Drivers should never return this status code to any
      * callers. It is strictly for internal use.
      */
-    OPERATION_IN_PROGRESS   = -128,
+    OPERATION_IN_PROGRESS = -128,
 };
 
 typedef enum status_code_wireless status_code_t;
diff --git a/tmk_core/protocol/arm_atsam/usb/udc.c b/tmk_core/protocol/arm_atsam/usb/udc.c
index 12444d305..d04e9b7b2 100644
--- a/tmk_core/protocol/arm_atsam/usb/udc.c
+++ b/tmk_core/protocol/arm_atsam/usb/udc.c
@@ -83,7 +83,6 @@ static usb_iface_desc_t UDC_DESC_STORAGE *udc_ptr_iface;
 
 //! @}
 
-
 //! \name Internal structure to store the USB device main strings
 //! @{
 
@@ -91,11 +90,7 @@ static usb_iface_desc_t UDC_DESC_STORAGE *udc_ptr_iface;
  * \brief Language ID of USB device (US ID by default)
  */
 COMPILER_WORD_ALIGNED
-static UDC_DESC_STORAGE usb_str_lgid_desc_t udc_string_desc_languageid = {
-    .desc.bLength = sizeof(usb_str_lgid_desc_t),
-    .desc.bDescriptorType = USB_DT_STRING,
-    .string = {LE16(USB_LANGID_EN_US)}
-};
+static UDC_DESC_STORAGE usb_str_lgid_desc_t udc_string_desc_languageid = {.desc.bLength = sizeof(usb_str_lgid_desc_t), .desc.bDescriptorType = USB_DT_STRING, .string = {LE16(USB_LANGID_EN_US)}};
 
 /**
  * \brief USB device manufacture name storage
@@ -104,9 +99,9 @@ static UDC_DESC_STORAGE usb_str_lgid_desc_t udc_string_desc_languageid = {
  */
 #ifdef USB_DEVICE_MANUFACTURE_NAME
 static uint8_t udc_string_manufacturer_name[] = USB_DEVICE_MANUFACTURE_NAME;
-#define USB_DEVICE_MANUFACTURE_NAME_SIZE (sizeof(udc_string_manufacturer_name)-1)
+#    define USB_DEVICE_MANUFACTURE_NAME_SIZE (sizeof(udc_string_manufacturer_name) - 1)
 #else
-#define USB_DEVICE_MANUFACTURE_NAME_SIZE 0
+#    define USB_DEVICE_MANUFACTURE_NAME_SIZE 0
 #endif
 
 /**
@@ -116,37 +111,34 @@ static uint8_t udc_string_manufacturer_name[] = USB_DEVICE_MANUFACTURE_NAME;
  */
 #ifdef USB_DEVICE_PRODUCT_NAME
 static uint8_t udc_string_product_name[] = USB_DEVICE_PRODUCT_NAME;
-#define USB_DEVICE_PRODUCT_NAME_SIZE (sizeof(udc_string_product_name)-1)
+#    define USB_DEVICE_PRODUCT_NAME_SIZE (sizeof(udc_string_product_name) - 1)
 #else
-#define USB_DEVICE_PRODUCT_NAME_SIZE 0
+#    define USB_DEVICE_PRODUCT_NAME_SIZE 0
 #endif
 
 #if defined USB_DEVICE_SERIAL_NAME
-#define USB_DEVICE_SERIAL_NAME_SIZE (sizeof(USB_DEVICE_SERIAL_NAME)-1)
+#    define USB_DEVICE_SERIAL_NAME_SIZE (sizeof(USB_DEVICE_SERIAL_NAME) - 1)
 #else
-#define USB_DEVICE_SERIAL_NAME_SIZE 0
+#    define USB_DEVICE_SERIAL_NAME_SIZE 0
 #endif
 
-uint8_t usb_device_serial_name_size = 0;
+uint8_t     usb_device_serial_name_size = 0;
 #if defined USB_DEVICE_SERIAL_USE_BOOTLOADER_SERIAL
-uint8_t bootloader_serial_number[BOOTLOADER_SERIAL_MAX_SIZE+1]="";
+uint8_t     bootloader_serial_number[BOOTLOADER_SERIAL_MAX_SIZE + 1] = "";
 #endif
-static const uint8_t *udc_get_string_serial_name(void)
-{
-#if defined USB_DEVICE_SERIAL_USE_BOOTLOADER_SERIAL
-    uint32_t serial_ptrloc = (uint32_t)&_srom - 4;
-    uint32_t serial_address = *(uint32_t *)serial_ptrloc; //Address of bootloader's serial number if available
+static const uint8_t *udc_get_string_serial_name(void) {
+#if defined           USB_DEVICE_SERIAL_USE_BOOTLOADER_SERIAL
+    uint32_t serial_ptrloc  = (uint32_t)&_srom - 4;
+    uint32_t serial_address = *(uint32_t *)serial_ptrloc;  // Address of bootloader's serial number if available
 
-    if (serial_address != 0xFFFFFFFF && serial_address < serial_ptrloc) //Check for factory programmed serial address
+    if (serial_address != 0xFFFFFFFF && serial_address < serial_ptrloc)  // Check for factory programmed serial address
     {
-        if ((serial_address & 0xFF) % 4 == 0) //Check alignment
+        if ((serial_address & 0xFF) % 4 == 0)  // Check alignment
         {
-            uint16_t *serial_use = (uint16_t *)(serial_address); //Point to address of string in rom
-            uint8_t serial_length = 0;
+            uint16_t *serial_use    = (uint16_t *)(serial_address);  // Point to address of string in rom
+            uint8_t   serial_length = 0;
 
-            while ((*(serial_use + serial_length) > 32 && *(serial_use + serial_length) < 127) &&
-                   serial_length < BOOTLOADER_SERIAL_MAX_SIZE)
-            {
+            while ((*(serial_use + serial_length) > 32 && *(serial_use + serial_length) < 127) && serial_length < BOOTLOADER_SERIAL_MAX_SIZE) {
                 bootloader_serial_number[serial_length] = *(serial_use + serial_length) & 0xFF;
                 serial_length++;
             }
@@ -154,7 +146,7 @@ static const uint8_t *udc_get_string_serial_name(void)
 
             usb_device_serial_name_size = serial_length;
 
-            return bootloader_serial_number; //Use serial programmed into bootloader rom
+            return bootloader_serial_number;  // Use serial programmed into bootloader rom
         }
     }
 #endif
@@ -162,9 +154,9 @@ static const uint8_t *udc_get_string_serial_name(void)
     usb_device_serial_name_size = USB_DEVICE_SERIAL_NAME_SIZE;
 
 #if defined USB_DEVICE_SERIAL_NAME
-    return (const uint8_t *)USB_DEVICE_SERIAL_NAME; //Use serial supplied by keyboard's config.h
+    return (const uint8_t *)USB_DEVICE_SERIAL_NAME;  // Use serial supplied by keyboard's config.h
 #else
-    return 0; //No serial supplied
+    return 0;  // No serial supplied
 #endif
 }
 
@@ -173,38 +165,26 @@ static const uint8_t *udc_get_string_serial_name(void)
  * Structure used to transfer ASCII strings to USB String descriptor structure.
  */
 #ifndef BOOTLOADER_SERIAL_MAX_SIZE
-#define BOOTLOADER_SERIAL_MAX_SIZE 0
-#endif //BOOTLOADER_SERIAL_MAX_SIZE
+#    define BOOTLOADER_SERIAL_MAX_SIZE 0
+#endif  // BOOTLOADER_SERIAL_MAX_SIZE
 struct udc_string_desc_t {
     usb_str_desc_t header;
-    le16_t string[Max(Max(Max(USB_DEVICE_MANUFACTURE_NAME_SIZE, \
-                  USB_DEVICE_PRODUCT_NAME_SIZE), USB_DEVICE_SERIAL_NAME_SIZE), \
-                  BOOTLOADER_SERIAL_MAX_SIZE)];
+    le16_t         string[Max(Max(Max(USB_DEVICE_MANUFACTURE_NAME_SIZE, USB_DEVICE_PRODUCT_NAME_SIZE), USB_DEVICE_SERIAL_NAME_SIZE), BOOTLOADER_SERIAL_MAX_SIZE)];
 };
 COMPILER_WORD_ALIGNED
-static UDC_DESC_STORAGE struct udc_string_desc_t udc_string_desc = {
-    .header.bDescriptorType = USB_DT_STRING
-};
+static UDC_DESC_STORAGE struct udc_string_desc_t udc_string_desc = {.header.bDescriptorType = USB_DT_STRING};
 //! @}
 
-usb_iface_desc_t UDC_DESC_STORAGE *udc_get_interface_desc(void)
-{
-    return udc_ptr_iface;
-}
+usb_iface_desc_t UDC_DESC_STORAGE *udc_get_interface_desc(void) { return udc_ptr_iface; }
 
 /**
  * \brief Returns a value to check the end of USB Configuration descriptor
  *
  * \return address after the last byte of USB Configuration descriptor
  */
-static usb_conf_desc_t UDC_DESC_STORAGE *udc_get_eof_conf(void)
-{
-    return (UDC_DESC_STORAGE usb_conf_desc_t *) ((uint8_t *)
-            udc_ptr_conf->desc +
-            le16_to_cpu(udc_ptr_conf->desc->wTotalLength));
-}
+static usb_conf_desc_t UDC_DESC_STORAGE *udc_get_eof_conf(void) { return (UDC_DESC_STORAGE usb_conf_desc_t *)((uint8_t *)udc_ptr_conf->desc + le16_to_cpu(udc_ptr_conf->desc->wTotalLength)); }
 
-#if (0!=USB_DEVICE_MAX_EP)
+#if (0 != USB_DEVICE_MAX_EP)
 /**
  * \brief Search specific descriptor in global interface descriptor
  *
@@ -215,30 +195,26 @@ static usb_conf_desc_t UDC_DESC_STORAGE *udc_get_eof_conf(void)
  * \return address of specific descriptor found
  * \return NULL if it is the end of global interface descriptor
  */
-static usb_conf_desc_t UDC_DESC_STORAGE *udc_next_desc_in_iface(usb_conf_desc_t
-        UDC_DESC_STORAGE * desc, uint8_t desc_id)
-{
+static usb_conf_desc_t UDC_DESC_STORAGE *udc_next_desc_in_iface(usb_conf_desc_t UDC_DESC_STORAGE *desc, uint8_t desc_id) {
     usb_conf_desc_t UDC_DESC_STORAGE *ptr_eof_desc;
 
     ptr_eof_desc = udc_get_eof_conf();
     // Go to next descriptor
-    desc = (UDC_DESC_STORAGE usb_conf_desc_t *) ((uint8_t *) desc +
-            desc->bLength);
+    desc = (UDC_DESC_STORAGE usb_conf_desc_t *)((uint8_t *)desc + desc->bLength);
     // Check the end of configuration descriptor
     while (ptr_eof_desc > desc) {
         // If new interface descriptor is found,
         // then it is the end of the current global interface descriptor
         if (USB_DT_INTERFACE == desc->bDescriptorType) {
-            break; // End of global interface descriptor
+            break;  // End of global interface descriptor
         }
         if (desc_id == desc->bDescriptorType) {
-            return desc; // Specific descriptor found
+            return desc;  // Specific descriptor found
         }
         // Go to next descriptor
-        desc = (UDC_DESC_STORAGE usb_conf_desc_t *) ((uint8_t *) desc +
-                desc->bLength);
+        desc = (UDC_DESC_STORAGE usb_conf_desc_t *)((uint8_t *)desc + desc->bLength);
     }
-    return NULL; // No specific descriptor found
+    return NULL;  // No specific descriptor found
 }
 #endif
 
@@ -251,8 +227,7 @@ static usb_conf_desc_t UDC_DESC_STORAGE *udc_next_desc_in_iface(usb_conf_desc_t
  *
  * \return 1 if found or 0 if not found
  */
-static bool udc_update_iface_desc(uint8_t iface_num, uint8_t setting_num)
-{
+static bool udc_update_iface_desc(uint8_t iface_num, uint8_t setting_num) {
     usb_conf_desc_t UDC_DESC_STORAGE *ptr_end_desc;
 
     if (0 == udc_num_configuration) {
@@ -264,28 +239,22 @@ static bool udc_update_iface_desc(uint8_t iface_num, uint8_t setting_num)
     }
 
     // Start at the beginning of configuration descriptor
-    udc_ptr_iface = (UDC_DESC_STORAGE usb_iface_desc_t *)
-            udc_ptr_conf->desc;
+    udc_ptr_iface = (UDC_DESC_STORAGE usb_iface_desc_t *)udc_ptr_conf->desc;
 
     // Check the end of configuration descriptor
     ptr_end_desc = udc_get_eof_conf();
-    while (ptr_end_desc >
-            (UDC_DESC_STORAGE usb_conf_desc_t *) udc_ptr_iface) {
+    while (ptr_end_desc > (UDC_DESC_STORAGE usb_conf_desc_t *)udc_ptr_iface) {
         if (USB_DT_INTERFACE == udc_ptr_iface->bDescriptorType) {
             // A interface descriptor is found
             // Check interface and alternate setting number
-            if ((iface_num == udc_ptr_iface->bInterfaceNumber) &&
-                    (setting_num ==
-                    udc_ptr_iface->bAlternateSetting)) {
-                return true; // Interface found
+            if ((iface_num == udc_ptr_iface->bInterfaceNumber) && (setting_num == udc_ptr_iface->bAlternateSetting)) {
+                return true;  // Interface found
             }
         }
         // Go to next descriptor
-        udc_ptr_iface = (UDC_DESC_STORAGE usb_iface_desc_t *) (
-                (uint8_t *) udc_ptr_iface +
-                udc_ptr_iface->bLength);
+        udc_ptr_iface = (UDC_DESC_STORAGE usb_iface_desc_t *)((uint8_t *)udc_ptr_iface + udc_ptr_iface->bLength);
     }
-    return false; // Interface not found
+    return false;  // Interface not found
 }
 
 /**
@@ -296,8 +265,7 @@ static bool udc_update_iface_desc(uint8_t iface_num, uint8_t setting_num)
  *
  * \return 1 if it is done or 0 if interface is not found
  */
-static bool udc_iface_disable(uint8_t iface_num)
-{
+static bool udc_iface_disable(uint8_t iface_num) {
     udi_api_t UDC_DESC_STORAGE *udi_api;
 
     // Select first alternate setting of the interface
@@ -309,7 +277,7 @@ static bool udc_iface_disable(uint8_t iface_num)
     // Select the interface with the current alternate setting
     udi_api = udc_ptr_conf->udi_apis[iface_num];
 
-#if (0!=USB_DEVICE_MAX_EP)
+#if (0 != USB_DEVICE_MAX_EP)
     if (!udc_update_iface_desc(iface_num, udi_api->getsetting())) {
         return false;
     }
@@ -317,13 +285,10 @@ static bool udc_iface_disable(uint8_t iface_num)
     // Start at the beginning of interface descriptor
     {
         usb_ep_desc_t UDC_DESC_STORAGE *ep_desc;
-        ep_desc = (UDC_DESC_STORAGE usb_ep_desc_t *) udc_ptr_iface;
+        ep_desc = (UDC_DESC_STORAGE usb_ep_desc_t *)udc_ptr_iface;
         while (1) {
             // Search Endpoint descriptor included in global interface descriptor
-            ep_desc = (UDC_DESC_STORAGE usb_ep_desc_t *)
-                    udc_next_desc_in_iface((UDC_DESC_STORAGE
-                    usb_conf_desc_t *)
-                    ep_desc, USB_DT_ENDPOINT);
+            ep_desc = (UDC_DESC_STORAGE usb_ep_desc_t *)udc_next_desc_in_iface((UDC_DESC_STORAGE usb_conf_desc_t *)ep_desc, USB_DT_ENDPOINT);
             if (NULL == ep_desc) {
                 break;
             }
@@ -348,31 +313,23 @@ static bool udc_iface_disable(uint8_t iface_num)
  *
  * \return 1 if it is done or 0 if interface is not found
  */
-static bool udc_iface_enable(uint8_t iface_num, uint8_t setting_num)
-{
+static bool udc_iface_enable(uint8_t iface_num, uint8_t setting_num) {
     // Select the interface descriptor
     if (!udc_update_iface_desc(iface_num, setting_num)) {
         return false;
     }
 
-#if (0!=USB_DEVICE_MAX_EP)
+#if (0 != USB_DEVICE_MAX_EP)
     usb_ep_desc_t UDC_DESC_STORAGE *ep_desc;
 
     // Start at the beginning of the global interface descriptor
-    ep_desc = (UDC_DESC_STORAGE usb_ep_desc_t *) udc_ptr_iface;
+    ep_desc = (UDC_DESC_STORAGE usb_ep_desc_t *)udc_ptr_iface;
     while (1) {
         // Search Endpoint descriptor included in the global interface descriptor
-        ep_desc = (UDC_DESC_STORAGE usb_ep_desc_t *)
-                udc_next_desc_in_iface((UDC_DESC_STORAGE
-                        usb_conf_desc_t *) ep_desc,
-                USB_DT_ENDPOINT);
-        if (NULL == ep_desc)
-            break;
+        ep_desc = (UDC_DESC_STORAGE usb_ep_desc_t *)udc_next_desc_in_iface((UDC_DESC_STORAGE usb_conf_desc_t *)ep_desc, USB_DT_ENDPOINT);
+        if (NULL == ep_desc) break;
         // Alloc the endpoint used by the interface
-        if (!udd_ep_alloc(ep_desc->bEndpointAddress,
-                ep_desc->bmAttributes,
-                le16_to_cpu
-                (ep_desc->wMaxPacketSize))) {
+        if (!udd_ep_alloc(ep_desc->bEndpointAddress, ep_desc->bmAttributes, le16_to_cpu(ep_desc->wMaxPacketSize))) {
             return false;
         }
     }
@@ -383,15 +340,11 @@ static bool udc_iface_enable(uint8_t iface_num, uint8_t setting_num)
 
 /*! \brief Start the USB Device stack
  */
-void udc_start(void)
-{
-    udd_enable();
-}
+void udc_start(void) { udd_enable(); }
 
 /*! \brief Stop the USB Device stack
  */
-void udc_stop(void)
-{
+void udc_stop(void) {
     udd_disable();
     udc_reset();
 }
@@ -400,20 +353,16 @@ void udc_stop(void)
  * \brief Reset the current configuration of the USB device,
  * This routines can be called by UDD when a RESET on the USB line occurs.
  */
-void udc_reset(void)
-{
+void udc_reset(void) {
     uint8_t iface_num;
 
     if (udc_num_configuration) {
-        for (iface_num = 0;
-                iface_num < udc_ptr_conf->desc->bNumInterfaces;
-                iface_num++) {
+        for (iface_num = 0; iface_num < udc_ptr_conf->desc->bNumInterfaces; iface_num++) {
             udc_iface_disable(iface_num);
         }
     }
     udc_num_configuration = 0;
-#if (USB_CONFIG_ATTR_REMOTE_WAKEUP \
-    == (USB_DEVICE_ATTR & USB_CONFIG_ATTR_REMOTE_WAKEUP))
+#if (USB_CONFIG_ATTR_REMOTE_WAKEUP == (USB_DEVICE_ATTR & USB_CONFIG_ATTR_REMOTE_WAKEUP))
     if (CPU_TO_LE16(USB_DEV_STATUS_REMOTEWAKEUP) & udc_device_status) {
         // Remote wakeup is enabled then disable it
         UDC_REMOTEWAKEUP_DISABLE();
@@ -421,20 +370,17 @@ void udc_reset(void)
 #endif
     udc_device_status =
 #if (USB_DEVICE_ATTR & USB_CONFIG_ATTR_SELF_POWERED)
-            CPU_TO_LE16(USB_DEV_STATUS_SELF_POWERED);
+        CPU_TO_LE16(USB_DEV_STATUS_SELF_POWERED);
 #else
-            CPU_TO_LE16(USB_DEV_STATUS_BUS_POWERED);
+        CPU_TO_LE16(USB_DEV_STATUS_BUS_POWERED);
 #endif
 }
 
-void udc_sof_notify(void)
-{
+void udc_sof_notify(void) {
     uint8_t iface_num;
 
     if (udc_num_configuration) {
-        for (iface_num = 0;
-                iface_num < udc_ptr_conf->desc->bNumInterfaces;
-                iface_num++) {
+        for (iface_num = 0; iface_num < udc_ptr_conf->desc->bNumInterfaces; iface_num++) {
             if (udc_ptr_conf->udi_apis[iface_num]->sof_notify != NULL) {
                 udc_ptr_conf->udi_apis[iface_num]->sof_notify();
             }
@@ -447,36 +393,31 @@ void udc_sof_notify(void)
  *
  * \return true if success
  */
-static bool udc_req_std_dev_get_status(void)
-{
+static bool udc_req_std_dev_get_status(void) {
     if (udd_g_ctrlreq.req.wLength != sizeof(udc_device_status)) {
         return false;
     }
 
-    udd_set_setup_payload( (uint8_t *) & udc_device_status,
-            sizeof(udc_device_status));
+    udd_set_setup_payload((uint8_t *)&udc_device_status, sizeof(udc_device_status));
     return true;
 }
 
-#if (0!=USB_DEVICE_MAX_EP)
+#if (0 != USB_DEVICE_MAX_EP)
 /**
  * \brief Standard endpoint request to get endpoint status
  *
  * \return true if success
  */
-static bool udc_req_std_ep_get_status(void)
-{
+static bool udc_req_std_ep_get_status(void) {
     static le16_t udc_ep_status;
 
     if (udd_g_ctrlreq.req.wLength != sizeof(udc_ep_status)) {
         return false;
     }
 
-    udc_ep_status = udd_ep_is_halted(udd_g_ctrlreq.req.
-            wIndex & 0xFF) ? CPU_TO_LE16(USB_EP_STATUS_HALTED) : 0;
+    udc_ep_status = udd_ep_is_halted(udd_g_ctrlreq.req.wIndex & 0xFF) ? CPU_TO_LE16(USB_EP_STATUS_HALTED) : 0;
 
-    udd_set_setup_payload( (uint8_t *) & udc_ep_status,
-            sizeof(udc_ep_status));
+    udd_set_setup_payload((uint8_t *)&udc_ep_status, sizeof(udc_ep_status));
     return true;
 }
 #endif
@@ -486,16 +427,14 @@ static bool udc_req_std_ep_get_status(void)
  *
  * \return true if success
  */
-static bool udc_req_std_dev_clear_feature(void)
-{
+static bool udc_req_std_dev_clear_feature(void) {
     if (udd_g_ctrlreq.req.wLength) {
         return false;
     }
 
     if (udd_g_ctrlreq.req.wValue == USB_DEV_FEATURE_REMOTE_WAKEUP) {
         udc_device_status &= CPU_TO_LE16(~(uint32_t)USB_DEV_STATUS_REMOTEWAKEUP);
-#if (USB_CONFIG_ATTR_REMOTE_WAKEUP \
-    == (USB_DEVICE_ATTR & USB_CONFIG_ATTR_REMOTE_WAKEUP))
+#if (USB_CONFIG_ATTR_REMOTE_WAKEUP == (USB_DEVICE_ATTR & USB_CONFIG_ATTR_REMOTE_WAKEUP))
         UDC_REMOTEWAKEUP_DISABLE();
 #endif
         return true;
@@ -503,14 +442,13 @@ static bool udc_req_std_dev_clear_feature(void)
     return false;
 }
 
-#if (0!=USB_DEVICE_MAX_EP)
+#if (0 != USB_DEVICE_MAX_EP)
 /**
  * \brief Standard endpoint request to clear endpoint feature
  *
  * \return true if success
  */
-static bool udc_req_std_ep_clear_feature(void)
-{
+static bool udc_req_std_ep_clear_feature(void) {
     if (udd_g_ctrlreq.req.wLength) {
         return false;
     }
@@ -527,59 +465,56 @@ static bool udc_req_std_ep_clear_feature(void)
  *
  * \return true if success
  */
-static bool udc_req_std_dev_set_feature(void)
-{
+static bool udc_req_std_dev_set_feature(void) {
     if (udd_g_ctrlreq.req.wLength) {
         return false;
     }
 
     switch (udd_g_ctrlreq.req.wValue) {
-
-    case USB_DEV_FEATURE_REMOTE_WAKEUP:
-#if (USB_CONFIG_ATTR_REMOTE_WAKEUP \
-    == (USB_DEVICE_ATTR & USB_CONFIG_ATTR_REMOTE_WAKEUP))
-        udc_device_status |= CPU_TO_LE16(USB_DEV_STATUS_REMOTEWAKEUP);
-        UDC_REMOTEWAKEUP_ENABLE();
-        return true;
+        case USB_DEV_FEATURE_REMOTE_WAKEUP:
+#if (USB_CONFIG_ATTR_REMOTE_WAKEUP == (USB_DEVICE_ATTR & USB_CONFIG_ATTR_REMOTE_WAKEUP))
+            udc_device_status |= CPU_TO_LE16(USB_DEV_STATUS_REMOTEWAKEUP);
+            UDC_REMOTEWAKEUP_ENABLE();
+            return true;
 #else
-        return false;
+            return false;
 #endif
 
 #ifdef USB_DEVICE_HS_SUPPORT
-    case USB_DEV_FEATURE_TEST_MODE:
-        if (!udd_is_high_speed()) {
-            break;
-        }
-        if (udd_g_ctrlreq.req.wIndex & 0xff) {
+        case USB_DEV_FEATURE_TEST_MODE:
+            if (!udd_is_high_speed()) {
+                break;
+            }
+            if (udd_g_ctrlreq.req.wIndex & 0xff) {
+                break;
+            }
+            // Unconfigure the device, terminating all ongoing requests
+            udc_reset();
+            switch ((udd_g_ctrlreq.req.wIndex >> 8) & 0xFF) {
+                case USB_DEV_TEST_MODE_J:
+                    udd_g_ctrlreq.callback = udd_test_mode_j;
+                    return true;
+
+                case USB_DEV_TEST_MODE_K:
+                    udd_g_ctrlreq.callback = udd_test_mode_k;
+                    return true;
+
+                case USB_DEV_TEST_MODE_SE0_NAK:
+                    udd_g_ctrlreq.callback = udd_test_mode_se0_nak;
+                    return true;
+
+                case USB_DEV_TEST_MODE_PACKET:
+                    udd_g_ctrlreq.callback = udd_test_mode_packet;
+                    return true;
+
+                case USB_DEV_TEST_MODE_FORCE_ENABLE:  // Only for downstream facing hub ports
+                default:
+                    break;
+            }
             break;
-        }
-        // Unconfigure the device, terminating all ongoing requests
-        udc_reset();
-        switch ((udd_g_ctrlreq.req.wIndex >> 8) & 0xFF) {
-        case USB_DEV_TEST_MODE_J:
-            udd_g_ctrlreq.callback = udd_test_mode_j;
-            return true;
-
-        case USB_DEV_TEST_MODE_K:
-            udd_g_ctrlreq.callback = udd_test_mode_k;
-            return true;
-
-        case USB_DEV_TEST_MODE_SE0_NAK:
-            udd_g_ctrlreq.callback = udd_test_mode_se0_nak;
-            return true;
-
-        case USB_DEV_TEST_MODE_PACKET:
-            udd_g_ctrlreq.callback = udd_test_mode_packet;
-            return true;
-
-        case USB_DEV_TEST_MODE_FORCE_ENABLE: // Only for downstream facing hub ports
+#endif
         default:
             break;
-        }
-        break;
-#endif
-    default:
-        break;
     }
     return false;
 }
@@ -589,9 +524,8 @@ static bool udc_req_std_dev_set_feature(void)
  *
  * \return true if success
  */
-#if (0!=USB_DEVICE_MAX_EP)
-static bool udc_req_std_ep_set_feature(void)
-{
+#if (0 != USB_DEVICE_MAX_EP)
+static bool udc_req_std_ep_set_feature(void) {
     if (udd_g_ctrlreq.req.wLength) {
         return false;
     }
@@ -607,18 +541,14 @@ static bool udc_req_std_ep_set_feature(void)
  * \brief Change the address of device
  * Callback called at the end of request set address
  */
-static void udc_valid_address(void)
-{
-    udd_set_address(udd_g_ctrlreq.req.wValue & 0x7F);
-}
+static void udc_valid_address(void) { udd_set_address(udd_g_ctrlreq.req.wValue & 0x7F); }
 
 /**
  * \brief Standard device request to set device address
  *
  * \return true if success
  */
-static bool udc_req_std_dev_set_address(void)
-{
+static bool udc_req_std_dev_set_address(void) {
     if (udd_g_ctrlreq.req.wLength) {
         return false;
     }
@@ -634,53 +564,49 @@ static bool udc_req_std_dev_set_address(void)
  *
  * \return true if success
  */
-static bool udc_req_std_dev_get_str_desc(void)
-{
-    uint8_t i;
+static bool udc_req_std_dev_get_str_desc(void) {
+    uint8_t        i;
     const uint8_t *str;
-    uint8_t str_length = 0;
+    uint8_t        str_length = 0;
 
     // Link payload pointer to the string corresponding at request
     switch (udd_g_ctrlreq.req.wValue & 0xff) {
-    case 0:
-        udd_set_setup_payload((uint8_t *) &udc_string_desc_languageid,
-                sizeof(udc_string_desc_languageid));
-        break;
+        case 0:
+            udd_set_setup_payload((uint8_t *)&udc_string_desc_languageid, sizeof(udc_string_desc_languageid));
+            break;
 
 #ifdef USB_DEVICE_MANUFACTURE_NAME
-    case 1:
-        str_length = USB_DEVICE_MANUFACTURE_NAME_SIZE;
-        str = udc_string_manufacturer_name;
-        break;
+        case 1:
+            str_length = USB_DEVICE_MANUFACTURE_NAME_SIZE;
+            str        = udc_string_manufacturer_name;
+            break;
 #endif
 #ifdef USB_DEVICE_PRODUCT_NAME
-    case 2:
-        str_length = USB_DEVICE_PRODUCT_NAME_SIZE;
-        str = udc_string_product_name;
-        break;
+        case 2:
+            str_length = USB_DEVICE_PRODUCT_NAME_SIZE;
+            str        = udc_string_product_name;
+            break;
 #endif
-    case 3:
-        str = udc_get_string_serial_name();
-        str_length = usb_device_serial_name_size;
-        break;
-    default:
-#ifdef UDC_GET_EXTRA_STRING
-        if (UDC_GET_EXTRA_STRING()) {
+        case 3:
+            str        = udc_get_string_serial_name();
+            str_length = usb_device_serial_name_size;
             break;
-        }
+        default:
+#ifdef UDC_GET_EXTRA_STRING
+            if (UDC_GET_EXTRA_STRING()) {
+                break;
+            }
 #endif
-        return false;
+            return false;
     }
 
     if (str_length) {
-        for(i = 0; i < str_length; i++) {
+        for (i = 0; i < str_length; i++) {
             udc_string_desc.string[i] = cpu_to_le16((le16_t)str[i]);
         }
 
-        udc_string_desc.header.bLength = 2 + (str_length) * 2;
-        udd_set_setup_payload(
-            (uint8_t *) &udc_string_desc,
-            udc_string_desc.header.bLength);
+        udc_string_desc.header.bLength = 2 + (str_length)*2;
+        udd_set_setup_payload((uint8_t *)&udc_string_desc, udc_string_desc.header.bLength);
     }
 
     return true;
@@ -691,106 +617,89 @@ static bool udc_req_std_dev_get_str_desc(void)
  *
  * \return true if success
  */
-static bool udc_req_std_dev_get_descriptor(void)
-{
+static bool udc_req_std_dev_get_descriptor(void) {
     uint8_t conf_num;
 
     conf_num = udd_g_ctrlreq.req.wValue & 0xff;
 
     // Check descriptor ID
-    switch ((uint8_t) (udd_g_ctrlreq.req.wValue >> 8)) {
-    case USB_DT_DEVICE:
-        // Device descriptor requested
+    switch ((uint8_t)(udd_g_ctrlreq.req.wValue >> 8)) {
+        case USB_DT_DEVICE:
+            // Device descriptor requested
 #ifdef USB_DEVICE_HS_SUPPORT
-        if (!udd_is_high_speed()) {
-            udd_set_setup_payload(
-                (uint8_t *) udc_config.confdev_hs,
-                udc_config.confdev_hs->bLength);
-        } else
+            if (!udd_is_high_speed()) {
+                udd_set_setup_payload((uint8_t *)udc_config.confdev_hs, udc_config.confdev_hs->bLength);
+            } else
 #endif
-        {
-            udd_set_setup_payload(
-                (uint8_t *) udc_config.confdev_lsfs,
-                udc_config.confdev_lsfs->bLength);
-        }
-        break;
+            {
+                udd_set_setup_payload((uint8_t *)udc_config.confdev_lsfs, udc_config.confdev_lsfs->bLength);
+            }
+            break;
 
-    case USB_DT_CONFIGURATION:
-        // Configuration descriptor requested
+        case USB_DT_CONFIGURATION:
+            // Configuration descriptor requested
 #ifdef USB_DEVICE_HS_SUPPORT
-        if (udd_is_high_speed()) {
-            // HS descriptor
-            if (conf_num >= udc_config.confdev_hs->bNumConfigurations) {
-                return false;
-            }
-            udd_set_setup_payload(
-                (uint8_t *)udc_config.conf_hs[conf_num].desc,
-                le16_to_cpu(udc_config.conf_hs[conf_num].desc->wTotalLength));
-        } else
+            if (udd_is_high_speed()) {
+                // HS descriptor
+                if (conf_num >= udc_config.confdev_hs->bNumConfigurations) {
+                    return false;
+                }
+                udd_set_setup_payload((uint8_t *)udc_config.conf_hs[conf_num].desc, le16_to_cpu(udc_config.conf_hs[conf_num].desc->wTotalLength));
+            } else
 #endif
-        {
-            // FS descriptor
-            if (conf_num >= udc_config.confdev_lsfs->bNumConfigurations) {
-                return false;
+            {
+                // FS descriptor
+                if (conf_num >= udc_config.confdev_lsfs->bNumConfigurations) {
+                    return false;
+                }
+                udd_set_setup_payload((uint8_t *)udc_config.conf_lsfs[conf_num].desc, le16_to_cpu(udc_config.conf_lsfs[conf_num].desc->wTotalLength));
             }
-            udd_set_setup_payload(
-                (uint8_t *)udc_config.conf_lsfs[conf_num].desc,
-                le16_to_cpu(udc_config.conf_lsfs[conf_num].desc->wTotalLength));
-        }
-        ((usb_conf_desc_t *) udd_g_ctrlreq.payload)->bDescriptorType =
-                USB_DT_CONFIGURATION;
-        break;
+            ((usb_conf_desc_t *)udd_g_ctrlreq.payload)->bDescriptorType = USB_DT_CONFIGURATION;
+            break;
 
 #ifdef USB_DEVICE_HS_SUPPORT
-    case USB_DT_DEVICE_QUALIFIER:
-        // Device qualifier descriptor requested
-        udd_set_setup_payload( (uint8_t *) udc_config.qualifier,
-                udc_config.qualifier->bLength);
-        break;
-
-    case USB_DT_OTHER_SPEED_CONFIGURATION:
-        // Other configuration descriptor requested
-        if (!udd_is_high_speed()) {
-            // HS descriptor
-            if (conf_num >= udc_config.confdev_hs->bNumConfigurations) {
-                return false;
+        case USB_DT_DEVICE_QUALIFIER:
+            // Device qualifier descriptor requested
+            udd_set_setup_payload((uint8_t *)udc_config.qualifier, udc_config.qualifier->bLength);
+            break;
+
+        case USB_DT_OTHER_SPEED_CONFIGURATION:
+            // Other configuration descriptor requested
+            if (!udd_is_high_speed()) {
+                // HS descriptor
+                if (conf_num >= udc_config.confdev_hs->bNumConfigurations) {
+                    return false;
+                }
+                udd_set_setup_payload((uint8_t *)udc_config.conf_hs[conf_num].desc, le16_to_cpu(udc_config.conf_hs[conf_num].desc->wTotalLength));
+            } else {
+                // FS descriptor
+                if (conf_num >= udc_config.confdev_lsfs->bNumConfigurations) {
+                    return false;
+                }
+                udd_set_setup_payload((uint8_t *)udc_config.conf_lsfs[conf_num].desc, le16_to_cpu(udc_config.conf_lsfs[conf_num].desc->wTotalLength));
             }
-            udd_set_setup_payload(
-                (uint8_t *)udc_config.conf_hs[conf_num].desc,
-                le16_to_cpu(udc_config.conf_hs[conf_num].desc->wTotalLength));
-        } else {
-            // FS descriptor
-            if (conf_num >= udc_config.confdev_lsfs->bNumConfigurations) {
+            ((usb_conf_desc_t *)udd_g_ctrlreq.payload)->bDescriptorType = USB_DT_OTHER_SPEED_CONFIGURATION;
+            break;
+#endif
+
+        case USB_DT_BOS:
+            // Device BOS descriptor requested
+            if (udc_config.conf_bos == NULL) {
                 return false;
             }
-            udd_set_setup_payload(
-                (uint8_t *)udc_config.conf_lsfs[conf_num].desc,
-                le16_to_cpu(udc_config.conf_lsfs[conf_num].desc->wTotalLength));
-        }
-        ((usb_conf_desc_t *) udd_g_ctrlreq.payload)->bDescriptorType =
-                USB_DT_OTHER_SPEED_CONFIGURATION;
-        break;
-#endif
+            udd_set_setup_payload((uint8_t *)udc_config.conf_bos, udc_config.conf_bos->wTotalLength);
+            break;
 
-    case USB_DT_BOS:
-        // Device BOS descriptor requested
-        if (udc_config.conf_bos == NULL) {
-            return false;
-        }
-        udd_set_setup_payload( (uint8_t *) udc_config.conf_bos,
-                udc_config.conf_bos->wTotalLength);
-        break;
+        case USB_DT_STRING:
+            // String descriptor requested
+            if (!udc_req_std_dev_get_str_desc()) {
+                return false;
+            }
+            break;
 
-    case USB_DT_STRING:
-        // String descriptor requested
-        if (!udc_req_std_dev_get_str_desc()) {
+        default:
+            // Unknown descriptor requested
             return false;
-        }
-        break;
-
-    default:
-        // Unknown descriptor requested
-        return false;
     }
     // if the descriptor is larger than length requested, then reduce it
     if (udd_g_ctrlreq.req.wLength < udd_g_ctrlreq.payload_size) {
@@ -804,13 +713,12 @@ static bool udc_req_std_dev_get_descriptor(void)
  *
  * \return true if success
  */
-static bool udc_req_std_dev_get_configuration(void)
-{
+static bool udc_req_std_dev_get_configuration(void) {
     if (udd_g_ctrlreq.req.wLength != 1) {
         return false;
     }
 
-    udd_set_setup_payload(&udc_num_configuration,1);
+    udd_set_setup_payload(&udc_num_configuration, 1);
     return true;
 }
 
@@ -819,8 +727,7 @@ static bool udc_req_std_dev_get_configuration(void)
  *
  * \return true if success
  */
-static bool udc_req_std_dev_set_configuration(void)
-{
+static bool udc_req_std_dev_set_configuration(void) {
     uint8_t iface_num;
 
     // Check request length
@@ -835,16 +742,14 @@ static bool udc_req_std_dev_set_configuration(void)
 #ifdef USB_DEVICE_HS_SUPPORT
     if (udd_is_high_speed()) {
         // HS descriptor
-        if ((udd_g_ctrlreq.req.wValue & 0xFF) >
-                udc_config.confdev_hs->bNumConfigurations) {
+        if ((udd_g_ctrlreq.req.wValue & 0xFF) > udc_config.confdev_hs->bNumConfigurations) {
             return false;
         }
     } else
 #endif
     {
         // FS descriptor
-        if ((udd_g_ctrlreq.req.wValue & 0xFF) >
-                udc_config.confdev_lsfs->bNumConfigurations) {
+        if ((udd_g_ctrlreq.req.wValue & 0xFF) > udc_config.confdev_lsfs->bNumConfigurations) {
             return false;
         }
     }
@@ -855,7 +760,7 @@ static bool udc_req_std_dev_set_configuration(void)
     // Enable new configuration
     udc_num_configuration = udd_g_ctrlreq.req.wValue & 0xFF;
     if (udc_num_configuration == 0) {
-        return true; // Default empty configuration requested
+        return true;  // Default empty configuration requested
     }
     // Update pointer of the configuration descriptor
 #ifdef USB_DEVICE_HS_SUPPORT
@@ -869,8 +774,7 @@ static bool udc_req_std_dev_set_configuration(void)
         udc_ptr_conf = &udc_config.conf_lsfs[udc_num_configuration - 1];
     }
     // Enable all interfaces of the selected configuration
-    for (iface_num = 0; iface_num < udc_ptr_conf->desc->bNumInterfaces;
-            iface_num++) {
+    for (iface_num = 0; iface_num < udc_ptr_conf->desc->bNumInterfaces; iface_num++) {
         if (!udc_iface_enable(iface_num, 0)) {
             return false;
         }
@@ -884,16 +788,15 @@ static bool udc_req_std_dev_set_configuration(void)
  *
  * \return true if success
  */
-static bool udc_req_std_iface_get_setting(void)
-{
-    uint8_t iface_num;
+static bool udc_req_std_iface_get_setting(void) {
+    uint8_t   iface_num;
     udi_api_t UDC_DESC_STORAGE *udi_api;
 
     if (udd_g_ctrlreq.req.wLength != 1) {
-        return false; // Error in request
+        return false;  // Error in request
     }
     if (!udc_num_configuration) {
-        return false; // The device is not is configured state yet
+        return false;  // The device is not is configured state yet
     }
 
     // Check the interface number included in the request
@@ -908,11 +811,11 @@ static bool udc_req_std_iface_get_setting(void)
         return false;
     }
     // Get alternate setting from UDI
-    udi_api = udc_ptr_conf->udi_apis[iface_num];
+    udi_api           = udc_ptr_conf->udi_apis[iface_num];
     udc_iface_setting = udi_api->getsetting();
 
     // Link value to payload pointer of request
-    udd_set_setup_payload(&udc_iface_setting,1);
+    udd_set_setup_payload(&udc_iface_setting, 1);
     return true;
 }
 
@@ -922,18 +825,17 @@ static bool udc_req_std_iface_get_setting(void)
  *
  * \return true if success
  */
-static bool udc_req_std_iface_set_setting(void)
-{
+static bool udc_req_std_iface_set_setting(void) {
     uint8_t iface_num, setting_num;
 
     if (udd_g_ctrlreq.req.wLength) {
-        return false; // Error in request
+        return false;  // Error in request
     }
     if (!udc_num_configuration) {
-        return false; // The device is not is configured state yet
+        return false;  // The device is not is configured state yet
     }
 
-    iface_num = udd_g_ctrlreq.req.wIndex & 0xFF;
+    iface_num   = udd_g_ctrlreq.req.wIndex & 0xFF;
     setting_num = udd_g_ctrlreq.req.wValue & 0xFF;
 
     // Disable current setting
@@ -950,45 +852,44 @@ static bool udc_req_std_iface_set_setting(void)
  *
  * \return true if the request is supported
  */
-static bool udc_reqstd(void)
-{
+static bool udc_reqstd(void) {
     if (Udd_setup_is_in()) {
         // GET Standard Requests
         if (udd_g_ctrlreq.req.wLength == 0) {
-            return false; // Error for USB host
+            return false;  // Error for USB host
         }
 
         if (USB_REQ_RECIP_DEVICE == Udd_setup_recipient()) {
             // Standard Get Device request
             switch (udd_g_ctrlreq.req.bRequest) {
-            case USB_REQ_GET_STATUS:
-                return udc_req_std_dev_get_status();
-            case USB_REQ_GET_DESCRIPTOR:
-                return udc_req_std_dev_get_descriptor();
-            case USB_REQ_GET_CONFIGURATION:
-                return udc_req_std_dev_get_configuration();
-            default:
-                break;
+                case USB_REQ_GET_STATUS:
+                    return udc_req_std_dev_get_status();
+                case USB_REQ_GET_DESCRIPTOR:
+                    return udc_req_std_dev_get_descriptor();
+                case USB_REQ_GET_CONFIGURATION:
+                    return udc_req_std_dev_get_configuration();
+                default:
+                    break;
             }
         }
 
         if (USB_REQ_RECIP_INTERFACE == Udd_setup_recipient()) {
             // Standard Get Interface request
             switch (udd_g_ctrlreq.req.bRequest) {
-            case USB_REQ_GET_INTERFACE:
-                return udc_req_std_iface_get_setting();
-            default:
-                break;
+                case USB_REQ_GET_INTERFACE:
+                    return udc_req_std_iface_get_setting();
+                default:
+                    break;
             }
         }
-#if (0!=USB_DEVICE_MAX_EP)
+#if (0 != USB_DEVICE_MAX_EP)
         if (USB_REQ_RECIP_ENDPOINT == Udd_setup_recipient()) {
             // Standard Get Endpoint request
             switch (udd_g_ctrlreq.req.bRequest) {
-            case USB_REQ_GET_STATUS:
-                return udc_req_std_ep_get_status();
-            default:
-                break;
+                case USB_REQ_GET_STATUS:
+                    return udc_req_std_ep_get_status();
+                default:
+                    break;
             }
         }
 #endif
@@ -997,41 +898,41 @@ static bool udc_reqstd(void)
         if (USB_REQ_RECIP_DEVICE == Udd_setup_recipient()) {
             // Standard Set Device request
             switch (udd_g_ctrlreq.req.bRequest) {
-            case USB_REQ_SET_ADDRESS:
-                return udc_req_std_dev_set_address();
-            case USB_REQ_CLEAR_FEATURE:
-                return udc_req_std_dev_clear_feature();
-            case USB_REQ_SET_FEATURE:
-                return udc_req_std_dev_set_feature();
-            case USB_REQ_SET_CONFIGURATION:
-                return udc_req_std_dev_set_configuration();
-            case USB_REQ_SET_DESCRIPTOR:
-                /* Not supported (defined as optional by the USB 2.0 spec) */
-                break;
-            default:
-                break;
+                case USB_REQ_SET_ADDRESS:
+                    return udc_req_std_dev_set_address();
+                case USB_REQ_CLEAR_FEATURE:
+                    return udc_req_std_dev_clear_feature();
+                case USB_REQ_SET_FEATURE:
+                    return udc_req_std_dev_set_feature();
+                case USB_REQ_SET_CONFIGURATION:
+                    return udc_req_std_dev_set_configuration();
+                case USB_REQ_SET_DESCRIPTOR:
+                    /* Not supported (defined as optional by the USB 2.0 spec) */
+                    break;
+                default:
+                    break;
             }
         }
 
         if (USB_REQ_RECIP_INTERFACE == Udd_setup_recipient()) {
             // Standard Set Interface request
             switch (udd_g_ctrlreq.req.bRequest) {
-            case USB_REQ_SET_INTERFACE:
-                return udc_req_std_iface_set_setting();
-            default:
-                break;
+                case USB_REQ_SET_INTERFACE:
+                    return udc_req_std_iface_set_setting();
+                default:
+                    break;
             }
         }
-#if (0!=USB_DEVICE_MAX_EP)
+#if (0 != USB_DEVICE_MAX_EP)
         if (USB_REQ_RECIP_ENDPOINT == Udd_setup_recipient()) {
             // Standard Set Endpoint request
             switch (udd_g_ctrlreq.req.bRequest) {
-            case USB_REQ_CLEAR_FEATURE:
-                return udc_req_std_ep_clear_feature();
-            case USB_REQ_SET_FEATURE:
-                return udc_req_std_ep_set_feature();
-            default:
-                break;
+                case USB_REQ_CLEAR_FEATURE:
+                    return udc_req_std_ep_clear_feature();
+                case USB_REQ_SET_FEATURE:
+                    return udc_req_std_ep_set_feature();
+                default:
+                    break;
             }
         }
 #endif
@@ -1044,13 +945,12 @@ static bool udc_reqstd(void)
  *
  * \return true if the request is supported
  */
-static bool udc_req_iface(void)
-{
-    uint8_t iface_num;
+static bool udc_req_iface(void) {
+    uint8_t   iface_num;
     udi_api_t UDC_DESC_STORAGE *udi_api;
 
     if (0 == udc_num_configuration) {
-        return false; // The device is not is configured state yet
+        return false;  // The device is not is configured state yet
     }
     // Check interface number
     iface_num = udd_g_ctrlreq.req.wIndex & 0xFF;
@@ -1079,18 +979,16 @@ static bool udc_req_iface(void)
  *
  * \return true if the request is supported
  */
-static bool udc_req_ep(void)
-{
-    uint8_t iface_num;
+static bool udc_req_ep(void) {
+    uint8_t   iface_num;
     udi_api_t UDC_DESC_STORAGE *udi_api;
 
     if (0 == udc_num_configuration) {
-        return false; // The device is not is configured state yet
+        return false;  // The device is not is configured state yet
     }
     // Send this request on all enabled interfaces
     iface_num = udd_g_ctrlreq.req.wIndex & 0xFF;
-    for (iface_num = 0; iface_num < udc_ptr_conf->desc->bNumInterfaces;
-            iface_num++) {
+    for (iface_num = 0; iface_num < udc_ptr_conf->desc->bNumInterfaces; iface_num++) {
         // Select the interface with the current alternate setting
         udi_api = udc_ptr_conf->udi_apis[iface_num];
         if (!udc_update_iface_desc(iface_num, udi_api->getsetting())) {
@@ -1118,16 +1016,15 @@ static bool udc_req_ep(void)
  *
  * \return true if the request is supported, else the request is stalled by UDD
  */
-bool udc_process_setup(void)
-{
+bool udc_process_setup(void) {
     // By default no data (receive/send) and no callbacks registered
-    udd_g_ctrlreq.payload_size = 0;
-    udd_g_ctrlreq.callback = NULL;
+    udd_g_ctrlreq.payload_size   = 0;
+    udd_g_ctrlreq.callback       = NULL;
     udd_g_ctrlreq.over_under_run = NULL;
 
     if (Udd_setup_is_in()) {
         if (udd_g_ctrlreq.req.wLength == 0) {
-            return false; // Error from USB host
+            return false;  // Error from USB host
         }
     }
 
@@ -1155,7 +1052,7 @@ bool udc_process_setup(void)
     // Here SETUP request unknown by UDC and UDIs
 #ifdef USB_DEVICE_SPECIFIC_REQUEST
     // Try to decode it in specific callback
-    return USB_DEVICE_SPECIFIC_REQUEST(); // Ex: Vendor request,...
+    return USB_DEVICE_SPECIFIC_REQUEST();  // Ex: Vendor request,...
 #else
     return false;
 #endif
diff --git a/tmk_core/protocol/arm_atsam/usb/udc.h b/tmk_core/protocol/arm_atsam/usb/udc.h
index 33335d186..8d33307d3 100644
--- a/tmk_core/protocol/arm_atsam/usb/udc.h
+++ b/tmk_core/protocol/arm_atsam/usb/udc.h
@@ -53,11 +53,11 @@
 #include "udd.h"
 
 #if USB_DEVICE_VENDOR_ID == 0
-#   error USB_DEVICE_VENDOR_ID cannot be equal to 0
+#    error USB_DEVICE_VENDOR_ID cannot be equal to 0
 #endif
 
 #if USB_DEVICE_PRODUCT_ID == 0
-#   error USB_DEVICE_PRODUCT_ID cannot be equal to 0
+#    error USB_DEVICE_PRODUCT_ID cannot be equal to 0
 #endif
 
 #ifdef __cplusplus
@@ -172,10 +172,7 @@ extern "C" {
     }
 \endcode
  */
-static inline bool udc_include_vbus_monitoring(void)
-{
-    return udd_include_vbus_monitoring();
-}
+static inline bool udc_include_vbus_monitoring(void) { return udd_include_vbus_monitoring(); }
 
 /*! \brief Start the USB Device stack
  */
@@ -192,28 +189,19 @@ void udc_stop(void);
  * then it will attach device when an acceptable Vbus
  * level from the host is detected.
  */
-static inline void udc_attach(void)
-{
-    udd_attach();
-}
+static inline void udc_attach(void) { udd_attach(); }
 
 /**
  * \brief Detaches the device from the bus
  *
  * The driver must remove pull-up on USB line D- or D+.
  */
-static inline void udc_detach(void)
-{
-    udd_detach();
-}
+static inline void udc_detach(void) { udd_detach(); }
 
 /*! \brief The USB driver sends a resume signal called \e "Upstream Resume"
  * This is authorized only when the remote wakeup feature is enabled by host.
  */
-inline void udc_remotewakeup(void)
-{
-    udd_send_remotewakeup();
-}
+inline void udc_remotewakeup(void) { udd_send_remotewakeup(); }
 
 /**
  * \brief Returns a pointer on the current interface descriptor
@@ -257,4 +245,4 @@ usb_iface_desc_t UDC_DESC_STORAGE *udc_get_interface_desc(void);
 }
 #endif
 
-#endif // _UDC_H_
+#endif  // _UDC_H_
diff --git a/tmk_core/protocol/arm_atsam/usb/udc_desc.h b/tmk_core/protocol/arm_atsam/usb/udc_desc.h
index 9cab03dcb..39ea153b4 100644
--- a/tmk_core/protocol/arm_atsam/usb/udc_desc.h
+++ b/tmk_core/protocol/arm_atsam/usb/udc_desc.h
@@ -77,23 +77,21 @@ extern "C" {
  *
  * For Mega application used "code".
  */
-#define  UDC_DESC_STORAGE
-    // Descriptor storage in internal RAM
+#define UDC_DESC_STORAGE
+// Descriptor storage in internal RAM
 #if (defined UDC_DATA_USE_HRAM_SUPPORT)
-#if defined(__GNUC__)
-#define UDC_DATA(x)              COMPILER_WORD_ALIGNED __attribute__((__section__(".data_hram0")))
-#define UDC_BSS(x)               COMPILER_ALIGNED(x)   __attribute__((__section__(".bss_hram0")))
-#elif defined(__ICCAVR32__)
-#define UDC_DATA(x)              COMPILER_ALIGNED(x)   __data32
-#define UDC_BSS(x)               COMPILER_ALIGNED(x)   __data32
-#endif
+#    if defined(__GNUC__)
+#        define UDC_DATA(x) COMPILER_WORD_ALIGNED __attribute__((__section__(".data_hram0")))
+#        define UDC_BSS(x) COMPILER_ALIGNED(x) __attribute__((__section__(".bss_hram0")))
+#    elif defined(__ICCAVR32__)
+#        define UDC_DATA(x) COMPILER_ALIGNED(x) __data32
+#        define UDC_BSS(x) COMPILER_ALIGNED(x) __data32
+#    endif
 #else
-#define UDC_DATA(x)              COMPILER_ALIGNED(x)
-#define UDC_BSS(x)               COMPILER_ALIGNED(x)
+#    define UDC_DATA(x) COMPILER_ALIGNED(x)
+#    define UDC_BSS(x) COMPILER_ALIGNED(x)
 #endif
 
-
-
 /**
  * \brief Configuration descriptor and UDI link for one USB speed
  */
@@ -101,10 +99,9 @@ typedef struct {
     //! USB configuration descriptor
     usb_conf_desc_t UDC_DESC_STORAGE *desc;
     //! Array of UDI API pointer
-    udi_api_t UDC_DESC_STORAGE *UDC_DESC_STORAGE * udi_apis;
+    udi_api_t UDC_DESC_STORAGE *UDC_DESC_STORAGE *udi_apis;
 } udc_config_speed_t;
 
-
 /**
  * \brief All information about the USB Device
  */
@@ -132,4 +129,4 @@ extern UDC_DESC_STORAGE udc_config_t udc_config;
 #ifdef __cplusplus
 }
 #endif
-#endif // _UDC_DESC_H_
+#endif  // _UDC_DESC_H_
diff --git a/tmk_core/protocol/arm_atsam/usb/udd.h b/tmk_core/protocol/arm_atsam/usb/udd.h
index b580e5847..805b761a7 100644
--- a/tmk_core/protocol/arm_atsam/usb/udd.h
+++ b/tmk_core/protocol/arm_atsam/usb/udd.h
@@ -71,7 +71,7 @@ typedef uint8_t udd_ep_id_t;
 //! \brief Endpoint transfer status
 //! Returned in parameters of callback register via udd_ep_run routine.
 typedef enum {
-    UDD_EP_TRANSFER_OK = 0,
+    UDD_EP_TRANSFER_OK    = 0,
     UDD_EP_TRANSFER_ABORT = 1,
 } udd_ep_status_t;
 
@@ -94,36 +94,32 @@ typedef struct {
     uint16_t payload_size;
 
     //! Callback called after reception of ZLP from setup request
-    void (*callback) (void);
+    void (*callback)(void);
 
     //! Callback called when the buffer given (.payload) is full or empty.
     //! This one return false to abort data transfer, or true with a new buffer in .payload.
-    bool(*over_under_run) (void);
+    bool (*over_under_run)(void);
 } udd_ctrl_request_t;
 extern udd_ctrl_request_t udd_g_ctrlreq;
 
 //! Return true if the setup request \a udd_g_ctrlreq indicates IN data transfer
-#define  Udd_setup_is_in()       \
-      (USB_REQ_DIR_IN == (udd_g_ctrlreq.req.bmRequestType & USB_REQ_DIR_MASK))
+#define Udd_setup_is_in() (USB_REQ_DIR_IN == (udd_g_ctrlreq.req.bmRequestType & USB_REQ_DIR_MASK))
 
 //! Return true if the setup request \a udd_g_ctrlreq indicates OUT data transfer
-#define  Udd_setup_is_out()      \
-      (USB_REQ_DIR_OUT == (udd_g_ctrlreq.req.bmRequestType & USB_REQ_DIR_MASK))
+#define Udd_setup_is_out() (USB_REQ_DIR_OUT == (udd_g_ctrlreq.req.bmRequestType & USB_REQ_DIR_MASK))
 
 //! Return the type of the SETUP request \a udd_g_ctrlreq. \see usb_reqtype.
-#define  Udd_setup_type()        \
-      (udd_g_ctrlreq.req.bmRequestType & USB_REQ_TYPE_MASK)
+#define Udd_setup_type() (udd_g_ctrlreq.req.bmRequestType & USB_REQ_TYPE_MASK)
 
 //! Return the recipient of the SETUP request \a udd_g_ctrlreq. \see usb_recipient
-#define  Udd_setup_recipient()   \
-      (udd_g_ctrlreq.req.bmRequestType & USB_REQ_RECIP_MASK)
+#define Udd_setup_recipient() (udd_g_ctrlreq.req.bmRequestType & USB_REQ_RECIP_MASK)
 
 /**
  * \brief End of halt callback function type.
  * Registered by routine udd_ep_wait_stall_clear()
  * Callback called when endpoint stall is cleared.
  */
-typedef void (*udd_callback_halt_cleared_t) (void);
+typedef void (*udd_callback_halt_cleared_t)(void);
 
 /**
  * \brief End of transfer callback function type.
@@ -134,8 +130,7 @@ typedef void (*udd_callback_halt_cleared_t) (void);
  * \param status     UDD_EP_TRANSFER_ABORT, if transfer is aborted
  * \param n          number of data transfered
  */
-typedef void (*udd_callback_trans_t) (udd_ep_status_t status,
-        iram_size_t nb_transfered, udd_ep_id_t ep);
+typedef void (*udd_callback_trans_t)(udd_ep_status_t status, iram_size_t nb_transfered, udd_ep_id_t ep);
 
 /**
  * \brief Authorizes the VBUS event
@@ -216,8 +211,7 @@ void udd_send_remotewakeup(void);
  * \param payload       Pointer on payload
  * \param payload_size  Size of payload
  */
-void udd_set_setup_payload( uint8_t *payload, uint16_t payload_size );
-
+void udd_set_setup_payload(uint8_t *payload, uint16_t payload_size);
 
 /**
  * \name Endpoint Management
@@ -239,8 +233,7 @@ void udd_set_setup_payload( uint8_t *payload, uint16_t payload_size );
  *
  * \return \c 1 if the endpoint is enabled, otherwise \c 0.
  */
-bool udd_ep_alloc(udd_ep_id_t ep, uint8_t bmAttributes,
-        uint16_t MaxEndpointSize);
+bool udd_ep_alloc(udd_ep_id_t ep, uint8_t bmAttributes, uint16_t MaxEndpointSize);
 
 /**
  * \brief Disables an endpoint
@@ -294,8 +287,7 @@ bool udd_ep_clear_halt(udd_ep_id_t ep);
  *
  * \return \c 1 if the register is accepted, otherwise \c 0.
  */
-bool udd_ep_wait_stall_clear(udd_ep_id_t ep,
-        udd_callback_halt_cleared_t callback);
+bool udd_ep_wait_stall_clear(udd_ep_id_t ep, udd_callback_halt_cleared_t callback);
 
 /**
  * \brief Allows to receive or send data on an endpoint
@@ -321,9 +313,7 @@ bool udd_ep_wait_stall_clear(udd_ep_id_t ep,
  *
  * \return \c 1 if function was successfully done, otherwise \c 0.
  */
-bool udd_ep_run(udd_ep_id_t ep, bool b_shortpacket,
-        uint8_t *buf, iram_size_t buf_size,
-        udd_callback_trans_t callback);
+bool udd_ep_run(udd_ep_id_t ep, bool b_shortpacket, uint8_t *buf, iram_size_t buf_size, udd_callback_trans_t callback);
 /**
  * \brief Aborts transfer on going on endpoint
  *
@@ -339,7 +329,6 @@ void udd_ep_abort(udd_ep_id_t ep);
 
 //@}
 
-
 /**
  * \name High speed test mode management
  *
@@ -352,7 +341,6 @@ void udd_test_mode_se0_nak(void);
 void udd_test_mode_packet(void);
 //@}
 
-
 /**
  * \name UDC callbacks to provide for UDD
  *
@@ -393,4 +381,4 @@ extern void udc_sof_notify(void);
 #ifdef __cplusplus
 }
 #endif
-#endif // _UDD_H_
+#endif  // _UDD_H_
diff --git a/tmk_core/protocol/arm_atsam/usb/udi.h b/tmk_core/protocol/arm_atsam/usb/udi.h
index 9e4d4baf7..89942cce4 100644
--- a/tmk_core/protocol/arm_atsam/usb/udi.h
+++ b/tmk_core/protocol/arm_atsam/usb/udi.h
@@ -72,57 +72,57 @@ extern "C" {
  * selected by UDC.
  */
 typedef struct {
-        /**
-         * \brief Enable the interface.
-         *
-         * This function is called when the host selects a configuration
-         * to which this interface belongs through a Set Configuration
-         * request, and when the host selects an alternate setting of
-         * this interface through a Set Interface request.
-         *
-         * \return \c 1 if function was successfully done, otherwise \c 0.
-         */
-        bool(*enable) (void);
+    /**
+     * \brief Enable the interface.
+     *
+     * This function is called when the host selects a configuration
+     * to which this interface belongs through a Set Configuration
+     * request, and when the host selects an alternate setting of
+     * this interface through a Set Interface request.
+     *
+     * \return \c 1 if function was successfully done, otherwise \c 0.
+     */
+    bool (*enable)(void);
 
-        /**
-         * \brief Disable the interface.
-         *
-         * This function is called when this interface is currently
-         * active, and
-         * - the host selects any configuration through a Set
-         *   Configuration request, or
-         * - the host issues a USB reset, or
-         * - the device is detached from the host (i.e. Vbus is no
-         *   longer present)
-         */
-        void (*disable) (void);
+    /**
+     * \brief Disable the interface.
+     *
+     * This function is called when this interface is currently
+     * active, and
+     * - the host selects any configuration through a Set
+     *   Configuration request, or
+     * - the host issues a USB reset, or
+     * - the device is detached from the host (i.e. Vbus is no
+     *   longer present)
+     */
+    void (*disable)(void);
 
-        /**
-         * \brief Handle a control request directed at an interface.
-         *
-         * This function is called when this interface is currently
-         * active and the host sends a SETUP request
-         * with this interface as the recipient.
-         *
-         * Use udd_g_ctrlreq to decode and response to SETUP request.
-         *
-         * \return \c 1 if this interface supports the SETUP request, otherwise \c 0.
-         */
-        bool(*setup) (void);
+    /**
+     * \brief Handle a control request directed at an interface.
+     *
+     * This function is called when this interface is currently
+     * active and the host sends a SETUP request
+     * with this interface as the recipient.
+     *
+     * Use udd_g_ctrlreq to decode and response to SETUP request.
+     *
+     * \return \c 1 if this interface supports the SETUP request, otherwise \c 0.
+     */
+    bool (*setup)(void);
 
-        /**
-         * \brief Returns the current setting of the selected interface.
-         *
-         * This function is called when UDC when know alternate setting of selected interface.
-         *
-         * \return alternate setting of selected interface
-         */
-        uint8_t(*getsetting) (void);
+    /**
+     * \brief Returns the current setting of the selected interface.
+     *
+     * This function is called when UDC when know alternate setting of selected interface.
+     *
+     * \return alternate setting of selected interface
+     */
+    uint8_t (*getsetting)(void);
 
-        /**
-         * \brief To signal that a SOF is occurred
-         */
-        void(*sof_notify) (void);
+    /**
+     * \brief To signal that a SOF is occurred
+     */
+    void (*sof_notify)(void);
 } udi_api_t;
 
 //@}
@@ -130,4 +130,4 @@ typedef struct {
 #ifdef __cplusplus
 }
 #endif
-#endif // _UDI_H_
+#endif  // _UDI_H_
diff --git a/tmk_core/protocol/arm_atsam/usb/udi_cdc.c b/tmk_core/protocol/arm_atsam/usb/udi_cdc.c
index ffe3526db..8271f3b97 100644
--- a/tmk_core/protocol/arm_atsam/usb/udi_cdc.c
+++ b/tmk_core/protocol/arm_atsam/usb/udi_cdc.c
@@ -59,27 +59,27 @@
 
 #ifdef CDC
 
-#ifdef UDI_CDC_LOW_RATE
-#  ifdef USB_DEVICE_HS_SUPPORT
-#    define UDI_CDC_TX_BUFFERS     (UDI_CDC_DATA_EPS_HS_SIZE)
-#    define UDI_CDC_RX_BUFFERS     (UDI_CDC_DATA_EPS_HS_SIZE)
-#  else
-#    define UDI_CDC_TX_BUFFERS     (UDI_CDC_DATA_EPS_FS_SIZE)
-#    define UDI_CDC_RX_BUFFERS     (UDI_CDC_DATA_EPS_FS_SIZE)
-#  endif
-#else
-#  ifdef USB_DEVICE_HS_SUPPORT
-#    define UDI_CDC_TX_BUFFERS     (UDI_CDC_DATA_EPS_HS_SIZE)
-#    define UDI_CDC_RX_BUFFERS     (UDI_CDC_DATA_EPS_HS_SIZE)
-#  else
-#    define UDI_CDC_TX_BUFFERS     (5*UDI_CDC_DATA_EPS_FS_SIZE)
-#    define UDI_CDC_RX_BUFFERS     (5*UDI_CDC_DATA_EPS_FS_SIZE)
-#  endif
-#endif
-
-#ifndef UDI_CDC_TX_EMPTY_NOTIFY
-#  define UDI_CDC_TX_EMPTY_NOTIFY(port)
-#endif
+#    ifdef UDI_CDC_LOW_RATE
+#        ifdef USB_DEVICE_HS_SUPPORT
+#            define UDI_CDC_TX_BUFFERS (UDI_CDC_DATA_EPS_HS_SIZE)
+#            define UDI_CDC_RX_BUFFERS (UDI_CDC_DATA_EPS_HS_SIZE)
+#        else
+#            define UDI_CDC_TX_BUFFERS (UDI_CDC_DATA_EPS_FS_SIZE)
+#            define UDI_CDC_RX_BUFFERS (UDI_CDC_DATA_EPS_FS_SIZE)
+#        endif
+#    else
+#        ifdef USB_DEVICE_HS_SUPPORT
+#            define UDI_CDC_TX_BUFFERS (UDI_CDC_DATA_EPS_HS_SIZE)
+#            define UDI_CDC_RX_BUFFERS (UDI_CDC_DATA_EPS_HS_SIZE)
+#        else
+#            define UDI_CDC_TX_BUFFERS (5 * UDI_CDC_DATA_EPS_FS_SIZE)
+#            define UDI_CDC_RX_BUFFERS (5 * UDI_CDC_DATA_EPS_FS_SIZE)
+#        endif
+#    endif
+
+#    ifndef UDI_CDC_TX_EMPTY_NOTIFY
+#        define UDI_CDC_TX_EMPTY_NOTIFY(port)
+#    endif
 
 /**
  * \ingroup udi_cdc_group
@@ -89,25 +89,19 @@
  *
  * @{
  */
-bool udi_cdc_comm_enable(void);
-void udi_cdc_comm_disable(void);
-bool udi_cdc_comm_setup(void);
-bool udi_cdc_data_enable(void);
-void udi_cdc_data_disable(void);
-bool udi_cdc_data_setup(void);
-uint8_t udi_cdc_getsetting(void);
-void udi_cdc_data_sof_notify(void);
-UDC_DESC_STORAGE udi_api_t udi_api_cdc_comm = {
-    .enable = udi_cdc_comm_enable,
-    .disable = udi_cdc_comm_disable,
-    .setup = udi_cdc_comm_setup,
-    .getsetting = udi_cdc_getsetting,
-    .sof_notify = NULL
-};
+bool             udi_cdc_comm_enable(void);
+void             udi_cdc_comm_disable(void);
+bool             udi_cdc_comm_setup(void);
+bool             udi_cdc_data_enable(void);
+void             udi_cdc_data_disable(void);
+bool             udi_cdc_data_setup(void);
+uint8_t          udi_cdc_getsetting(void);
+void             udi_cdc_data_sof_notify(void);
+UDC_DESC_STORAGE udi_api_t udi_api_cdc_comm = {.enable = udi_cdc_comm_enable, .disable = udi_cdc_comm_disable, .setup = udi_cdc_comm_setup, .getsetting = udi_cdc_getsetting, .sof_notify = NULL};
 UDC_DESC_STORAGE udi_api_t udi_api_cdc_data = {
-    .enable = udi_cdc_data_enable,
-    .disable = udi_cdc_data_disable,
-    .setup = udi_cdc_data_setup,
+    .enable     = udi_cdc_data_enable,
+    .disable    = udi_cdc_data_disable,
+    .setup      = udi_cdc_data_setup,
     .getsetting = udi_cdc_getsetting,
     .sof_notify = udi_cdc_data_sof_notify,
 };
@@ -226,9 +220,9 @@ static void udi_cdc_tx_send(uint8_t port);
  */
 //@{
 COMPILER_WORD_ALIGNED
-static usb_cdc_line_coding_t udi_cdc_line_coding[UDI_CDC_PORT_NB];
-static bool udi_cdc_serial_state_msg_ongoing[UDI_CDC_PORT_NB];
-static volatile le16_t udi_cdc_state[UDI_CDC_PORT_NB];
+static usb_cdc_line_coding_t                               udi_cdc_line_coding[UDI_CDC_PORT_NB];
+static bool                                                udi_cdc_serial_state_msg_ongoing[UDI_CDC_PORT_NB];
+static volatile le16_t                                     udi_cdc_state[UDI_CDC_PORT_NB];
 COMPILER_WORD_ALIGNED static usb_cdc_notify_serial_state_t uid_cdc_state_msg[UDI_CDC_PORT_NB];
 
 //! Status of CDC COMM interfaces
@@ -243,7 +237,7 @@ static volatile uint8_t udi_cdc_nb_comm_enabled = 0;
 
 //! Status of CDC DATA interfaces
 static volatile uint8_t udi_cdc_nb_data_enabled = 0;
-static volatile bool udi_cdc_data_running = false;
+static volatile bool    udi_cdc_data_running    = false;
 //! Buffer to receive data
 COMPILER_WORD_ALIGNED static uint8_t udi_cdc_rx_buf[UDI_CDC_PORT_NB][2][UDI_CDC_RX_BUFFERS];
 //! Data available in RX buffers
@@ -256,7 +250,7 @@ static volatile uint16_t udi_cdc_rx_pos[UDI_CDC_PORT_NB];
 static volatile bool udi_cdc_rx_trans_ongoing[UDI_CDC_PORT_NB];
 
 //! Define a transfer halted
-#define  UDI_CDC_TRANS_HALTED    2
+#    define UDI_CDC_TRANS_HALTED 2
 
 //! Buffer to send data
 COMPILER_WORD_ALIGNED static uint8_t udi_cdc_tx_buf[UDI_CDC_PORT_NB][2][UDI_CDC_TX_BUFFERS];
@@ -273,29 +267,26 @@ static volatile bool udi_cdc_tx_both_buf_to_send[UDI_CDC_PORT_NB];
 
 //@}
 
-bool udi_cdc_comm_enable(void)
-{
+bool udi_cdc_comm_enable(void) {
     uint8_t port;
     uint8_t iface_comm_num;
 
-//#if UDI_CDC_PORT_NB == 1 // To optimize code
-    port = 0;
+    //#if UDI_CDC_PORT_NB == 1 // To optimize code
+    port                    = 0;
     udi_cdc_nb_comm_enabled = 0;
-//#else
-//    if (udi_cdc_nb_comm_enabled > UDI_CDC_PORT_NB) {
-//        udi_cdc_nb_comm_enabled = 0;
-//    }
-//    port = udi_cdc_nb_comm_enabled;
-//#endif
+    //#else
+    //    if (udi_cdc_nb_comm_enabled > UDI_CDC_PORT_NB) {
+    //        udi_cdc_nb_comm_enabled = 0;
+    //    }
+    //    port = udi_cdc_nb_comm_enabled;
+    //#endif
 
     // Initialize control signal management
     udi_cdc_state[port] = CPU_TO_LE16(0);
 
-    uid_cdc_state_msg[port].header.bmRequestType =
-            USB_REQ_DIR_IN | USB_REQ_TYPE_CLASS |
-            USB_REQ_RECIP_INTERFACE;
+    uid_cdc_state_msg[port].header.bmRequestType = USB_REQ_DIR_IN | USB_REQ_TYPE_CLASS | USB_REQ_RECIP_INTERFACE;
     uid_cdc_state_msg[port].header.bNotification = USB_REQ_CDC_NOTIFY_SERIAL_STATE;
-    uid_cdc_state_msg[port].header.wValue = LE16(0);
+    uid_cdc_state_msg[port].header.wValue        = LE16(0);
 
     /*
     switch (port) {
@@ -312,55 +303,54 @@ bool udi_cdc_comm_enable(void)
     */
     iface_comm_num = UDI_CDC_COMM_IFACE_NUMBER_0;
 
-    uid_cdc_state_msg[port].header.wIndex = LE16(iface_comm_num);
+    uid_cdc_state_msg[port].header.wIndex  = LE16(iface_comm_num);
     uid_cdc_state_msg[port].header.wLength = LE16(2);
-    uid_cdc_state_msg[port].value = CPU_TO_LE16(0);
+    uid_cdc_state_msg[port].value          = CPU_TO_LE16(0);
 
-    udi_cdc_line_coding[port].dwDTERate = CPU_TO_LE32(UDI_CDC_DEFAULT_RATE);
+    udi_cdc_line_coding[port].dwDTERate   = CPU_TO_LE32(UDI_CDC_DEFAULT_RATE);
     udi_cdc_line_coding[port].bCharFormat = UDI_CDC_DEFAULT_STOPBITS;
     udi_cdc_line_coding[port].bParityType = UDI_CDC_DEFAULT_PARITY;
-    udi_cdc_line_coding[port].bDataBits = UDI_CDC_DEFAULT_DATABITS;
+    udi_cdc_line_coding[port].bDataBits   = UDI_CDC_DEFAULT_DATABITS;
     // Call application callback
     // to initialize memories or indicate that interface is enabled
-#if 0
+#    if 0
     UDI_CDC_SET_CODING_EXT(port,(&udi_cdc_line_coding[port]));
     if (!UDI_CDC_ENABLE_EXT(port)) {
         return false;
     }
-#endif
+#    endif
     udi_cdc_nb_comm_enabled++;
     return true;
 }
 
-bool udi_cdc_data_enable(void)
-{
+bool udi_cdc_data_enable(void) {
     uint8_t port;
 
-//#if UDI_CDC_PORT_NB == 1 // To optimize code
-    port = 0;
+    //#if UDI_CDC_PORT_NB == 1 // To optimize code
+    port                    = 0;
     udi_cdc_nb_data_enabled = 0;
-//#else
-//    if (udi_cdc_nb_data_enabled > UDI_CDC_PORT_NB) {
-//        udi_cdc_nb_data_enabled = 0;
-//    }
-//    port = udi_cdc_nb_data_enabled;
-//#endif
+    //#else
+    //    if (udi_cdc_nb_data_enabled > UDI_CDC_PORT_NB) {
+    //        udi_cdc_nb_data_enabled = 0;
+    //    }
+    //    port = udi_cdc_nb_data_enabled;
+    //#endif
 
     // Initialize TX management
-    udi_cdc_tx_trans_ongoing[port] = false;
+    udi_cdc_tx_trans_ongoing[port]    = false;
     udi_cdc_tx_both_buf_to_send[port] = false;
-    udi_cdc_tx_buf_sel[port] = 0;
-    udi_cdc_tx_buf_nb[port][0] = 0;
-    udi_cdc_tx_buf_nb[port][1] = 0;
-    udi_cdc_tx_sof_num[port] = 0;
+    udi_cdc_tx_buf_sel[port]          = 0;
+    udi_cdc_tx_buf_nb[port][0]        = 0;
+    udi_cdc_tx_buf_nb[port][1]        = 0;
+    udi_cdc_tx_sof_num[port]          = 0;
     udi_cdc_tx_send(port);
 
     // Initialize RX management
     udi_cdc_rx_trans_ongoing[port] = false;
-    udi_cdc_rx_buf_sel[port] = 0;
-    udi_cdc_rx_buf_nb[port][0] = 0;
-    udi_cdc_rx_buf_nb[port][1] = 0;
-    udi_cdc_rx_pos[port] = 0;
+    udi_cdc_rx_buf_sel[port]       = 0;
+    udi_cdc_rx_buf_nb[port][0]     = 0;
+    udi_cdc_rx_buf_nb[port][1]     = 0;
+    udi_cdc_rx_pos[port]           = 0;
     if (!udi_cdc_rx_start(port)) {
         return false;
     }
@@ -371,25 +361,22 @@ bool udi_cdc_data_enable(void)
     return true;
 }
 
-void udi_cdc_comm_disable(void)
-{
+void udi_cdc_comm_disable(void) {
     Assert(udi_cdc_nb_comm_enabled != 0);
     udi_cdc_nb_comm_enabled--;
 }
 
-void udi_cdc_data_disable(void)
-{
-//  uint8_t port;
+void udi_cdc_data_disable(void) {
+    //  uint8_t port;
 
     Assert(udi_cdc_nb_data_enabled != 0);
     udi_cdc_nb_data_enabled--;
-//  port = udi_cdc_nb_data_enabled;
-//  UDI_CDC_DISABLE_EXT(port);
+    //  port = udi_cdc_nb_data_enabled;
+    //  UDI_CDC_DISABLE_EXT(port);
     udi_cdc_data_running = false;
 }
 
-bool udi_cdc_comm_setup(void)
-{
+bool udi_cdc_comm_setup(void) {
     uint8_t port = udi_cdc_setup_to_port();
 
     if (Udd_setup_is_in()) {
@@ -397,17 +384,12 @@ bool udi_cdc_comm_setup(void)
         if (Udd_setup_type() == USB_REQ_TYPE_CLASS) {
             // Requests Class Interface Get
             switch (udd_g_ctrlreq.req.bRequest) {
-            case USB_REQ_CDC_GET_LINE_CODING:
-                // Get configuration of CDC line
-                if (sizeof(usb_cdc_line_coding_t) !=
-                        udd_g_ctrlreq.req.wLength)
-                    return false; // Error for USB host
-                udd_g_ctrlreq.payload =
-                        (uint8_t *) &
-                        udi_cdc_line_coding[port];
-                udd_g_ctrlreq.payload_size =
-                        sizeof(usb_cdc_line_coding_t);
-                return true;
+                case USB_REQ_CDC_GET_LINE_CODING:
+                    // Get configuration of CDC line
+                    if (sizeof(usb_cdc_line_coding_t) != udd_g_ctrlreq.req.wLength) return false;  // Error for USB host
+                    udd_g_ctrlreq.payload      = (uint8_t *)&udi_cdc_line_coding[port];
+                    udd_g_ctrlreq.payload_size = sizeof(usb_cdc_line_coding_t);
+                    return true;
             }
         }
     }
@@ -416,46 +398,37 @@ bool udi_cdc_comm_setup(void)
         if (Udd_setup_type() == USB_REQ_TYPE_CLASS) {
             // Requests Class Interface Set
             switch (udd_g_ctrlreq.req.bRequest) {
-            case USB_REQ_CDC_SET_LINE_CODING:
-                // Change configuration of CDC line
-                if (sizeof(usb_cdc_line_coding_t) !=
-                        udd_g_ctrlreq.req.wLength)
-                    return false; // Error for USB host
-                udd_g_ctrlreq.callback =
-                        udi_cdc_line_coding_received;
-                udd_g_ctrlreq.payload =
-                        (uint8_t *) &
-                        udi_cdc_line_coding[port];
-                udd_g_ctrlreq.payload_size =
-                        sizeof(usb_cdc_line_coding_t);
-                return true;
-            case USB_REQ_CDC_SET_CONTROL_LINE_STATE:
-                // According cdc spec 1.1 chapter 6.2.14
-//              UDI_CDC_SET_DTR_EXT(port, (0 !=
-//                      (udd_g_ctrlreq.req.wValue
-//                       & CDC_CTRL_SIGNAL_DTE_PRESENT)));
-//              UDI_CDC_SET_RTS_EXT(port, (0 !=
-//                      (udd_g_ctrlreq.req.wValue
-//                       & CDC_CTRL_SIGNAL_ACTIVATE_CARRIER)));
-                return true;
+                case USB_REQ_CDC_SET_LINE_CODING:
+                    // Change configuration of CDC line
+                    if (sizeof(usb_cdc_line_coding_t) != udd_g_ctrlreq.req.wLength) return false;  // Error for USB host
+                    udd_g_ctrlreq.callback     = udi_cdc_line_coding_received;
+                    udd_g_ctrlreq.payload      = (uint8_t *)&udi_cdc_line_coding[port];
+                    udd_g_ctrlreq.payload_size = sizeof(usb_cdc_line_coding_t);
+                    return true;
+                case USB_REQ_CDC_SET_CONTROL_LINE_STATE:
+                    // According cdc spec 1.1 chapter 6.2.14
+                    //              UDI_CDC_SET_DTR_EXT(port, (0 !=
+                    //                      (udd_g_ctrlreq.req.wValue
+                    //                       & CDC_CTRL_SIGNAL_DTE_PRESENT)));
+                    //              UDI_CDC_SET_RTS_EXT(port, (0 !=
+                    //                      (udd_g_ctrlreq.req.wValue
+                    //                       & CDC_CTRL_SIGNAL_ACTIVATE_CARRIER)));
+                    return true;
             }
         }
     }
     return false;  // request Not supported
 }
 
-bool udi_cdc_data_setup(void)
-{
+bool udi_cdc_data_setup(void) {
     return false;  // request Not supported
 }
 
-uint8_t udi_cdc_getsetting(void)
-{
-    return 0;      // CDC don't have multiple alternate setting
+uint8_t udi_cdc_getsetting(void) {
+    return 0;  // CDC don't have multiple alternate setting
 }
 
-void udi_cdc_data_sof_notify(void)
-{
+void udi_cdc_data_sof_notify(void) {
     static uint8_t port_notify = 0;
 
     // A call of udi_cdc_data_sof_notify() is done for each port
@@ -470,12 +443,10 @@ void udi_cdc_data_sof_notify(void)
     */
 }
 
-
 //-------------------------------------------------
 //------- Internal routines to control serial line
 
-static uint8_t udi_cdc_setup_to_port(void)
-{
+static uint8_t udi_cdc_setup_to_port(void) {
     uint8_t port;
 
     /*
@@ -496,35 +467,32 @@ static uint8_t udi_cdc_setup_to_port(void)
     return port;
 }
 
-static void udi_cdc_line_coding_received(void)
-{
+static void udi_cdc_line_coding_received(void) {
     uint8_t port = udi_cdc_setup_to_port();
     UNUSED(port);
 
-//  UDI_CDC_SET_CODING_EXT(port, (&udi_cdc_line_coding[port]));
+    //  UDI_CDC_SET_CODING_EXT(port, (&udi_cdc_line_coding[port]));
 }
 
-static void udi_cdc_ctrl_state_change(uint8_t port, bool b_set, le16_t bit_mask)
-{
+static void udi_cdc_ctrl_state_change(uint8_t port, bool b_set, le16_t bit_mask) {
     udd_ep_id_t ep_comm;
-    uint32_t irqflags;  //irqflags_t
-
+    uint32_t    irqflags;  // irqflags_t
 
-//#if UDI_CDC_PORT_NB == 1 // To optimize code
+    //#if UDI_CDC_PORT_NB == 1 // To optimize code
     port = 0;
-//#endif
+    //#endif
 
     // Update state
-  irqflags = __get_PRIMASK();
-  __disable_irq();
-  __DMB();
+    irqflags = __get_PRIMASK();
+    __disable_irq();
+    __DMB();
     if (b_set) {
         udi_cdc_state[port] |= bit_mask;
     } else {
         udi_cdc_state[port] &= ~(unsigned)bit_mask;
     }
     __DMB();
-  __set_PRIMASK(irqflags);
+    __set_PRIMASK(irqflags);
 
     /*
     // Send it if possible and state changed
@@ -545,31 +513,21 @@ static void udi_cdc_ctrl_state_change(uint8_t port, bool b_set, le16_t bit_mask)
     udi_cdc_ctrl_state_notify(port, ep_comm);
 }
 
-
-static void udi_cdc_ctrl_state_notify(uint8_t port, udd_ep_id_t ep)
-{
-#if UDI_CDC_PORT_NB == 1 // To optimize code
+static void udi_cdc_ctrl_state_notify(uint8_t port, udd_ep_id_t ep) {
+#    if UDI_CDC_PORT_NB == 1  // To optimize code
     port = 0;
-#endif
+#    endif
 
     // Send it if possible and state changed
-    if ((!udi_cdc_serial_state_msg_ongoing[port])
-            && (udi_cdc_state[port] != uid_cdc_state_msg[port].value)) {
+    if ((!udi_cdc_serial_state_msg_ongoing[port]) && (udi_cdc_state[port] != uid_cdc_state_msg[port].value)) {
         // Fill notification message
         uid_cdc_state_msg[port].value = udi_cdc_state[port];
         // Send notification message
-        udi_cdc_serial_state_msg_ongoing[port] =
-                udd_ep_run(ep,
-                false,
-                (uint8_t *) & uid_cdc_state_msg[port],
-                sizeof(uid_cdc_state_msg[0]),
-                udi_cdc_serial_state_msg_sent);
+        udi_cdc_serial_state_msg_ongoing[port] = udd_ep_run(ep, false, (uint8_t *)&uid_cdc_state_msg[port], sizeof(uid_cdc_state_msg[0]), udi_cdc_serial_state_msg_sent);
     }
 }
 
-
-static void udi_cdc_serial_state_msg_sent(udd_ep_status_t status, iram_size_t n, udd_ep_id_t ep)
-{
+static void udi_cdc_serial_state_msg_sent(udd_ep_status_t status, iram_size_t n, udd_ep_id_t ep) {
     uint8_t port;
     UNUSED(n);
     UNUSED(status);
@@ -594,14 +552,8 @@ static void udi_cdc_serial_state_msg_sent(udd_ep_status_t status, iram_size_t n,
     // For the irregular signals like break, the incoming ring signal,
     // or the overrun error state, this will reset their values to zero
     // and again will not send another notification until their state changes.
-    udi_cdc_state[port] &= ~(CDC_SERIAL_STATE_BREAK |
-            CDC_SERIAL_STATE_RING |
-            CDC_SERIAL_STATE_FRAMING |
-            CDC_SERIAL_STATE_PARITY | CDC_SERIAL_STATE_OVERRUN);
-    uid_cdc_state_msg[port].value &= ~(CDC_SERIAL_STATE_BREAK |
-            CDC_SERIAL_STATE_RING |
-            CDC_SERIAL_STATE_FRAMING |
-            CDC_SERIAL_STATE_PARITY | CDC_SERIAL_STATE_OVERRUN);
+    udi_cdc_state[port] &= ~(CDC_SERIAL_STATE_BREAK | CDC_SERIAL_STATE_RING | CDC_SERIAL_STATE_FRAMING | CDC_SERIAL_STATE_PARITY | CDC_SERIAL_STATE_OVERRUN);
+    uid_cdc_state_msg[port].value &= ~(CDC_SERIAL_STATE_BREAK | CDC_SERIAL_STATE_RING | CDC_SERIAL_STATE_FRAMING | CDC_SERIAL_STATE_PARITY | CDC_SERIAL_STATE_OVERRUN);
     // Send it if possible and state changed
     udi_cdc_ctrl_state_notify(port, ep);
 }
@@ -609,39 +561,37 @@ static void udi_cdc_serial_state_msg_sent(udd_ep_status_t status, iram_size_t n,
 //-------------------------------------------------
 //------- Internal routines to process data transfer
 
-static bool udi_cdc_rx_start(uint8_t port)
-{
-    uint32_t irqflags;  //irqflags_t
-    uint8_t buf_sel_trans;
+static bool udi_cdc_rx_start(uint8_t port) {
+    uint32_t    irqflags;  // irqflags_t
+    uint8_t     buf_sel_trans;
     udd_ep_id_t ep;
 
-//#if UDI_CDC_PORT_NB == 1 // To optimize code
+    //#if UDI_CDC_PORT_NB == 1 // To optimize code
     port = 0;
-//#endif
+    //#endif
 
     irqflags = __get_PRIMASK();
-  __disable_irq();
-  __DMB();
+    __disable_irq();
+    __DMB();
     buf_sel_trans = udi_cdc_rx_buf_sel[port];
-    if (udi_cdc_rx_trans_ongoing[port] ||
-        (udi_cdc_rx_pos[port] < udi_cdc_rx_buf_nb[port][buf_sel_trans])) {
+    if (udi_cdc_rx_trans_ongoing[port] || (udi_cdc_rx_pos[port] < udi_cdc_rx_buf_nb[port][buf_sel_trans])) {
         // Transfer already on-going or current buffer no empty
-      __DMB();
-    __set_PRIMASK(irqflags);
+        __DMB();
+        __set_PRIMASK(irqflags);
         return false;
     }
 
     // Change current buffer
-    udi_cdc_rx_pos[port] = 0;
-    udi_cdc_rx_buf_sel[port] = (buf_sel_trans==0)?1:0;
+    udi_cdc_rx_pos[port]     = 0;
+    udi_cdc_rx_buf_sel[port] = (buf_sel_trans == 0) ? 1 : 0;
 
     // Start transfer on RX
     udi_cdc_rx_trans_ongoing[port] = true;
-  __DMB();
-  __set_PRIMASK(irqflags);
+    __DMB();
+    __set_PRIMASK(irqflags);
 
     if (udi_cdc_multi_is_rx_ready(port)) {
-//      UDI_CDC_RX_NOTIFY(port);
+        //      UDI_CDC_RX_NOTIFY(port);
     }
 
     /*
@@ -660,15 +610,10 @@ static bool udi_cdc_rx_start(uint8_t port)
     */
     ep = UDI_CDC_DATA_EP_OUT_0;
 
-    return udd_ep_run(ep,
-            true,
-            udi_cdc_rx_buf[port][buf_sel_trans],
-            UDI_CDC_RX_BUFFERS,
-            udi_cdc_data_received);
+    return udd_ep_run(ep, true, udi_cdc_rx_buf[port][buf_sel_trans], UDI_CDC_RX_BUFFERS, udi_cdc_data_received);
 }
 
-static void udi_cdc_data_received(udd_ep_status_t status, iram_size_t n, udd_ep_id_t ep)
-{
+static void udi_cdc_data_received(udd_ep_status_t status, iram_size_t n, udd_ep_id_t ep) {
     uint8_t buf_sel_trans;
     uint8_t port;
 
@@ -692,24 +637,19 @@ static void udi_cdc_data_received(udd_ep_status_t status, iram_size_t n, udd_ep_
         return;
     }
 
-    buf_sel_trans = (udi_cdc_rx_buf_sel[port]==0)?1:0;
+    buf_sel_trans = (udi_cdc_rx_buf_sel[port] == 0) ? 1 : 0;
 
     if (!n) {
-        udd_ep_run( ep,
-                true,
-                udi_cdc_rx_buf[port][buf_sel_trans],
-                UDI_CDC_RX_BUFFERS,
-                udi_cdc_data_received);
+        udd_ep_run(ep, true, udi_cdc_rx_buf[port][buf_sel_trans], UDI_CDC_RX_BUFFERS, udi_cdc_data_received);
         return;
     }
 
     udi_cdc_rx_buf_nb[port][buf_sel_trans] = n;
-    udi_cdc_rx_trans_ongoing[port] = false;
+    udi_cdc_rx_trans_ongoing[port]         = false;
     udi_cdc_rx_start(port);
 }
 
-static void udi_cdc_data_sent(udd_ep_status_t status, iram_size_t n, udd_ep_id_t ep)
-{
+static void udi_cdc_data_sent(udd_ep_status_t status, iram_size_t n, udd_ep_id_t ep) {
     uint8_t port;
     UNUSED(n);
 
@@ -733,9 +673,9 @@ static void udi_cdc_data_sent(udd_ep_status_t status, iram_size_t n, udd_ep_id_t
         return;
     }
 
-    udi_cdc_tx_buf_nb[port][(udi_cdc_tx_buf_sel[port]==0)?1:0] = 0;
-    udi_cdc_tx_both_buf_to_send[port] = false;
-    udi_cdc_tx_trans_ongoing[port] = false;
+    udi_cdc_tx_buf_nb[port][(udi_cdc_tx_buf_sel[port] == 0) ? 1 : 0] = 0;
+    udi_cdc_tx_both_buf_to_send[port]                                = false;
+    udi_cdc_tx_trans_ongoing[port]                                   = false;
 
     if (n != 0) {
         UDI_CDC_TX_EMPTY_NOTIFY(port);
@@ -744,41 +684,39 @@ static void udi_cdc_data_sent(udd_ep_status_t status, iram_size_t n, udd_ep_id_t
     udi_cdc_tx_send(port);
 }
 
-static void udi_cdc_tx_send(uint8_t port)
-{
-    uint32_t irqflags;  //irqflags_t
-    uint8_t buf_sel_trans;
-    bool b_short_packet;
-    udd_ep_id_t ep;
+static void udi_cdc_tx_send(uint8_t port) {
+    uint32_t        irqflags;  // irqflags_t
+    uint8_t         buf_sel_trans;
+    bool            b_short_packet;
+    udd_ep_id_t     ep;
     static uint16_t sof_zlp_counter = 0;
 
-//#if UDI_CDC_PORT_NB == 1 // To optimize code
+    //#if UDI_CDC_PORT_NB == 1 // To optimize code
     port = 0;
-//#endif
+    //#endif
 
     if (udi_cdc_tx_trans_ongoing[port]) {
-        return; // Already on going or wait next SOF to send next data
+        return;  // Already on going or wait next SOF to send next data
     }
     if (udd_is_high_speed()) {
         if (udi_cdc_tx_sof_num[port] == udd_get_micro_frame_number()) {
-            return; // Wait next SOF to send next data
+            return;  // Wait next SOF to send next data
         }
-    }else{
+    } else {
         if (udi_cdc_tx_sof_num[port] == udd_get_frame_number()) {
-            return; // Wait next SOF to send next data
+            return;  // Wait next SOF to send next data
         }
     }
 
     irqflags = __get_PRIMASK();
-  __disable_irq();
-  __DMB();
+    __disable_irq();
+    __DMB();
     buf_sel_trans = udi_cdc_tx_buf_sel[port];
     if (udi_cdc_tx_buf_nb[port][buf_sel_trans] == 0) {
         sof_zlp_counter++;
-        if (((!udd_is_high_speed()) && (sof_zlp_counter < 100))
-                || (udd_is_high_speed() && (sof_zlp_counter < 800))) {
-      __DMB();
-    __set_PRIMASK(irqflags);
+        if (((!udd_is_high_speed()) && (sof_zlp_counter < 100)) || (udd_is_high_speed() && (sof_zlp_counter < 800))) {
+            __DMB();
+            __set_PRIMASK(irqflags);
             return;
         }
     }
@@ -787,25 +725,25 @@ static void udi_cdc_tx_send(uint8_t port)
     if (!udi_cdc_tx_both_buf_to_send[port]) {
         // Send current Buffer
         // and switch the current buffer
-        udi_cdc_tx_buf_sel[port] = (buf_sel_trans==0)?1:0;
-    }else{
+        udi_cdc_tx_buf_sel[port] = (buf_sel_trans == 0) ? 1 : 0;
+    } else {
         // Send the other Buffer
         // and no switch the current buffer
-        buf_sel_trans = (buf_sel_trans==0)?1:0;
+        buf_sel_trans = (buf_sel_trans == 0) ? 1 : 0;
     }
     udi_cdc_tx_trans_ongoing[port] = true;
-  __DMB();
-  __set_PRIMASK(irqflags);
+    __DMB();
+    __set_PRIMASK(irqflags);
 
     b_short_packet = (udi_cdc_tx_buf_nb[port][buf_sel_trans] != UDI_CDC_TX_BUFFERS);
     if (b_short_packet) {
         if (udd_is_high_speed()) {
             udi_cdc_tx_sof_num[port] = udd_get_micro_frame_number();
-        }else{
+        } else {
             udi_cdc_tx_sof_num[port] = udd_get_frame_number();
         }
-    }else{
-        udi_cdc_tx_sof_num[port] = 0; // Force next transfer without wait SOF
+    } else {
+        udi_cdc_tx_sof_num[port] = 0;  // Force next transfer without wait SOF
     }
 
     /*
@@ -824,126 +762,81 @@ static void udi_cdc_tx_send(uint8_t port)
     */
     ep = UDI_CDC_DATA_EP_IN_0;
 
-    udd_ep_run( ep,
-            b_short_packet,
-            udi_cdc_tx_buf[port][buf_sel_trans],
-            udi_cdc_tx_buf_nb[port][buf_sel_trans],
-            udi_cdc_data_sent);
+    udd_ep_run(ep, b_short_packet, udi_cdc_tx_buf[port][buf_sel_trans], udi_cdc_tx_buf_nb[port][buf_sel_trans], udi_cdc_data_sent);
 }
 
 //---------------------------------------------
 //------- Application interface
 
-void udi_cdc_ctrl_signal_dcd(bool b_set)
-{
-    udi_cdc_ctrl_state_change(0, b_set, CDC_SERIAL_STATE_DCD);
-}
+void udi_cdc_ctrl_signal_dcd(bool b_set) { udi_cdc_ctrl_state_change(0, b_set, CDC_SERIAL_STATE_DCD); }
 
-void udi_cdc_ctrl_signal_dsr(bool b_set)
-{
-    udi_cdc_ctrl_state_change(0, b_set, CDC_SERIAL_STATE_DSR);
-}
+void udi_cdc_ctrl_signal_dsr(bool b_set) { udi_cdc_ctrl_state_change(0, b_set, CDC_SERIAL_STATE_DSR); }
 
-void udi_cdc_signal_framing_error(void)
-{
-    udi_cdc_ctrl_state_change(0, true, CDC_SERIAL_STATE_FRAMING);
-}
+void udi_cdc_signal_framing_error(void) { udi_cdc_ctrl_state_change(0, true, CDC_SERIAL_STATE_FRAMING); }
 
-void udi_cdc_signal_parity_error(void)
-{
-    udi_cdc_ctrl_state_change(0, true, CDC_SERIAL_STATE_PARITY);
-}
+void udi_cdc_signal_parity_error(void) { udi_cdc_ctrl_state_change(0, true, CDC_SERIAL_STATE_PARITY); }
 
-void udi_cdc_signal_overrun(void)
-{
-    udi_cdc_ctrl_state_change(0, true, CDC_SERIAL_STATE_OVERRUN);
-}
+void udi_cdc_signal_overrun(void) { udi_cdc_ctrl_state_change(0, true, CDC_SERIAL_STATE_OVERRUN); }
 
-void udi_cdc_multi_ctrl_signal_dcd(uint8_t port, bool b_set)
-{
-    udi_cdc_ctrl_state_change(port, b_set, CDC_SERIAL_STATE_DCD);
-}
+void udi_cdc_multi_ctrl_signal_dcd(uint8_t port, bool b_set) { udi_cdc_ctrl_state_change(port, b_set, CDC_SERIAL_STATE_DCD); }
 
-void udi_cdc_multi_ctrl_signal_dsr(uint8_t port, bool b_set)
-{
-    udi_cdc_ctrl_state_change(port, b_set, CDC_SERIAL_STATE_DSR);
-}
+void udi_cdc_multi_ctrl_signal_dsr(uint8_t port, bool b_set) { udi_cdc_ctrl_state_change(port, b_set, CDC_SERIAL_STATE_DSR); }
 
-void udi_cdc_multi_signal_framing_error(uint8_t port)
-{
-    udi_cdc_ctrl_state_change(port, true, CDC_SERIAL_STATE_FRAMING);
-}
+void udi_cdc_multi_signal_framing_error(uint8_t port) { udi_cdc_ctrl_state_change(port, true, CDC_SERIAL_STATE_FRAMING); }
 
-void udi_cdc_multi_signal_parity_error(uint8_t port)
-{
-    udi_cdc_ctrl_state_change(port, true, CDC_SERIAL_STATE_PARITY);
-}
+void udi_cdc_multi_signal_parity_error(uint8_t port) { udi_cdc_ctrl_state_change(port, true, CDC_SERIAL_STATE_PARITY); }
 
-void udi_cdc_multi_signal_overrun(uint8_t port)
-{
-    udi_cdc_ctrl_state_change(port, true, CDC_SERIAL_STATE_OVERRUN);
-}
+void udi_cdc_multi_signal_overrun(uint8_t port) { udi_cdc_ctrl_state_change(port, true, CDC_SERIAL_STATE_OVERRUN); }
 
-iram_size_t udi_cdc_multi_get_nb_received_data(uint8_t port)
-{
-    uint32_t irqflags;  //irqflags_t
-    uint16_t pos;
+iram_size_t udi_cdc_multi_get_nb_received_data(uint8_t port) {
+    uint32_t    irqflags;  // irqflags_t
+    uint16_t    pos;
     iram_size_t nb_received;
 
-//#if UDI_CDC_PORT_NB == 1 // To optimize code
+    //#if UDI_CDC_PORT_NB == 1 // To optimize code
     port = 0;
-//#endif
+    //#endif
 
     irqflags = __get_PRIMASK();
-  __disable_irq();
-  __DMB();
-    pos = udi_cdc_rx_pos[port];
+    __disable_irq();
+    __DMB();
+    pos         = udi_cdc_rx_pos[port];
     nb_received = udi_cdc_rx_buf_nb[port][udi_cdc_rx_buf_sel[port]] - pos;
     __DMB();
-  __set_PRIMASK(irqflags);
+    __set_PRIMASK(irqflags);
     return nb_received;
 }
 
-iram_size_t udi_cdc_get_nb_received_data(void)
-{
-    return udi_cdc_multi_get_nb_received_data(0);
-}
+iram_size_t udi_cdc_get_nb_received_data(void) { return udi_cdc_multi_get_nb_received_data(0); }
 
-bool udi_cdc_multi_is_rx_ready(uint8_t port)
-{
-    return (udi_cdc_multi_get_nb_received_data(port) > 0);
-}
+bool udi_cdc_multi_is_rx_ready(uint8_t port) { return (udi_cdc_multi_get_nb_received_data(port) > 0); }
 
-bool udi_cdc_is_rx_ready(void)
-{
-    return udi_cdc_multi_is_rx_ready(0);
-}
+bool udi_cdc_is_rx_ready(void) { return udi_cdc_multi_is_rx_ready(0); }
 
-int udi_cdc_multi_getc(uint8_t port)
-{
-    uint32_t irqflags;  //irqflags_t
-    int rx_data = 0;
-    bool b_databit_9;
+int udi_cdc_multi_getc(uint8_t port) {
+    uint32_t irqflags;  // irqflags_t
+    int      rx_data = 0;
+    bool     b_databit_9;
     uint16_t pos;
-    uint8_t buf_sel;
-    bool again;
+    uint8_t  buf_sel;
+    bool     again;
 
-//#if UDI_CDC_PORT_NB == 1 // To optimize code
+    //#if UDI_CDC_PORT_NB == 1 // To optimize code
     port = 0;
-//#endif
+    //#endif
 
     b_databit_9 = (9 == udi_cdc_line_coding[port].bDataBits);
 
 udi_cdc_getc_process_one_byte:
     // Check available data
     irqflags = __get_PRIMASK();
-  __disable_irq();
-  __DMB();
-    pos = udi_cdc_rx_pos[port];
+    __disable_irq();
+    __DMB();
+    pos     = udi_cdc_rx_pos[port];
     buf_sel = udi_cdc_rx_buf_sel[port];
-    again = pos >= udi_cdc_rx_buf_nb[port][buf_sel];
+    again   = pos >= udi_cdc_rx_buf_nb[port][buf_sel];
     __DMB();
-  __set_PRIMASK(irqflags);
+    __set_PRIMASK(irqflags);
     while (again) {
         if (!udi_cdc_data_running) {
             return 0;
@@ -953,46 +846,43 @@ udi_cdc_getc_process_one_byte:
 
     // Read data
     rx_data |= udi_cdc_rx_buf[port][buf_sel][pos];
-    udi_cdc_rx_pos[port] = pos+1;
+    udi_cdc_rx_pos[port] = pos + 1;
 
     udi_cdc_rx_start(port);
 
     if (b_databit_9) {
         // Receive MSB
         b_databit_9 = false;
-        rx_data = rx_data << 8;
+        rx_data     = rx_data << 8;
         goto udi_cdc_getc_process_one_byte;
     }
     return rx_data;
 }
 
-int udi_cdc_getc(void)
-{
-    return udi_cdc_multi_getc(0);
-}
+int udi_cdc_getc(void) { return udi_cdc_multi_getc(0); }
 
-iram_size_t udi_cdc_multi_read_buf(uint8_t port, void* buf, iram_size_t size)
-{
-    uint32_t irqflags;  //irqflags_t
-    uint8_t *ptr_buf = (uint8_t *)buf;
+iram_size_t udi_cdc_multi_read_buf(uint8_t port, void *buf, iram_size_t size) {
+    uint32_t    irqflags;  // irqflags_t
+    uint8_t *   ptr_buf = (uint8_t *)buf;
     iram_size_t copy_nb;
-    uint16_t pos;
-    uint8_t buf_sel;
-    bool again;
+    uint16_t    pos;
+    uint8_t     buf_sel;
+    bool        again;
 
-//#if UDI_CDC_PORT_NB == 1 // To optimize code
+    //#if UDI_CDC_PORT_NB == 1 // To optimize code
     port = 0;
-//#endif
+    //#endif
 
 udi_cdc_read_buf_loop_wait:
     // Check available data
     irqflags = __get_PRIMASK();
-  __disable_irq();
-  __DMB();  pos = udi_cdc_rx_pos[port];
+    __disable_irq();
+    __DMB();
+    pos     = udi_cdc_rx_pos[port];
     buf_sel = udi_cdc_rx_buf_sel[port];
-    again = pos >= udi_cdc_rx_buf_nb[port][buf_sel];
+    again   = pos >= udi_cdc_rx_buf_nb[port][buf_sel];
     __DMB();
-  __set_PRIMASK(irqflags);
+    __set_PRIMASK(irqflags);
     while (again) {
         if (!udi_cdc_data_running) {
             return size;
@@ -1002,7 +892,7 @@ udi_cdc_read_buf_loop_wait:
 
     // Read data
     copy_nb = udi_cdc_rx_buf_nb[port][buf_sel] - pos;
-    if (copy_nb>size) {
+    if (copy_nb > size) {
         copy_nb = size;
     }
     memcpy(ptr_buf, &udi_cdc_rx_buf[port][buf_sel][pos], copy_nb);
@@ -1017,118 +907,99 @@ udi_cdc_read_buf_loop_wait:
     return 0;
 }
 
-static iram_size_t udi_cdc_multi_read_no_polling(uint8_t port, void* buf, iram_size_t size)
-{
-    uint8_t *ptr_buf = (uint8_t *)buf;
+static iram_size_t udi_cdc_multi_read_no_polling(uint8_t port, void *buf, iram_size_t size) {
+    uint8_t *   ptr_buf = (uint8_t *)buf;
     iram_size_t nb_avail_data;
-    uint16_t pos;
-    uint8_t buf_sel;
-    uint32_t irqflags;  //irqflags_t
+    uint16_t    pos;
+    uint8_t     buf_sel;
+    uint32_t    irqflags;  // irqflags_t
 
-//#if UDI_CDC_PORT_NB == 1 // To optimize code
+    //#if UDI_CDC_PORT_NB == 1 // To optimize code
     port = 0;
-//#endif
+    //#endif
 
-    //Data interface not started... exit
+    // Data interface not started... exit
     if (!udi_cdc_data_running) {
         return 0;
     }
 
-    //Get number of available data
+    // Get number of available data
     // Check available data
     irqflags = __get_PRIMASK();
-  __disable_irq();
-  __DMB();
-    pos = udi_cdc_rx_pos[port];
-    buf_sel = udi_cdc_rx_buf_sel[port];
+    __disable_irq();
+    __DMB();
+    pos           = udi_cdc_rx_pos[port];
+    buf_sel       = udi_cdc_rx_buf_sel[port];
     nb_avail_data = udi_cdc_rx_buf_nb[port][buf_sel] - pos;
     __DMB();
-  __set_PRIMASK(irqflags);
-    //If the buffer contains less than the requested number of data,
-    //adjust read size
-    if(nb_avail_data<size) {
+    __set_PRIMASK(irqflags);
+    // If the buffer contains less than the requested number of data,
+    // adjust read size
+    if (nb_avail_data < size) {
         size = nb_avail_data;
     }
-    if(size>0) {
+    if (size > 0) {
         memcpy(ptr_buf, &udi_cdc_rx_buf[port][buf_sel][pos], size);
-    irqflags = __get_PRIMASK();
-    __disable_irq();
-    __DMB();
+        irqflags = __get_PRIMASK();
+        __disable_irq();
+        __DMB();
         udi_cdc_rx_pos[port] += size;
-    __DMB();
-    __set_PRIMASK(irqflags);
+        __DMB();
+        __set_PRIMASK(irqflags);
         ptr_buf += size;
         udi_cdc_rx_start(port);
     }
-    return(nb_avail_data);
+    return (nb_avail_data);
 }
 
-iram_size_t udi_cdc_read_no_polling(void* buf, iram_size_t size)
-{
-    return udi_cdc_multi_read_no_polling(0, buf, size);
-}
+iram_size_t udi_cdc_read_no_polling(void *buf, iram_size_t size) { return udi_cdc_multi_read_no_polling(0, buf, size); }
 
-iram_size_t udi_cdc_read_buf(void* buf, iram_size_t size)
-{
-    return udi_cdc_multi_read_buf(0, buf, size);
-}
+iram_size_t udi_cdc_read_buf(void *buf, iram_size_t size) { return udi_cdc_multi_read_buf(0, buf, size); }
 
-iram_size_t udi_cdc_multi_get_free_tx_buffer(uint8_t port)
-{
-    uint32_t irqflags;  //irqflags_t
+iram_size_t udi_cdc_multi_get_free_tx_buffer(uint8_t port) {
+    uint32_t    irqflags;  // irqflags_t
     iram_size_t buf_sel_nb, retval;
-    uint8_t buf_sel;
+    uint8_t     buf_sel;
 
-//#if UDI_CDC_PORT_NB == 1 // To optimize code
+    //#if UDI_CDC_PORT_NB == 1 // To optimize code
     port = 0;
-//#endif
+    //#endif
 
     irqflags = __get_PRIMASK();
-  __disable_irq();
-  __DMB();
-    buf_sel = udi_cdc_tx_buf_sel[port];
+    __disable_irq();
+    __DMB();
+    buf_sel    = udi_cdc_tx_buf_sel[port];
     buf_sel_nb = udi_cdc_tx_buf_nb[port][buf_sel];
     if (buf_sel_nb == UDI_CDC_TX_BUFFERS) {
-        if ((!udi_cdc_tx_trans_ongoing[port])
-            && (!udi_cdc_tx_both_buf_to_send[port])) {
+        if ((!udi_cdc_tx_trans_ongoing[port]) && (!udi_cdc_tx_both_buf_to_send[port])) {
             /* One buffer is full, but the other buffer is not used.
              * (not used = transfer on-going)
              * then move to the other buffer to store data */
             udi_cdc_tx_both_buf_to_send[port] = true;
-            udi_cdc_tx_buf_sel[port] = (buf_sel == 0)? 1 : 0;
-            buf_sel_nb = 0;
+            udi_cdc_tx_buf_sel[port]          = (buf_sel == 0) ? 1 : 0;
+            buf_sel_nb                        = 0;
         }
     }
     retval = UDI_CDC_TX_BUFFERS - buf_sel_nb;
     __DMB();
-  __set_PRIMASK(irqflags);
+    __set_PRIMASK(irqflags);
     return retval;
 }
 
-iram_size_t udi_cdc_get_free_tx_buffer(void)
-{
-    return udi_cdc_multi_get_free_tx_buffer(0);
-}
+iram_size_t udi_cdc_get_free_tx_buffer(void) { return udi_cdc_multi_get_free_tx_buffer(0); }
 
-bool udi_cdc_multi_is_tx_ready(uint8_t port)
-{
-    return (udi_cdc_multi_get_free_tx_buffer(port) != 0);
-}
+bool udi_cdc_multi_is_tx_ready(uint8_t port) { return (udi_cdc_multi_get_free_tx_buffer(port) != 0); }
 
-bool udi_cdc_is_tx_ready(void)
-{
-    return udi_cdc_multi_is_tx_ready(0);
-}
+bool udi_cdc_is_tx_ready(void) { return udi_cdc_multi_is_tx_ready(0); }
 
-int udi_cdc_multi_putc(uint8_t port, int value)
-{
-    uint32_t irqflags;  //irqflags_t
-    bool b_databit_9;
-    uint8_t buf_sel;
+int udi_cdc_multi_putc(uint8_t port, int value) {
+    uint32_t irqflags;  // irqflags_t
+    bool     b_databit_9;
+    uint8_t  buf_sel;
 
-//#if UDI_CDC_PORT_NB == 1 // To optimize code
+    //#if UDI_CDC_PORT_NB == 1 // To optimize code
     port = 0;
-//#endif
+    //#endif
 
     b_databit_9 = (9 == udi_cdc_line_coding[port].bDataBits);
 
@@ -1143,44 +1014,40 @@ udi_cdc_putc_process_one_byte:
 
     // Write value
     irqflags = __get_PRIMASK();
-  __disable_irq();
-  __DMB();
-    buf_sel = udi_cdc_tx_buf_sel[port];
+    __disable_irq();
+    __DMB();
+    buf_sel                                                           = udi_cdc_tx_buf_sel[port];
     udi_cdc_tx_buf[port][buf_sel][udi_cdc_tx_buf_nb[port][buf_sel]++] = value;
-  __DMB();
-  __set_PRIMASK(irqflags);
+    __DMB();
+    __set_PRIMASK(irqflags);
 
     if (b_databit_9) {
         // Send MSB
         b_databit_9 = false;
-        value = value >> 8;
+        value       = value >> 8;
         goto udi_cdc_putc_process_one_byte;
     }
     return true;
 }
 
-int udi_cdc_putc(int value)
-{
-    return udi_cdc_multi_putc(0, value);
-}
+int udi_cdc_putc(int value) { return udi_cdc_multi_putc(0, value); }
 
-iram_size_t udi_cdc_multi_write_buf(uint8_t port, const void* buf, iram_size_t size)
-{
-    uint32_t irqflags;  //irqflags_t
-    uint8_t buf_sel;
-    uint16_t buf_nb;
+iram_size_t udi_cdc_multi_write_buf(uint8_t port, const void *buf, iram_size_t size) {
+    uint32_t    irqflags;  // irqflags_t
+    uint8_t     buf_sel;
+    uint16_t    buf_nb;
     iram_size_t copy_nb;
-    uint8_t *ptr_buf = (uint8_t *)buf;
+    uint8_t *   ptr_buf = (uint8_t *)buf;
 
-//#if UDI_CDC_PORT_NB == 1 // To optimize code
+    //#if UDI_CDC_PORT_NB == 1 // To optimize code
     port = 0;
-//#endif
+    //#endif
 
     if (9 == udi_cdc_line_coding[port].bDataBits) {
-        size *=2;
+        size *= 2;
     }
 
-    udi_cdc_write_buf_loop_wait:
+udi_cdc_write_buf_loop_wait:
 
     // Check available space
     if (!udi_cdc_multi_is_tx_ready(port)) {
@@ -1195,7 +1062,7 @@ iram_size_t udi_cdc_multi_write_buf(uint8_t port, const void* buf, iram_size_t s
     __disable_irq();
     __DMB();
     buf_sel = udi_cdc_tx_buf_sel[port];
-    buf_nb = udi_cdc_tx_buf_nb[port][buf_sel];
+    buf_nb  = udi_cdc_tx_buf_nb[port][buf_sel];
     copy_nb = UDI_CDC_TX_BUFFERS - buf_nb;
     if (copy_nb > size) {
         copy_nb = size;
@@ -1216,43 +1083,36 @@ iram_size_t udi_cdc_multi_write_buf(uint8_t port, const void* buf, iram_size_t s
     return 0;
 }
 
-iram_size_t udi_cdc_write_buf(const void* buf, iram_size_t size)
-{
-    return udi_cdc_multi_write_buf(0, buf, size);
-}
+iram_size_t udi_cdc_write_buf(const void *buf, iram_size_t size) { return udi_cdc_multi_write_buf(0, buf, size); }
 
-#define MAX_PRINT 256
-#define CDC_SEND_INTERVAL 2
+#    define MAX_PRINT 256
+#    define CDC_SEND_INTERVAL 2
 uint32_t cdc_tx_send_time_next;
 
-void CDC_send(void)
-{
-    while (timer_read64() < cdc_tx_send_time_next);
+void CDC_send(void) {
+    while (timer_read64() < cdc_tx_send_time_next)
+        ;
     udi_cdc_tx_send(0);
     cdc_tx_send_time_next = timer_read64() + CDC_SEND_INTERVAL;
 }
 
-uint32_t CDC_print(char *printbuf)
-{
-    uint32_t count=0;
-    char *buf = printbuf;
-    char c;
+uint32_t CDC_print(char *printbuf) {
+    uint32_t count = 0;
+    char *   buf   = printbuf;
+    char     c;
 
     if (timer_read64() < 5000) return 0;
 
-    while ((c = *buf++) != 0 && !(count >= MAX_PRINT))
-    {
+    while ((c = *buf++) != 0 && !(count >= MAX_PRINT)) {
         count++;
         if (!udi_cdc_is_tx_ready()) return 0;
         udi_cdc_putc(c);
-        if (count >= UDI_CDC_TX_BUFFERS)
-        {
+        if (count >= UDI_CDC_TX_BUFFERS) {
             count = 0;
             CDC_send();
         }
     }
-    if (count)
-    {
+    if (count) {
         CDC_send();
     }
     return 1;
@@ -1260,12 +1120,11 @@ uint32_t CDC_print(char *printbuf)
 
 char printbuf[CDC_PRINTBUF_SIZE];
 
-int CDC_printf(const char *_Format, ...)
-{
-    va_list va; //Variable argument list variable
-    int result;
+int CDC_printf(const char *_Format, ...) {
+    va_list va;  // Variable argument list variable
+    int     result;
 
-    va_start(va, _Format); //Initialize the variable argument list
+    va_start(va, _Format);  // Initialize the variable argument list
     result = vsnprintf(printbuf, CDC_PRINTBUF_SIZE, _Format, va);
     va_end(va);
 
@@ -1274,107 +1133,83 @@ int CDC_printf(const char *_Format, ...)
     return result;
 }
 
-//global "inbuf" if desired
+// global "inbuf" if desired
 inbuf_t inbuf;
 
-uint32_t CDC_input_buf(inbuf_t inbuf, uint32_t inbuf_size)
-{
+uint32_t CDC_input_buf(inbuf_t inbuf, uint32_t inbuf_size) {
     int RXChar;
     int entered = 0;
 
     if (!udi_cdc_is_rx_ready()) return 0;
     udi_cdc_get_nb_received_data();
-    RXChar =  udi_cdc_getc();
-
-    if (RXChar)
-    {
-        switch (RXChar)
-        {
-            case '\t':  //tab - repeat last
-                inbuf.count=inbuf.lastcount;
-                inbuf.buf[inbuf.count+1] = 0;
+    RXChar = udi_cdc_getc();
+
+    if (RXChar) {
+        switch (RXChar) {
+            case '\t':  // tab - repeat last
+                inbuf.count                = inbuf.lastcount;
+                inbuf.buf[inbuf.count + 1] = 0;
                 CDC_print(inbuf.buf);
                 break;
-            case '\r':  //enter
-                inbuf.buf[inbuf.count]=0;
-                inbuf.lastcount = inbuf.count;
-                inbuf.count = 0;
-                entered = 1;
+            case '\r':  // enter
+                inbuf.buf[inbuf.count] = 0;
+                inbuf.lastcount        = inbuf.count;
+                inbuf.count            = 0;
+                entered                = 1;
                 break;
-            case '\b': //backspace
+            case '\b':  // backspace
                 if (inbuf.count > 0) {
                     inbuf.count -= 1;
                     CDC_print("\b \b\0");
-                }
-                else
+                } else
                     CDC_print("\a\0");
                 break;
-        default:
-            if ((RXChar >= 32) && (RXChar <= 126))
-            {
-                if (inbuf.count < inbuf_size-1)
-                {
-                    inbuf.buf[inbuf.count] = RXChar;
-                    inbuf.buf[inbuf.count+1] = 0;
-                    CDC_print(&inbuf.buf[inbuf.count]);
-                    inbuf.count += 1;
+            default:
+                if ((RXChar >= 32) && (RXChar <= 126)) {
+                    if (inbuf.count < inbuf_size - 1) {
+                        inbuf.buf[inbuf.count]     = RXChar;
+                        inbuf.buf[inbuf.count + 1] = 0;
+                        CDC_print(&inbuf.buf[inbuf.count]);
+                        inbuf.count += 1;
+                    } else
+                        CDC_print("\a\0");
                 }
-                else
-                    CDC_print("\a\0");
-            }
-            break;
+                break;
         }
         RXChar = 0;
     }
     return entered;
 }
 
-uint32_t CDC_input()
-{
-    return CDC_input_buf(inbuf, CDC_INBUF_SIZE);
-}
+uint32_t CDC_input() { return CDC_input_buf(inbuf, CDC_INBUF_SIZE); }
 
-void CDC_init(void)
-{
-    inbuf.count = 0;
-    inbuf.lastcount = 0;
-    printbuf[0] = 0;
+void CDC_init(void) {
+    inbuf.count           = 0;
+    inbuf.lastcount       = 0;
+    printbuf[0]           = 0;
     cdc_tx_send_time_next = timer_read64() + CDC_SEND_INTERVAL;
 }
 
-#else //CDC line 62
+#else  // CDC line 62
 
 char printbuf[CDC_PRINTBUF_SIZE];
 
-void CDC_send(void)
-{
-    return;
-}
+void CDC_send(void) { return; }
 
-uint32_t CDC_print(char *printbuf)
-{
-    return 0;
-}
+uint32_t CDC_print(char *printbuf) { return 0; }
 
-int CDC_printf(const char *_Format, ...)
-{
-    return 0;
-}
+int CDC_printf(const char *_Format, ...) { return 0; }
 
 inbuf_t inbuf;
 
-uint32_t CDC_input(void)
-{
-    return 0;
-}
+uint32_t CDC_input(void) { return 0; }
 
-void CDC_init(void)
-{
-    inbuf.count = 0;
+void CDC_init(void) {
+    inbuf.count     = 0;
     inbuf.lastcount = 0;
-    printbuf[0]=0;
+    printbuf[0]     = 0;
 }
 
-#endif //CDC line 62
+#endif  // CDC line 62
 
 //@}
diff --git a/tmk_core/protocol/arm_atsam/usb/udi_cdc.h b/tmk_core/protocol/arm_atsam/usb/udi_cdc.h
index 86077ce53..9135bab54 100644
--- a/tmk_core/protocol/arm_atsam/usb/udi_cdc.h
+++ b/tmk_core/protocol/arm_atsam/usb/udi_cdc.h
@@ -49,24 +49,24 @@
 
 #ifdef CDC
 
-#include "conf_usb.h"
-#include "usb_protocol.h"
-#include "usb_protocol_cdc.h"
-#include "udd.h"
-#include "udc_desc.h"
-#include "udi.h"
+#    include "conf_usb.h"
+#    include "usb_protocol.h"
+#    include "usb_protocol_cdc.h"
+#    include "udd.h"
+#    include "udc_desc.h"
+#    include "udi.h"
 
 // Check the number of port
-#ifndef UDI_CDC_PORT_NB
-# define UDI_CDC_PORT_NB 1
-#endif
-#if (UDI_CDC_PORT_NB > 1)
-# error UDI_CDC_PORT_NB must be at most 1
-#endif
-
-#ifdef __cplusplus
+#    ifndef UDI_CDC_PORT_NB
+#        define UDI_CDC_PORT_NB 1
+#    endif
+#    if (UDI_CDC_PORT_NB > 1)
+#        error UDI_CDC_PORT_NB must be at most 1
+#    endif
+
+#    ifdef __cplusplus
 extern "C" {
-#endif
+#    endif
 
 /**
  * \addtogroup udi_cdc_group_udc
@@ -82,9 +82,9 @@ extern UDC_DESC_STORAGE udi_api_t udi_api_cdc_data;
 //#define CDC_RX_SIZE   64
 
 //! CDC communication endpoints size for all speeds
-#define UDI_CDC_COMM_EP_SIZE        CDC_ACM_SIZE
+#    define UDI_CDC_COMM_EP_SIZE CDC_ACM_SIZE
 //! CDC data endpoints size for FS speed (8B, 16B, 32B, 64B)
-#define UDI_CDC_DATA_EPS_FS_SIZE    CDC_RX_SIZE
+#    define UDI_CDC_DATA_EPS_FS_SIZE CDC_RX_SIZE
 
 //@}
 
@@ -335,42 +335,42 @@ int udi_cdc_multi_putc(uint8_t port, int value);
 iram_size_t udi_cdc_multi_write_buf(uint8_t port, const void* buf, iram_size_t size);
 //@}
 
-#define CDC_PRINTBUF_SIZE  256
+#    define CDC_PRINTBUF_SIZE 256
 extern char printbuf[CDC_PRINTBUF_SIZE];
 
-#define CDC_INBUF_SIZE 256
+#    define CDC_INBUF_SIZE 256
 
 typedef struct {
     uint32_t count;
     uint32_t lastcount;
-    char buf[CDC_INBUF_SIZE];
+    char     buf[CDC_INBUF_SIZE];
 } inbuf_t;
 
-#else //CDC
+#else  // CDC
 
 // keep these to accommodate calls if remaining
-#define CDC_PRINTBUF_SIZE  1
+#    define CDC_PRINTBUF_SIZE 1
 extern char printbuf[CDC_PRINTBUF_SIZE];
 
-#define CDC_INBUF_SIZE 1
+#    define CDC_INBUF_SIZE 1
 
 typedef struct {
     uint32_t count;
     uint32_t lastcount;
-    char buf[CDC_INBUF_SIZE];
+    char     buf[CDC_INBUF_SIZE];
 } inbuf_t;
 
 extern inbuf_t inbuf;
 
-#endif //CDC
+#endif  // CDC
 
-uint32_t CDC_print(char *printbuf);
-int CDC_printf(const char *_Format, ...);
+uint32_t CDC_print(char* printbuf);
+int      CDC_printf(const char* _Format, ...);
 uint32_t CDC_input(void);
-void CDC_init(void);
+void     CDC_init(void);
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif // _UDI_CDC_H_
+#endif  // _UDI_CDC_H_
diff --git a/tmk_core/protocol/arm_atsam/usb/udi_cdc_conf.h b/tmk_core/protocol/arm_atsam/usb/udi_cdc_conf.h
index 2db61fab5..e07951249 100644
--- a/tmk_core/protocol/arm_atsam/usb/udi_cdc_conf.h
+++ b/tmk_core/protocol/arm_atsam/usb/udi_cdc_conf.h
@@ -51,22 +51,22 @@
 #include "conf_usb.h"
 #include "udi_device_conf.h"
 
-#ifndef  UDI_CDC_PORT_NB
-#define  UDI_CDC_PORT_NB 1
+#ifndef UDI_CDC_PORT_NB
+#    define UDI_CDC_PORT_NB 1
 #endif
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#define  UDI_CDC_DATA_EP_IN_0   ((CDC_TX_ENDPOINT) | (USB_EP_DIR_IN)) //TX
-#define  UDI_CDC_DATA_EP_OUT_0  ((CDC_RX_ENDPOINT) | (USB_EP_DIR_OUT)) // RX
-#define  UDI_CDC_COMM_EP_0      ((CDC_ACM_ENDPOINT) | (USB_EP_DIR_IN))  // Notify endpoint
+#define UDI_CDC_DATA_EP_IN_0 ((CDC_TX_ENDPOINT) | (USB_EP_DIR_IN))    // TX
+#define UDI_CDC_DATA_EP_OUT_0 ((CDC_RX_ENDPOINT) | (USB_EP_DIR_OUT))  // RX
+#define UDI_CDC_COMM_EP_0 ((CDC_ACM_ENDPOINT) | (USB_EP_DIR_IN))      // Notify endpoint
 
-#define  UDI_CDC_COMM_IFACE_NUMBER_0   (CDC_STATUS_INTERFACE)
-#define  UDI_CDC_DATA_IFACE_NUMBER_0   (CDC_DATA_INTERFACE)
+#define UDI_CDC_COMM_IFACE_NUMBER_0 (CDC_STATUS_INTERFACE)
+#define UDI_CDC_DATA_IFACE_NUMBER_0 (CDC_DATA_INTERFACE)
 
 #ifdef __cplusplus
 }
 #endif
-#endif // _UDI_CDC_CONF_H_
+#endif  // _UDI_CDC_CONF_H_
diff --git a/tmk_core/protocol/arm_atsam/usb/udi_device_conf.h b/tmk_core/protocol/arm_atsam/usb/udi_device_conf.h
index 1e82b9ecc..f22f5003a 100644
--- a/tmk_core/protocol/arm_atsam/usb/udi_device_conf.h
+++ b/tmk_core/protocol/arm_atsam/usb/udi_device_conf.h
@@ -31,27 +31,27 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 //#define MOUSE_ENABLE //rules.mk
 #ifdef MOUSE_ENABLE
-#define MOU
+#    define MOU
 #endif
 
 //#define EXTRAKEY_ENABLE //rules.mk
 #ifdef EXTRAKEY_ENABLE
-#define EXK
+#    define EXK
 #endif
 
 //#define RAW_ENABLE //rules.mk
 #ifdef RAW_ENABLE
-#define RAW
+#    define RAW
 #endif
 
 //#define CONSOLE_ENABLE //rules.mk
 #ifdef CONSOLE_ENABLE
-#define CON
+#    define CON
 #endif
 
 //#define NKRO_ENABLE //rules.mk
 #ifdef NKRO_ENABLE
-#define NKRO
+#    define NKRO
 #endif
 
 //#define MIDI_ENABLE //deferred implementation
@@ -61,229 +61,227 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 //#define VIRTSER_ENABLE //rules.mk
 #ifdef VIRTSER_ENABLE
-#define CDC
-//because CDC uses IAD (interface association descriptor
-//per USB Interface Association Descriptor Device Class Code and Use Model 7/23/2003 Rev 1.0)
-#undef DEVICE_CLASS
-#define DEVICE_CLASS 0xEF
-#undef DEVICE_SUBCLASS
-#define DEVICE_SUBCLASS 0x02
-#undef DEVICE_PROTOCOL
-#define DEVICE_PROTOCOL 0x01
+#    define CDC
+// because CDC uses IAD (interface association descriptor
+// per USB Interface Association Descriptor Device Class Code and Use Model 7/23/2003 Rev 1.0)
+#    undef DEVICE_CLASS
+#    define DEVICE_CLASS 0xEF
+#    undef DEVICE_SUBCLASS
+#    define DEVICE_SUBCLASS 0x02
+#    undef DEVICE_PROTOCOL
+#    define DEVICE_PROTOCOL 0x01
 #endif
 
 /* number of interfaces */
-#define NEXT_INTERFACE_0            0
+#define NEXT_INTERFACE_0 0
 
 #ifdef KBD
-#define KEYBOARD_INTERFACE          NEXT_INTERFACE_0
-#define NEXT_INTERFACE_1            (KEYBOARD_INTERFACE + 1)
-#define UDI_HID_KBD_IFACE_NUMBER    KEYBOARD_INTERFACE
+#    define KEYBOARD_INTERFACE NEXT_INTERFACE_0
+#    define NEXT_INTERFACE_1 (KEYBOARD_INTERFACE + 1)
+#    define UDI_HID_KBD_IFACE_NUMBER KEYBOARD_INTERFACE
 #else
-#define NEXT_INTERFACE_1            NEXT_INTERFACE_0
+#    define NEXT_INTERFACE_1 NEXT_INTERFACE_0
 #endif
 
 // It is important that the Raw HID interface is at a constant
 // interface number, to support Linux/OSX platforms and chrome.hid
 // If Raw HID is enabled, let it be always 1.
 #ifdef RAW
-#define RAW_INTERFACE               NEXT_INTERFACE_1
-#define NEXT_INTERFACE_2            (RAW_INTERFACE + 1)
+#    define RAW_INTERFACE NEXT_INTERFACE_1
+#    define NEXT_INTERFACE_2 (RAW_INTERFACE + 1)
 #else
-#define NEXT_INTERFACE_2            NEXT_INTERFACE_1
+#    define NEXT_INTERFACE_2 NEXT_INTERFACE_1
 #endif
 
 #ifdef MOU
-#define MOUSE_INTERFACE             NEXT_INTERFACE_2
-#define UDI_HID_MOU_IFACE_NUMBER    MOUSE_INTERFACE
-#define NEXT_INTERFACE_3            (MOUSE_INTERFACE + 1)
+#    define MOUSE_INTERFACE NEXT_INTERFACE_2
+#    define UDI_HID_MOU_IFACE_NUMBER MOUSE_INTERFACE
+#    define NEXT_INTERFACE_3 (MOUSE_INTERFACE + 1)
 #else
-#define NEXT_INTERFACE_3            NEXT_INTERFACE_2
+#    define NEXT_INTERFACE_3 NEXT_INTERFACE_2
 #endif
 
 #ifdef EXK
-#define EXTRAKEY_INTERFACE          NEXT_INTERFACE_3
-#define NEXT_INTERFACE_4            (EXTRAKEY_INTERFACE + 1)
-#define UDI_HID_EXK_IFACE_NUMBER    EXTRAKEY_INTERFACE
+#    define EXTRAKEY_INTERFACE NEXT_INTERFACE_3
+#    define NEXT_INTERFACE_4 (EXTRAKEY_INTERFACE + 1)
+#    define UDI_HID_EXK_IFACE_NUMBER EXTRAKEY_INTERFACE
 #else
-#define NEXT_INTERFACE_4            NEXT_INTERFACE_3
+#    define NEXT_INTERFACE_4 NEXT_INTERFACE_3
 #endif
 
 #ifdef CON
-#define CON_INTERFACE               NEXT_INTERFACE_4
-#define NEXT_INTERFACE_5            (CON_INTERFACE + 1)
-#define UDI_HID_CON_IFACE_NUMBER    CON_INTERFACE
+#    define CON_INTERFACE NEXT_INTERFACE_4
+#    define NEXT_INTERFACE_5 (CON_INTERFACE + 1)
+#    define UDI_HID_CON_IFACE_NUMBER CON_INTERFACE
 #else
-#define NEXT_INTERFACE_5            NEXT_INTERFACE_4
+#    define NEXT_INTERFACE_5 NEXT_INTERFACE_4
 #endif
 
 #ifdef NKRO
-#define NKRO_INTERFACE              NEXT_INTERFACE_5
-#define NEXT_INTERFACE_6            (NKRO_INTERFACE + 1)
-#define UDI_HID_NKRO_IFACE_NUMBER   NKRO_INTERFACE
+#    define NKRO_INTERFACE NEXT_INTERFACE_5
+#    define NEXT_INTERFACE_6 (NKRO_INTERFACE + 1)
+#    define UDI_HID_NKRO_IFACE_NUMBER NKRO_INTERFACE
 #else
-#define NEXT_INTERFACE_6            NEXT_INTERFACE_5
+#    define NEXT_INTERFACE_6 NEXT_INTERFACE_5
 #endif
 
 #ifdef MIDI
-#define AC_INTERFACE                NEXT_INTERFACE_6
-#define AS_INTERFACE                (AC_INTERFACE + 1)
-#define NEXT_INTERFACE_7            (AS_INTERFACE + 1)
+#    define AC_INTERFACE NEXT_INTERFACE_6
+#    define AS_INTERFACE (AC_INTERFACE + 1)
+#    define NEXT_INTERFACE_7 (AS_INTERFACE + 1)
 #else
-#define NEXT_INTERFACE_7            NEXT_INTERFACE_6
+#    define NEXT_INTERFACE_7 NEXT_INTERFACE_6
 #endif
 
 #ifdef CDC
-#define CCI_INTERFACE               NEXT_INTERFACE_7
-#define CDI_INTERFACE               (CCI_INTERFACE + 1)
-#define NEXT_INTERFACE_8            (CDI_INTERFACE + 1)
-#define CDC_STATUS_INTERFACE        CCI_INTERFACE
-#define CDC_DATA_INTERFACE          CDI_INTERFACE
+#    define CCI_INTERFACE NEXT_INTERFACE_7
+#    define CDI_INTERFACE (CCI_INTERFACE + 1)
+#    define NEXT_INTERFACE_8 (CDI_INTERFACE + 1)
+#    define CDC_STATUS_INTERFACE CCI_INTERFACE
+#    define CDC_DATA_INTERFACE CDI_INTERFACE
 #else
-#define NEXT_INTERFACE_8            NEXT_INTERFACE_7
+#    define NEXT_INTERFACE_8 NEXT_INTERFACE_7
 #endif
 
 /* nubmer of interfaces */
-#define TOTAL_INTERFACES            NEXT_INTERFACE_8
-#define USB_DEVICE_NB_INTERFACE     TOTAL_INTERFACES
-
+#define TOTAL_INTERFACES NEXT_INTERFACE_8
+#define USB_DEVICE_NB_INTERFACE TOTAL_INTERFACES
 
 // **********************************************************************
 // Endopoint number and size
 // **********************************************************************
-#define USB_DEVICE_EP_CTRL_SIZE     8
+#define USB_DEVICE_EP_CTRL_SIZE 8
 
-#define NEXT_IN_EPNUM_0             1
-#define NEXT_OUT_EPNUM_0            1
+#define NEXT_IN_EPNUM_0 1
+#define NEXT_OUT_EPNUM_0 1
 
 #ifdef KBD
-#define KEYBOARD_IN_EPNUM           NEXT_IN_EPNUM_0
-#define UDI_HID_KBD_EP_IN           KEYBOARD_IN_EPNUM
-#define NEXT_IN_EPNUM_1             (KEYBOARD_IN_EPNUM + 1)
-#define UDI_HID_KBD_EP_SIZE         KEYBOARD_EPSIZE
-#define KBD_POLLING_INTERVAL        10
-#ifndef UDI_HID_KBD_STRING_ID
-#define UDI_HID_KBD_STRING_ID       0
-#endif
+#    define KEYBOARD_IN_EPNUM NEXT_IN_EPNUM_0
+#    define UDI_HID_KBD_EP_IN KEYBOARD_IN_EPNUM
+#    define NEXT_IN_EPNUM_1 (KEYBOARD_IN_EPNUM + 1)
+#    define UDI_HID_KBD_EP_SIZE KEYBOARD_EPSIZE
+#    define KBD_POLLING_INTERVAL 10
+#    ifndef UDI_HID_KBD_STRING_ID
+#        define UDI_HID_KBD_STRING_ID 0
+#    endif
 #else
-#define NEXT_IN_EPNUM_1             NEXT_IN_EPNUM_0
+#    define NEXT_IN_EPNUM_1 NEXT_IN_EPNUM_0
 #endif
 
 #ifdef MOU
-#define MOUSE_IN_EPNUM              NEXT_IN_EPNUM_1
-#define NEXT_IN_EPNUM_2             (MOUSE_IN_EPNUM + 1)
-#define UDI_HID_MOU_EP_IN           MOUSE_IN_EPNUM
-#define UDI_HID_MOU_EP_SIZE         MOUSE_EPSIZE
-#define MOU_POLLING_INTERVAL        10
-#ifndef UDI_HID_MOU_STRING_ID
-#define UDI_HID_MOU_STRING_ID       0
-#endif
+#    define MOUSE_IN_EPNUM NEXT_IN_EPNUM_1
+#    define NEXT_IN_EPNUM_2 (MOUSE_IN_EPNUM + 1)
+#    define UDI_HID_MOU_EP_IN MOUSE_IN_EPNUM
+#    define UDI_HID_MOU_EP_SIZE MOUSE_EPSIZE
+#    define MOU_POLLING_INTERVAL 10
+#    ifndef UDI_HID_MOU_STRING_ID
+#        define UDI_HID_MOU_STRING_ID 0
+#    endif
 #else
-#define NEXT_IN_EPNUM_2             NEXT_IN_EPNUM_1
+#    define NEXT_IN_EPNUM_2 NEXT_IN_EPNUM_1
 #endif
 
 #ifdef EXK
-#define EXTRAKEY_IN_EPNUM           NEXT_IN_EPNUM_2
-#define UDI_HID_EXK_EP_IN           EXTRAKEY_IN_EPNUM
-#define NEXT_IN_EPNUM_3             (EXTRAKEY_IN_EPNUM + 1)
-#define UDI_HID_EXK_EP_SIZE         EXTRAKEY_EPSIZE
-#define EXTRAKEY_POLLING_INTERVAL   10
-#ifndef UDI_HID_EXK_STRING_ID
-#define UDI_HID_EXK_STRING_ID       0
-#endif
+#    define EXTRAKEY_IN_EPNUM NEXT_IN_EPNUM_2
+#    define UDI_HID_EXK_EP_IN EXTRAKEY_IN_EPNUM
+#    define NEXT_IN_EPNUM_3 (EXTRAKEY_IN_EPNUM + 1)
+#    define UDI_HID_EXK_EP_SIZE EXTRAKEY_EPSIZE
+#    define EXTRAKEY_POLLING_INTERVAL 10
+#    ifndef UDI_HID_EXK_STRING_ID
+#        define UDI_HID_EXK_STRING_ID 0
+#    endif
 #else
-#define NEXT_IN_EPNUM_3             NEXT_IN_EPNUM_2
+#    define NEXT_IN_EPNUM_3 NEXT_IN_EPNUM_2
 #endif
 
 #ifdef RAW
-#define RAW_IN_EPNUM                NEXT_IN_EPNUM_3
-#define UDI_HID_RAW_EP_IN           RAW_IN_EPNUM
-#define NEXT_IN_EPNUM_4             (RAW_IN_EPNUM + 1)
-#define RAW_OUT_EPNUM               NEXT_OUT_EPNUM_0
-#define UDI_HID_RAW_EP_OUT          RAW_OUT_EPNUM
-#define NEXT_OUT_EPNUM_1            (RAW_OUT_EPNUM + 1)
-#define RAW_POLLING_INTERVAL        1
-#ifndef UDI_HID_RAW_STRING_ID
-#define UDI_HID_RAW_STRING_ID       0
-#endif
+#    define RAW_IN_EPNUM NEXT_IN_EPNUM_3
+#    define UDI_HID_RAW_EP_IN RAW_IN_EPNUM
+#    define NEXT_IN_EPNUM_4 (RAW_IN_EPNUM + 1)
+#    define RAW_OUT_EPNUM NEXT_OUT_EPNUM_0
+#    define UDI_HID_RAW_EP_OUT RAW_OUT_EPNUM
+#    define NEXT_OUT_EPNUM_1 (RAW_OUT_EPNUM + 1)
+#    define RAW_POLLING_INTERVAL 1
+#    ifndef UDI_HID_RAW_STRING_ID
+#        define UDI_HID_RAW_STRING_ID 0
+#    endif
 #else
-#define NEXT_IN_EPNUM_4             NEXT_IN_EPNUM_3
-#define NEXT_OUT_EPNUM_1            NEXT_OUT_EPNUM_0
+#    define NEXT_IN_EPNUM_4 NEXT_IN_EPNUM_3
+#    define NEXT_OUT_EPNUM_1 NEXT_OUT_EPNUM_0
 #endif
 
 #ifdef CON
-#define CON_IN_EPNUM                NEXT_IN_EPNUM_4
-#define UDI_HID_CON_EP_IN           CON_IN_EPNUM
-#define NEXT_IN_EPNUM_5             (CON_IN_EPNUM + 1)
-#define CON_OUT_EPNUM               NEXT_OUT_EPNUM_1
-#define UDI_HID_CON_EP_OUT          CON_OUT_EPNUM
-#define NEXT_OUT_EPNUM_2            (CON_OUT_EPNUM + 1)
-#define CON_POLLING_INTERVAL        1
-#ifndef UDI_HID_CON_STRING_ID
-#define UDI_HID_CON_STRING_ID       0
-#endif
+#    define CON_IN_EPNUM NEXT_IN_EPNUM_4
+#    define UDI_HID_CON_EP_IN CON_IN_EPNUM
+#    define NEXT_IN_EPNUM_5 (CON_IN_EPNUM + 1)
+#    define CON_OUT_EPNUM NEXT_OUT_EPNUM_1
+#    define UDI_HID_CON_EP_OUT CON_OUT_EPNUM
+#    define NEXT_OUT_EPNUM_2 (CON_OUT_EPNUM + 1)
+#    define CON_POLLING_INTERVAL 1
+#    ifndef UDI_HID_CON_STRING_ID
+#        define UDI_HID_CON_STRING_ID 0
+#    endif
 #else
-#define NEXT_IN_EPNUM_5             NEXT_IN_EPNUM_4
-#define NEXT_OUT_EPNUM_2            NEXT_OUT_EPNUM_1
+#    define NEXT_IN_EPNUM_5 NEXT_IN_EPNUM_4
+#    define NEXT_OUT_EPNUM_2 NEXT_OUT_EPNUM_1
 #endif
 
 #ifdef NKRO
-#define NKRO_IN_EPNUM               NEXT_IN_EPNUM_5
-#define UDI_HID_NKRO_EP_IN          NKRO_IN_EPNUM
-#define NEXT_IN_EPNUM_6             (NKRO_IN_EPNUM + 1)
-#define UDI_HID_NKRO_EP_SIZE        NKRO_EPSIZE
-#define NKRO_POLLING_INTERVAL       1
-#ifndef UDI_HID_NKRO_STRING_ID
-#define UDI_HID_NKRO_STRING_ID      0
-#endif
+#    define NKRO_IN_EPNUM NEXT_IN_EPNUM_5
+#    define UDI_HID_NKRO_EP_IN NKRO_IN_EPNUM
+#    define NEXT_IN_EPNUM_6 (NKRO_IN_EPNUM + 1)
+#    define UDI_HID_NKRO_EP_SIZE NKRO_EPSIZE
+#    define NKRO_POLLING_INTERVAL 1
+#    ifndef UDI_HID_NKRO_STRING_ID
+#        define UDI_HID_NKRO_STRING_ID 0
+#    endif
 #else
-#define NEXT_IN_EPNUM_6             NEXT_IN_EPNUM_5
+#    define NEXT_IN_EPNUM_6 NEXT_IN_EPNUM_5
 #endif
 
 #ifdef MIDI
-#define MIDI_STREAM_IN_EPNUM        NEXT_IN_EPNUM_6
-#define NEXT_IN_EPNUM_7             (MIDI_STREAM_IN_EPNUM + 1)
-#define MIDI_STREAM_OUT_EPNUM       NEXT_OUT_EPNUM_2
-#define NEXT_OUT_EPNUM_3            (MIDI_STREAM_OUT_EPNUM + 1)
-#define MIDI_POLLING_INTERVAL       5
+#    define MIDI_STREAM_IN_EPNUM NEXT_IN_EPNUM_6
+#    define NEXT_IN_EPNUM_7 (MIDI_STREAM_IN_EPNUM + 1)
+#    define MIDI_STREAM_OUT_EPNUM NEXT_OUT_EPNUM_2
+#    define NEXT_OUT_EPNUM_3 (MIDI_STREAM_OUT_EPNUM + 1)
+#    define MIDI_POLLING_INTERVAL 5
 #else
-#define NEXT_IN_EPNUM_7             NEXT_IN_EPNUM_6
-#define NEXT_OUT_EPNUM_3            NEXT_OUT_EPNUM_2
+#    define NEXT_IN_EPNUM_7 NEXT_IN_EPNUM_6
+#    define NEXT_OUT_EPNUM_3 NEXT_OUT_EPNUM_2
 #endif
 
 #ifdef CDC
-#define CDC_NOTIFICATION_EPNUM      NEXT_IN_EPNUM_7
-#define CDC_ACM_ENDPOINT            CDC_NOTIFICATION_EPNUM
-#define CDC_TX_ENDPOINT             (CDC_NOTIFICATION_EPNUM + 1)
-#define NEXT_IN_EPNUM_8             (CDC_TX_ENDPOINT + 1)
-
-#define CDC_OUT_EPNUM               NEXT_OUT_EPNUM_3
-#define CDC_RX_ENDPOINT             CDC_OUT_EPNUM
-#define NEXT_OUT_EPNUM_4            (CDC_OUT_EPNUM + 1)
-
-#define CDC_ACM_SIZE                CDC_NOTIFICATION_EPSIZE
-#define CDC_RX_SIZE                 CDC_EPSIZE  //KFSMOD was 64
-#define CDC_TX_SIZE                 CDC_RX_SIZE
-#define CDC_ACM_POLLING_INTERVAL    255
-#define CDC_EP_INTERVAL_STATUS      CDC_ACM_POLLING_INTERVAL
-#define CDC_DATA_POLLING_INTERVAL   5
-#define CDC_EP_INTERVAL_DATA        CDC_DATA_POLLING_INTERVAL
-#define CDC_STATUS_NAME             L"Virtual Serial Port - Status"
-#define CDC_DATA_NAME               L"Virtual Serial Port - Data"
+#    define CDC_NOTIFICATION_EPNUM NEXT_IN_EPNUM_7
+#    define CDC_ACM_ENDPOINT CDC_NOTIFICATION_EPNUM
+#    define CDC_TX_ENDPOINT (CDC_NOTIFICATION_EPNUM + 1)
+#    define NEXT_IN_EPNUM_8 (CDC_TX_ENDPOINT + 1)
+
+#    define CDC_OUT_EPNUM NEXT_OUT_EPNUM_3
+#    define CDC_RX_ENDPOINT CDC_OUT_EPNUM
+#    define NEXT_OUT_EPNUM_4 (CDC_OUT_EPNUM + 1)
+
+#    define CDC_ACM_SIZE CDC_NOTIFICATION_EPSIZE
+#    define CDC_RX_SIZE CDC_EPSIZE  // KFSMOD was 64
+#    define CDC_TX_SIZE CDC_RX_SIZE
+#    define CDC_ACM_POLLING_INTERVAL 255
+#    define CDC_EP_INTERVAL_STATUS CDC_ACM_POLLING_INTERVAL
+#    define CDC_DATA_POLLING_INTERVAL 5
+#    define CDC_EP_INTERVAL_DATA CDC_DATA_POLLING_INTERVAL
+#    define CDC_STATUS_NAME L"Virtual Serial Port - Status"
+#    define CDC_DATA_NAME L"Virtual Serial Port - Data"
 #else
-#define NEXT_IN_EPNUM_8             NEXT_IN_EPNUM_7
-#define NEXT_OUT_EPNUM_4            NEXT_OUT_EPNUM_3
+#    define NEXT_IN_EPNUM_8 NEXT_IN_EPNUM_7
+#    define NEXT_OUT_EPNUM_4 NEXT_OUT_EPNUM_3
 #endif
 
-#define TOTAL_OUT_EP                NEXT_OUT_EPNUM_4
-#define TOTAL_IN_EP                 NEXT_IN_EPNUM_8
-#define USB_DEVICE_MAX_EP           (max(NEXT_OUT_EPNUM_4, NEXT_IN_EPNUM_8))
+#define TOTAL_OUT_EP NEXT_OUT_EPNUM_4
+#define TOTAL_IN_EP NEXT_IN_EPNUM_8
+#define USB_DEVICE_MAX_EP (max(NEXT_OUT_EPNUM_4, NEXT_IN_EPNUM_8))
 
 #if USB_DEVICE_MAX_EP > 8
-#error "There are not enough available endpoints to support all functions. Remove some in the rules.mk file.(MOUSEKEY, EXTRAKEY, CONSOLE, NKRO, MIDI, VIRTSER)"
+#    error "There are not enough available endpoints to support all functions. Remove some in the rules.mk file.(MOUSEKEY, EXTRAKEY, CONSOLE, NKRO, MIDI, VIRTSER)"
 #endif
 
-
 // **********************************************************************
 // KBD Descriptor structure and content
 // **********************************************************************
@@ -292,50 +290,28 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 COMPILER_PACK_SET(1)
 
 typedef struct {
-    usb_iface_desc_t iface;
+    usb_iface_desc_t     iface;
     usb_hid_descriptor_t hid;
-    usb_ep_desc_t ep;
+    usb_ep_desc_t        ep;
 } udi_hid_kbd_desc_t;
 
 typedef struct {
     uint8_t array[59];
 } udi_hid_kbd_report_desc_t;
 
-#define UDI_HID_KBD_DESC {\
-    .iface.bLength             = sizeof(usb_iface_desc_t),\
-    .iface.bDescriptorType     = USB_DT_INTERFACE,\
-    .iface.bInterfaceNumber    = UDI_HID_KBD_IFACE_NUMBER,\
-    .iface.bAlternateSetting   = 0,\
-    .iface.bNumEndpoints       = 1,\
-    .iface.bInterfaceClass     = HID_CLASS,\
-    .iface.bInterfaceSubClass  = HID_SUB_CLASS_BOOT,\
-    .iface.bInterfaceProtocol  = HID_PROTOCOL_KEYBOARD,\
-    .iface.iInterface          = UDI_HID_KBD_STRING_ID,\
-    .hid.bLength               = sizeof(usb_hid_descriptor_t),\
-    .hid.bDescriptorType       = USB_DT_HID,\
-    .hid.bcdHID                = LE16(USB_HID_BDC_V1_11),\
-    .hid.bCountryCode          = USB_HID_NO_COUNTRY_CODE,\
-    .hid.bNumDescriptors       = USB_HID_NUM_DESC,\
-    .hid.bRDescriptorType      = USB_DT_HID_REPORT,\
-    .hid.wDescriptorLength     = LE16(sizeof(udi_hid_kbd_report_desc_t)),\
-    .ep.bLength                = sizeof(usb_ep_desc_t),\
-    .ep.bDescriptorType        = USB_DT_ENDPOINT,\
-    .ep.bEndpointAddress       = UDI_HID_KBD_EP_IN | USB_EP_DIR_IN,\
-    .ep.bmAttributes           = USB_EP_TYPE_INTERRUPT,\
-    .ep.wMaxPacketSize         = LE16(UDI_HID_KBD_EP_SIZE),\
-    .ep.bInterval              = KBD_POLLING_INTERVAL,\
-}
-
-//set report buffer (from host)
+#    define UDI_HID_KBD_DESC \
+        { .iface.bLength = sizeof(usb_iface_desc_t), .iface.bDescriptorType = USB_DT_INTERFACE, .iface.bInterfaceNumber = UDI_HID_KBD_IFACE_NUMBER, .iface.bAlternateSetting = 0, .iface.bNumEndpoints = 1, .iface.bInterfaceClass = HID_CLASS, .iface.bInterfaceSubClass = HID_SUB_CLASS_BOOT, .iface.bInterfaceProtocol = HID_PROTOCOL_KEYBOARD, .iface.iInterface = UDI_HID_KBD_STRING_ID, .hid.bLength = sizeof(usb_hid_descriptor_t), .hid.bDescriptorType = USB_DT_HID, .hid.bcdHID = LE16(USB_HID_BDC_V1_11), .hid.bCountryCode = USB_HID_NO_COUNTRY_CODE, .hid.bNumDescriptors = USB_HID_NUM_DESC, .hid.bRDescriptorType = USB_DT_HID_REPORT, .hid.wDescriptorLength = LE16(sizeof(udi_hid_kbd_report_desc_t)), .ep.bLength = sizeof(usb_ep_desc_t), .ep.bDescriptorType = USB_DT_ENDPOINT, .ep.bEndpointAddress = UDI_HID_KBD_EP_IN | USB_EP_DIR_IN, .ep.bmAttributes = USB_EP_TYPE_INTERRUPT, .ep.wMaxPacketSize = LE16(UDI_HID_KBD_EP_SIZE), .ep.bInterval = KBD_POLLING_INTERVAL, }
+
+// set report buffer (from host)
 extern uint8_t udi_hid_kbd_report_set;
 
-//report buffer (to host)
-#define UDI_HID_KBD_REPORT_SIZE 8
+// report buffer (to host)
+#    define UDI_HID_KBD_REPORT_SIZE 8
 extern uint8_t udi_hid_kbd_report[UDI_HID_KBD_REPORT_SIZE];
 
 COMPILER_PACK_RESET()
 
-#endif //KBD
+#endif  // KBD
 
 // **********************************************************************
 // EXK Descriptor structure and content
@@ -345,59 +321,37 @@ COMPILER_PACK_RESET()
 COMPILER_PACK_SET(1)
 
 typedef struct {
-    usb_iface_desc_t iface;
+    usb_iface_desc_t     iface;
     usb_hid_descriptor_t hid;
-    usb_ep_desc_t ep;
+    usb_ep_desc_t        ep;
 } udi_hid_exk_desc_t;
 
 typedef struct {
     uint8_t array[54];
 } udi_hid_exk_report_desc_t;
 
-#define UDI_HID_EXK_DESC {\
-    .iface.bLength             = sizeof(usb_iface_desc_t),\
-    .iface.bDescriptorType     = USB_DT_INTERFACE,\
-    .iface.bInterfaceNumber    = UDI_HID_EXK_IFACE_NUMBER,\
-    .iface.bAlternateSetting   = 0,\
-    .iface.bNumEndpoints       = 1,\
-    .iface.bInterfaceClass     = HID_CLASS,\
-    .iface.bInterfaceSubClass  = HID_SUB_CLASS_BOOT,\
-    .iface.bInterfaceProtocol  = HID_PROTOCOL_GENERIC,\
-    .iface.iInterface          = UDI_HID_EXK_STRING_ID,\
-    .hid.bLength               = sizeof(usb_hid_descriptor_t),\
-    .hid.bDescriptorType       = USB_DT_HID,\
-    .hid.bcdHID                = LE16(USB_HID_BDC_V1_11),\
-    .hid.bCountryCode          = USB_HID_NO_COUNTRY_CODE,\
-    .hid.bNumDescriptors       = USB_HID_NUM_DESC,\
-    .hid.bRDescriptorType      = USB_DT_HID_REPORT,\
-    .hid.wDescriptorLength     = LE16(sizeof(udi_hid_exk_report_desc_t)),\
-    .ep.bLength                = sizeof(usb_ep_desc_t),\
-    .ep.bDescriptorType        = USB_DT_ENDPOINT,\
-    .ep.bEndpointAddress       = UDI_HID_EXK_EP_IN | USB_EP_DIR_IN,\
-    .ep.bmAttributes           = USB_EP_TYPE_INTERRUPT,\
-    .ep.wMaxPacketSize         = LE16(UDI_HID_EXK_EP_SIZE),\
-    .ep.bInterval              = EXTRAKEY_POLLING_INTERVAL,\
-}
-
-//set report buffer (from host)
+#    define UDI_HID_EXK_DESC \
+        { .iface.bLength = sizeof(usb_iface_desc_t), .iface.bDescriptorType = USB_DT_INTERFACE, .iface.bInterfaceNumber = UDI_HID_EXK_IFACE_NUMBER, .iface.bAlternateSetting = 0, .iface.bNumEndpoints = 1, .iface.bInterfaceClass = HID_CLASS, .iface.bInterfaceSubClass = HID_SUB_CLASS_BOOT, .iface.bInterfaceProtocol = HID_PROTOCOL_GENERIC, .iface.iInterface = UDI_HID_EXK_STRING_ID, .hid.bLength = sizeof(usb_hid_descriptor_t), .hid.bDescriptorType = USB_DT_HID, .hid.bcdHID = LE16(USB_HID_BDC_V1_11), .hid.bCountryCode = USB_HID_NO_COUNTRY_CODE, .hid.bNumDescriptors = USB_HID_NUM_DESC, .hid.bRDescriptorType = USB_DT_HID_REPORT, .hid.wDescriptorLength = LE16(sizeof(udi_hid_exk_report_desc_t)), .ep.bLength = sizeof(usb_ep_desc_t), .ep.bDescriptorType = USB_DT_ENDPOINT, .ep.bEndpointAddress = UDI_HID_EXK_EP_IN | USB_EP_DIR_IN, .ep.bmAttributes = USB_EP_TYPE_INTERRUPT, .ep.wMaxPacketSize = LE16(UDI_HID_EXK_EP_SIZE), .ep.bInterval = EXTRAKEY_POLLING_INTERVAL, }
+
+// set report buffer (from host)
 extern uint8_t udi_hid_exk_report_set;
 
-//report buffer
-#define UDI_HID_EXK_REPORT_SIZE 3
+// report buffer
+#    define UDI_HID_EXK_REPORT_SIZE 3
 
 typedef union {
-  struct {
-    uint8_t report_id;
-    uint16_t report_data;
- } desc;
- uint8_t raw[UDI_HID_EXK_REPORT_SIZE];
+    struct {
+        uint8_t  report_id;
+        uint16_t report_data;
+    } desc;
+    uint8_t raw[UDI_HID_EXK_REPORT_SIZE];
 } udi_hid_exk_report_t;
 
 extern udi_hid_exk_report_t udi_hid_exk_report;
 
 COMPILER_PACK_RESET()
 
-#endif //EXK
+#endif  // EXK
 
 // **********************************************************************
 // NKRO Descriptor structure and content
@@ -407,50 +361,28 @@ COMPILER_PACK_RESET()
 COMPILER_PACK_SET(1)
 
 typedef struct {
-    usb_iface_desc_t iface;
+    usb_iface_desc_t     iface;
     usb_hid_descriptor_t hid;
-    usb_ep_desc_t ep;
+    usb_ep_desc_t        ep;
 } udi_hid_nkro_desc_t;
 
 typedef struct {
     uint8_t array[57];
 } udi_hid_nkro_report_desc_t;
 
-#define UDI_HID_NKRO_DESC {\
-    .iface.bLength             = sizeof(usb_iface_desc_t),\
-    .iface.bDescriptorType     = USB_DT_INTERFACE,\
-    .iface.bInterfaceNumber    = UDI_HID_NKRO_IFACE_NUMBER,\
-    .iface.bAlternateSetting   = 0,\
-    .iface.bNumEndpoints       = 1,\
-    .iface.bInterfaceClass     = HID_CLASS,\
-    .iface.bInterfaceSubClass  = HID_SUB_CLASS_NOBOOT,\
-    .iface.bInterfaceProtocol  = HID_PROTOCOL_KEYBOARD,\
-    .iface.iInterface          = UDI_HID_NKRO_STRING_ID,\
-    .hid.bLength               = sizeof(usb_hid_descriptor_t),\
-    .hid.bDescriptorType       = USB_DT_HID,\
-    .hid.bcdHID                = LE16(USB_HID_BDC_V1_11),\
-    .hid.bCountryCode          = USB_HID_NO_COUNTRY_CODE,\
-    .hid.bNumDescriptors       = USB_HID_NUM_DESC,\
-    .hid.bRDescriptorType      = USB_DT_HID_REPORT,\
-    .hid.wDescriptorLength     = LE16(sizeof(udi_hid_nkro_report_desc_t)),\
-    .ep.bLength                = sizeof(usb_ep_desc_t),\
-    .ep.bDescriptorType        = USB_DT_ENDPOINT,\
-    .ep.bEndpointAddress       = UDI_HID_NKRO_EP_IN | USB_EP_DIR_IN,\
-    .ep.bmAttributes           = USB_EP_TYPE_INTERRUPT,\
-    .ep.wMaxPacketSize         = LE16(UDI_HID_NKRO_EP_SIZE),\
-    .ep.bInterval              = NKRO_POLLING_INTERVAL,\
-}
-
-//set report buffer
+#    define UDI_HID_NKRO_DESC \
+        { .iface.bLength = sizeof(usb_iface_desc_t), .iface.bDescriptorType = USB_DT_INTERFACE, .iface.bInterfaceNumber = UDI_HID_NKRO_IFACE_NUMBER, .iface.bAlternateSetting = 0, .iface.bNumEndpoints = 1, .iface.bInterfaceClass = HID_CLASS, .iface.bInterfaceSubClass = HID_SUB_CLASS_NOBOOT, .iface.bInterfaceProtocol = HID_PROTOCOL_KEYBOARD, .iface.iInterface = UDI_HID_NKRO_STRING_ID, .hid.bLength = sizeof(usb_hid_descriptor_t), .hid.bDescriptorType = USB_DT_HID, .hid.bcdHID = LE16(USB_HID_BDC_V1_11), .hid.bCountryCode = USB_HID_NO_COUNTRY_CODE, .hid.bNumDescriptors = USB_HID_NUM_DESC, .hid.bRDescriptorType = USB_DT_HID_REPORT, .hid.wDescriptorLength = LE16(sizeof(udi_hid_nkro_report_desc_t)), .ep.bLength = sizeof(usb_ep_desc_t), .ep.bDescriptorType = USB_DT_ENDPOINT, .ep.bEndpointAddress = UDI_HID_NKRO_EP_IN | USB_EP_DIR_IN, .ep.bmAttributes = USB_EP_TYPE_INTERRUPT, .ep.wMaxPacketSize = LE16(UDI_HID_NKRO_EP_SIZE), .ep.bInterval = NKRO_POLLING_INTERVAL, }
+
+// set report buffer
 extern uint8_t udi_hid_nkro_report_set;
 
-//report buffer
-#define UDI_HID_NKRO_REPORT_SIZE 32
+// report buffer
+#    define UDI_HID_NKRO_REPORT_SIZE 32
 extern uint8_t udi_hid_nkro_report[UDI_HID_NKRO_REPORT_SIZE];
 
 COMPILER_PACK_RESET()
 
-#endif //NKRO
+#endif  // NKRO
 
 // **********************************************************************
 // MOU Descriptor structure and content
@@ -460,49 +392,27 @@ COMPILER_PACK_RESET()
 COMPILER_PACK_SET(1)
 
 typedef struct {
-    usb_iface_desc_t iface;
+    usb_iface_desc_t     iface;
     usb_hid_descriptor_t hid;
-    usb_ep_desc_t ep;
+    usb_ep_desc_t        ep;
 } udi_hid_mou_desc_t;
 
 typedef struct {
-    uint8_t array[77];//MOU PDS
+    uint8_t array[77];  // MOU PDS
 } udi_hid_mou_report_desc_t;
 
-#define UDI_HID_MOU_DESC {\
-    .iface.bLength             = sizeof(usb_iface_desc_t),\
-    .iface.bDescriptorType     = USB_DT_INTERFACE,\
-    .iface.bInterfaceNumber    = MOUSE_INTERFACE,\
-    .iface.bAlternateSetting   = 0,\
-    .iface.bNumEndpoints       = 1,\
-    .iface.bInterfaceClass     = HID_CLASS,\
-    .iface.bInterfaceSubClass  = HID_SUB_CLASS_BOOT,\
-    .iface.bInterfaceProtocol  = HID_PROTOCOL_MOUSE,\
-    .iface.iInterface          = UDI_HID_MOU_STRING_ID,\
-    .hid.bLength               = sizeof(usb_hid_descriptor_t),\
-    .hid.bDescriptorType       = USB_DT_HID,\
-    .hid.bcdHID                = LE16(USB_HID_BDC_V1_11),\
-    .hid.bCountryCode          = USB_HID_NO_COUNTRY_CODE,\
-    .hid.bNumDescriptors       = USB_HID_NUM_DESC,\
-    .hid.bRDescriptorType      = USB_DT_HID_REPORT,\
-    .hid.wDescriptorLength     = LE16(sizeof(udi_hid_mou_report_desc_t)),\
-    .ep.bLength                = sizeof(usb_ep_desc_t),\
-    .ep.bDescriptorType        = USB_DT_ENDPOINT,\
-    .ep.bEndpointAddress       = UDI_HID_MOU_EP_IN | USB_EP_DIR_IN,\
-    .ep.bmAttributes           = USB_EP_TYPE_INTERRUPT,\
-    .ep.wMaxPacketSize         = LE16(UDI_HID_MOU_EP_SIZE),\
-    .ep.bInterval              = MOU_POLLING_INTERVAL,\
-}
-
-//no set report buffer
-
-//report buffer
-#define UDI_HID_MOU_REPORT_SIZE 5 //MOU PDS
+#    define UDI_HID_MOU_DESC \
+        { .iface.bLength = sizeof(usb_iface_desc_t), .iface.bDescriptorType = USB_DT_INTERFACE, .iface.bInterfaceNumber = MOUSE_INTERFACE, .iface.bAlternateSetting = 0, .iface.bNumEndpoints = 1, .iface.bInterfaceClass = HID_CLASS, .iface.bInterfaceSubClass = HID_SUB_CLASS_BOOT, .iface.bInterfaceProtocol = HID_PROTOCOL_MOUSE, .iface.iInterface = UDI_HID_MOU_STRING_ID, .hid.bLength = sizeof(usb_hid_descriptor_t), .hid.bDescriptorType = USB_DT_HID, .hid.bcdHID = LE16(USB_HID_BDC_V1_11), .hid.bCountryCode = USB_HID_NO_COUNTRY_CODE, .hid.bNumDescriptors = USB_HID_NUM_DESC, .hid.bRDescriptorType = USB_DT_HID_REPORT, .hid.wDescriptorLength = LE16(sizeof(udi_hid_mou_report_desc_t)), .ep.bLength = sizeof(usb_ep_desc_t), .ep.bDescriptorType = USB_DT_ENDPOINT, .ep.bEndpointAddress = UDI_HID_MOU_EP_IN | USB_EP_DIR_IN, .ep.bmAttributes = USB_EP_TYPE_INTERRUPT, .ep.wMaxPacketSize = LE16(UDI_HID_MOU_EP_SIZE), .ep.bInterval = MOU_POLLING_INTERVAL, }
+
+// no set report buffer
+
+// report buffer
+#    define UDI_HID_MOU_REPORT_SIZE 5  // MOU PDS
 extern uint8_t udi_hid_mou_report[UDI_HID_MOU_REPORT_SIZE];
 
 COMPILER_PACK_RESET()
 
-#endif //MOU
+#endif  // MOU
 
 // **********************************************************************
 // RAW Descriptor structure and content
@@ -512,57 +422,32 @@ COMPILER_PACK_RESET()
 COMPILER_PACK_SET(1)
 
 typedef struct {
-    usb_iface_desc_t iface;
+    usb_iface_desc_t     iface;
     usb_hid_descriptor_t hid;
-    usb_ep_desc_t ep_out;
-    usb_ep_desc_t ep_in;
+    usb_ep_desc_t        ep_out;
+    usb_ep_desc_t        ep_in;
 } udi_hid_raw_desc_t;
 
 typedef struct {
     uint8_t array[27];
 } udi_hid_raw_report_desc_t;
 
-#define UDI_HID_RAW_DESC {\
-    .iface.bLength             = sizeof(usb_iface_desc_t),\
-    .iface.bDescriptorType     = USB_DT_INTERFACE,\
-    .iface.bInterfaceNumber    = RAW_INTERFACE,\
-    .iface.bAlternateSetting   = 0,\
-    .iface.bNumEndpoints       = 2,\
-    .iface.bInterfaceClass     = HID_CLASS,\
-    .iface.bInterfaceSubClass  = HID_SUB_CLASS_NOBOOT,\
-    .iface.bInterfaceProtocol  = HID_SUB_CLASS_NOBOOT,\
-    .iface.iInterface          = UDI_HID_RAW_STRING_ID,\
-    .hid.bLength               = sizeof(usb_hid_descriptor_t),\
-    .hid.bDescriptorType       = USB_DT_HID,\
-    .hid.bcdHID                = LE16(USB_HID_BDC_V1_11),\
-    .hid.bCountryCode          = USB_HID_NO_COUNTRY_CODE,\
-    .hid.bNumDescriptors       = USB_HID_NUM_DESC,\
-    .hid.bRDescriptorType      = USB_DT_HID_REPORT,\
-    .hid.wDescriptorLength     = LE16(sizeof(udi_hid_raw_report_desc_t)),\
-    .ep_out.bLength            = sizeof(usb_ep_desc_t),\
-    .ep_out.bDescriptorType    = USB_DT_ENDPOINT,\
-    .ep_out.bEndpointAddress   = UDI_HID_RAW_EP_OUT | USB_EP_DIR_OUT,\
-    .ep_out.bmAttributes       = USB_EP_TYPE_INTERRUPT,\
-    .ep_out.wMaxPacketSize     = LE16(RAW_EPSIZE),\
-    .ep_out.bInterval          = RAW_POLLING_INTERVAL,\
-    .ep_in.bLength             = sizeof(usb_ep_desc_t),\
-    .ep_in.bDescriptorType     = USB_DT_ENDPOINT,\
-    .ep_in.bEndpointAddress    = UDI_HID_RAW_EP_IN | USB_EP_DIR_IN,\
-    .ep_in.bmAttributes        = USB_EP_TYPE_INTERRUPT,\
-    .ep_in.wMaxPacketSize      = LE16(RAW_EPSIZE),\
-    .ep_in.bInterval           = RAW_POLLING_INTERVAL,\
-}
-
-#define UDI_HID_RAW_REPORT_SIZE RAW_EPSIZE
+#    define UDI_HID_RAW_DESC                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           \
+        {                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              \
+            .iface.bLength = sizeof(usb_iface_desc_t), .iface.bDescriptorType = USB_DT_INTERFACE, .iface.bInterfaceNumber = RAW_INTERFACE, .iface.bAlternateSetting = 0, .iface.bNumEndpoints = 2, .iface.bInterfaceClass = HID_CLASS, .iface.bInterfaceSubClass = HID_SUB_CLASS_NOBOOT, .iface.bInterfaceProtocol = HID_SUB_CLASS_NOBOOT, .iface.iInterface = UDI_HID_RAW_STRING_ID, .hid.bLength = sizeof(usb_hid_descriptor_t), .hid.bDescriptorType = USB_DT_HID, .hid.bcdHID = LE16(USB_HID_BDC_V1_11), .hid.bCountryCode = USB_HID_NO_COUNTRY_CODE, .hid.bNumDescriptors = USB_HID_NUM_DESC, .hid.bRDescriptorType = USB_DT_HID_REPORT, .hid.wDescriptorLength = LE16(sizeof(udi_hid_raw_report_desc_t)), .ep_out.bLength = sizeof(usb_ep_desc_t), .ep_out.bDescriptorType = USB_DT_ENDPOINT, .ep_out.bEndpointAddress = UDI_HID_RAW_EP_OUT | USB_EP_DIR_OUT, .ep_out.bmAttributes = USB_EP_TYPE_INTERRUPT, .ep_out.wMaxPacketSize = LE16(RAW_EPSIZE), .ep_out.bInterval = RAW_POLLING_INTERVAL, \
+            .ep_in.bLength = sizeof(usb_ep_desc_t), .ep_in.bDescriptorType = USB_DT_ENDPOINT, .ep_in.bEndpointAddress = UDI_HID_RAW_EP_IN | USB_EP_DIR_IN, .ep_in.bmAttributes = USB_EP_TYPE_INTERRUPT, .ep_in.wMaxPacketSize = LE16(RAW_EPSIZE), .ep_in.bInterval = RAW_POLLING_INTERVAL,                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             \
+        }
+
+#    define UDI_HID_RAW_REPORT_SIZE RAW_EPSIZE
 
 extern uint8_t udi_hid_raw_report_set[UDI_HID_RAW_REPORT_SIZE];
 
-//report buffer
+// report buffer
 extern uint8_t udi_hid_raw_report[UDI_HID_RAW_REPORT_SIZE];
 
 COMPILER_PACK_RESET()
 
-#endif //RAW
+#endif  // RAW
 
 // **********************************************************************
 // CON Descriptor structure and content
@@ -572,57 +457,32 @@ COMPILER_PACK_RESET()
 COMPILER_PACK_SET(1)
 
 typedef struct {
-    usb_iface_desc_t iface;
+    usb_iface_desc_t     iface;
     usb_hid_descriptor_t hid;
-    usb_ep_desc_t ep_out;
-    usb_ep_desc_t ep_in;
+    usb_ep_desc_t        ep_out;
+    usb_ep_desc_t        ep_in;
 } udi_hid_con_desc_t;
 
 typedef struct {
     uint8_t array[34];
 } udi_hid_con_report_desc_t;
 
-#define UDI_HID_CON_DESC {\
-    .iface.bLength             = sizeof(usb_iface_desc_t),\
-    .iface.bDescriptorType     = USB_DT_INTERFACE,\
-    .iface.bInterfaceNumber    = UDI_HID_CON_IFACE_NUMBER,\
-    .iface.bAlternateSetting   = 0,\
-    .iface.bNumEndpoints       = 2,\
-    .iface.bInterfaceClass     = HID_CLASS,\
-    .iface.bInterfaceSubClass  = HID_SUB_CLASS_NOBOOT,\
-    .iface.bInterfaceProtocol  = HID_SUB_CLASS_NOBOOT,\
-    .iface.iInterface          = UDI_HID_CON_STRING_ID,\
-    .hid.bLength               = sizeof(usb_hid_descriptor_t),\
-    .hid.bDescriptorType       = USB_DT_HID,\
-    .hid.bcdHID                = LE16(USB_HID_BDC_V1_11),\
-    .hid.bCountryCode          = USB_HID_NO_COUNTRY_CODE,\
-    .hid.bNumDescriptors       = USB_HID_NUM_DESC,\
-    .hid.bRDescriptorType      = USB_DT_HID_REPORT,\
-    .hid.wDescriptorLength     = LE16(sizeof(udi_hid_con_report_desc_t)),\
-    .ep_out.bLength            = sizeof(usb_ep_desc_t),\
-    .ep_out.bDescriptorType    = USB_DT_ENDPOINT,\
-    .ep_out.bEndpointAddress   = UDI_HID_CON_EP_OUT | USB_EP_DIR_OUT,\
-    .ep_out.bmAttributes       = USB_EP_TYPE_INTERRUPT,\
-    .ep_out.wMaxPacketSize     = LE16(CONSOLE_EPSIZE),\
-    .ep_out.bInterval          = CON_POLLING_INTERVAL,\
-    .ep_in.bLength             = sizeof(usb_ep_desc_t),\
-    .ep_in.bDescriptorType     = USB_DT_ENDPOINT,\
-    .ep_in.bEndpointAddress    = UDI_HID_CON_EP_IN | USB_EP_DIR_IN,\
-    .ep_in.bmAttributes        = USB_EP_TYPE_INTERRUPT,\
-    .ep_in.wMaxPacketSize      = LE16(CONSOLE_EPSIZE),\
-    .ep_in.bInterval           = CON_POLLING_INTERVAL,\
-}
-
-#define UDI_HID_CON_REPORT_SIZE CONSOLE_EPSIZE
+#    define UDI_HID_CON_DESC                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          \
+        {                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             \
+            .iface.bLength = sizeof(usb_iface_desc_t), .iface.bDescriptorType = USB_DT_INTERFACE, .iface.bInterfaceNumber = UDI_HID_CON_IFACE_NUMBER, .iface.bAlternateSetting = 0, .iface.bNumEndpoints = 2, .iface.bInterfaceClass = HID_CLASS, .iface.bInterfaceSubClass = HID_SUB_CLASS_NOBOOT, .iface.bInterfaceProtocol = HID_SUB_CLASS_NOBOOT, .iface.iInterface = UDI_HID_CON_STRING_ID, .hid.bLength = sizeof(usb_hid_descriptor_t), .hid.bDescriptorType = USB_DT_HID, .hid.bcdHID = LE16(USB_HID_BDC_V1_11), .hid.bCountryCode = USB_HID_NO_COUNTRY_CODE, .hid.bNumDescriptors = USB_HID_NUM_DESC, .hid.bRDescriptorType = USB_DT_HID_REPORT, .hid.wDescriptorLength = LE16(sizeof(udi_hid_con_report_desc_t)), .ep_out.bLength = sizeof(usb_ep_desc_t), .ep_out.bDescriptorType = USB_DT_ENDPOINT, .ep_out.bEndpointAddress = UDI_HID_CON_EP_OUT | USB_EP_DIR_OUT, .ep_out.bmAttributes = USB_EP_TYPE_INTERRUPT, .ep_out.wMaxPacketSize = LE16(CONSOLE_EPSIZE), .ep_out.bInterval = CON_POLLING_INTERVAL, \
+            .ep_in.bLength = sizeof(usb_ep_desc_t), .ep_in.bDescriptorType = USB_DT_ENDPOINT, .ep_in.bEndpointAddress = UDI_HID_CON_EP_IN | USB_EP_DIR_IN, .ep_in.bmAttributes = USB_EP_TYPE_INTERRUPT, .ep_in.wMaxPacketSize = LE16(CONSOLE_EPSIZE), .ep_in.bInterval = CON_POLLING_INTERVAL,                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        \
+        }
+
+#    define UDI_HID_CON_REPORT_SIZE CONSOLE_EPSIZE
 
 extern uint8_t udi_hid_con_report_set[UDI_HID_CON_REPORT_SIZE];
 
-//report buffer
+// report buffer
 extern uint8_t udi_hid_con_report[UDI_HID_CON_REPORT_SIZE];
 
 COMPILER_PACK_RESET()
 
-#endif //CON
+#endif  // CON
 
 // **********************************************************************
 // CDC Descriptor structure and content
@@ -662,86 +522,28 @@ typedef struct {
 } usb_cdc_union_desc_t;
 
 typedef struct {
-    usb_association_desc_t iaface;
-    usb_iface_desc_t iface_c;
-    usb_cdc_hdr_desc_t fd;
+    usb_association_desc_t   iaface;
+    usb_iface_desc_t         iface_c;
+    usb_cdc_hdr_desc_t       fd;
     usb_cdc_call_mgmt_desc_t mfd;
-    usb_cdc_acm_desc_t acmd;
-    usb_cdc_union_desc_t ufd;
-    usb_ep_desc_t ep_c;
-    usb_iface_desc_t iface_d;
-    usb_ep_desc_t ep_tx;
-    usb_ep_desc_t ep_rx;
+    usb_cdc_acm_desc_t       acmd;
+    usb_cdc_union_desc_t     ufd;
+    usb_ep_desc_t            ep_c;
+    usb_iface_desc_t         iface_d;
+    usb_ep_desc_t            ep_tx;
+    usb_ep_desc_t            ep_rx;
 } udi_cdc_desc_t;
 
-#define CDC_DESCRIPTOR {\
-    .iaface.bLength            = sizeof(usb_association_desc_t),\
-    .iaface.bDescriptorType    = USB_DT_IAD,\
-    .iaface.bFirstInterface    = CDC_STATUS_INTERFACE,\
-    .iaface.bInterfaceCount    = 2,\
-    .iaface.bFunctionClass     = CDC_CLASS_DEVICE,\
-    .iaface.bFunctionSubClass  = CDC_SUBCLASS_ACM,\
-    .iaface.bFunctionProtocol  = CDC_PROTOCOL_V25TER,\
-    .iaface.iFunction          = 0,\
-    .iface_c.bLength             = sizeof(usb_iface_desc_t),\
-    .iface_c.bDescriptorType     = USB_DT_INTERFACE,\
-    .iface_c.bInterfaceNumber    = CDC_STATUS_INTERFACE,\
-    .iface_c.bAlternateSetting   = 0,\
-    .iface_c.bNumEndpoints       = 1,\
-    .iface_c.bInterfaceClass     = 0x02,\
-    .iface_c.bInterfaceSubClass  = 0x02,\
-    .iface_c.bInterfaceProtocol  = CDC_PROTOCOL_V25TER,\
-    .iface_c.iInterface          = 0,\
-    .fd.bFunctionLength        = sizeof(usb_cdc_hdr_desc_t),\
-    .fd.bDescriptorType        = CDC_CS_INTERFACE,\
-    .fd.bDescriptorSubtype     = CDC_SCS_HEADER,\
-    .fd.bcdCDC                 = 0x0110,\
-    .mfd.bFunctionLength       = sizeof(usb_cdc_call_mgmt_desc_t),\
-    .mfd.bDescriptorType       = CDC_CS_INTERFACE,\
-    .mfd.bDescriptorSubtype    = CDC_SCS_CALL_MGMT,\
-    .mfd.bmCapabilities        = CDC_CALL_MGMT_SUPPORTED,\
-    .mfd.bDataInterface        = CDC_DATA_INTERFACE,\
-    .acmd.bFunctionLength      = sizeof(usb_cdc_acm_desc_t),\
-    .acmd.bDescriptorType      = CDC_CS_INTERFACE,\
-    .acmd.bDescriptorSubtype   = CDC_SCS_ACM,\
-    .acmd.bmCapabilities       = CDC_ACM_SUPPORT_LINE_REQUESTS,\
-    .ufd.bFunctionLength       = sizeof(usb_cdc_union_desc_t),\
-    .ufd.bDescriptorType       = CDC_CS_INTERFACE,\
-    .ufd.bDescriptorSubtype    = CDC_SCS_UNION,\
-    .ufd.bMasterInterface      = CDC_STATUS_INTERFACE,\
-    .ufd.bSlaveInterface0      = CDC_DATA_INTERFACE,\
-    .ep_c.bLength                = sizeof(usb_ep_desc_t),\
-    .ep_c.bDescriptorType        = USB_DT_ENDPOINT,\
-    .ep_c.bEndpointAddress       = CDC_ACM_ENDPOINT | USB_EP_DIR_IN,\
-    .ep_c.bmAttributes           = USB_EP_TYPE_INTERRUPT,\
-    .ep_c.wMaxPacketSize         = LE16(CDC_ACM_SIZE),\
-    .ep_c.bInterval              = CDC_EP_INTERVAL_STATUS,\
-    .iface_d.bLength             = sizeof(usb_iface_desc_t),\
-    .iface_d.bDescriptorType     = USB_DT_INTERFACE,\
-    .iface_d.bInterfaceNumber    = CDC_DATA_INTERFACE,\
-    .iface_d.bAlternateSetting   = 0,\
-    .iface_d.bNumEndpoints       = 2,\
-    .iface_d.bInterfaceClass     = CDC_CLASS_DATA,\
-    .iface_d.bInterfaceSubClass  = 0,\
-    .iface_d.bInterfaceProtocol  = 0,\
-    .iface_d.iInterface          = 0,\
-    .ep_rx.bLength                = sizeof(usb_ep_desc_t),\
-    .ep_rx.bDescriptorType        = USB_DT_ENDPOINT,\
-    .ep_rx.bEndpointAddress       = CDC_RX_ENDPOINT | USB_EP_DIR_OUT,\
-    .ep_rx.bmAttributes           = USB_EP_TYPE_BULK,\
-    .ep_rx.wMaxPacketSize         = LE16(CDC_RX_SIZE),\
-    .ep_rx.bInterval              = CDC_EP_INTERVAL_DATA,\
-    .ep_tx.bLength                = sizeof(usb_ep_desc_t),\
-    .ep_tx.bDescriptorType        = USB_DT_ENDPOINT,\
-    .ep_tx.bEndpointAddress       = CDC_TX_ENDPOINT | USB_EP_DIR_IN,\
-    .ep_tx.bmAttributes           = USB_EP_TYPE_BULK,\
-    .ep_tx.wMaxPacketSize         = LE16(CDC_TX_SIZE),\
-    .ep_tx.bInterval              = CDC_EP_INTERVAL_DATA,\
-}
+#    define CDC_DESCRIPTOR                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          \
+        {                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           \
+            .iaface.bLength = sizeof(usb_association_desc_t), .iaface.bDescriptorType = USB_DT_IAD, .iaface.bFirstInterface = CDC_STATUS_INTERFACE, .iaface.bInterfaceCount = 2, .iaface.bFunctionClass = CDC_CLASS_DEVICE, .iaface.bFunctionSubClass = CDC_SUBCLASS_ACM, .iaface.bFunctionProtocol = CDC_PROTOCOL_V25TER, .iaface.iFunction = 0, .iface_c.bLength = sizeof(usb_iface_desc_t), .iface_c.bDescriptorType = USB_DT_INTERFACE, .iface_c.bInterfaceNumber = CDC_STATUS_INTERFACE, .iface_c.bAlternateSetting = 0, .iface_c.bNumEndpoints = 1, .iface_c.bInterfaceClass = 0x02, .iface_c.bInterfaceSubClass = 0x02, .iface_c.bInterfaceProtocol = CDC_PROTOCOL_V25TER, .iface_c.iInterface = 0, .fd.bFunctionLength = sizeof(usb_cdc_hdr_desc_t), .fd.bDescriptorType = CDC_CS_INTERFACE, .fd.bDescriptorSubtype = CDC_SCS_HEADER, .fd.bcdCDC = 0x0110, .mfd.bFunctionLength = sizeof(usb_cdc_call_mgmt_desc_t), .mfd.bDescriptorType = CDC_CS_INTERFACE, .mfd.bDescriptorSubtype = CDC_SCS_CALL_MGMT,   \
+            .mfd.bmCapabilities = CDC_CALL_MGMT_SUPPORTED, .mfd.bDataInterface = CDC_DATA_INTERFACE, .acmd.bFunctionLength = sizeof(usb_cdc_acm_desc_t), .acmd.bDescriptorType = CDC_CS_INTERFACE, .acmd.bDescriptorSubtype = CDC_SCS_ACM, .acmd.bmCapabilities = CDC_ACM_SUPPORT_LINE_REQUESTS, .ufd.bFunctionLength = sizeof(usb_cdc_union_desc_t), .ufd.bDescriptorType = CDC_CS_INTERFACE, .ufd.bDescriptorSubtype = CDC_SCS_UNION, .ufd.bMasterInterface = CDC_STATUS_INTERFACE, .ufd.bSlaveInterface0 = CDC_DATA_INTERFACE, .ep_c.bLength = sizeof(usb_ep_desc_t), .ep_c.bDescriptorType = USB_DT_ENDPOINT, .ep_c.bEndpointAddress = CDC_ACM_ENDPOINT | USB_EP_DIR_IN, .ep_c.bmAttributes = USB_EP_TYPE_INTERRUPT, .ep_c.wMaxPacketSize = LE16(CDC_ACM_SIZE), .ep_c.bInterval = CDC_EP_INTERVAL_STATUS, .iface_d.bLength = sizeof(usb_iface_desc_t), .iface_d.bDescriptorType = USB_DT_INTERFACE, .iface_d.bInterfaceNumber = CDC_DATA_INTERFACE, .iface_d.bAlternateSetting = 0, .iface_d.bNumEndpoints = 2, \
+            .iface_d.bInterfaceClass = CDC_CLASS_DATA, .iface_d.bInterfaceSubClass = 0, .iface_d.bInterfaceProtocol = 0, .iface_d.iInterface = 0, .ep_rx.bLength = sizeof(usb_ep_desc_t), .ep_rx.bDescriptorType = USB_DT_ENDPOINT, .ep_rx.bEndpointAddress = CDC_RX_ENDPOINT | USB_EP_DIR_OUT, .ep_rx.bmAttributes = USB_EP_TYPE_BULK, .ep_rx.wMaxPacketSize = LE16(CDC_RX_SIZE), .ep_rx.bInterval = CDC_EP_INTERVAL_DATA, .ep_tx.bLength = sizeof(usb_ep_desc_t), .ep_tx.bDescriptorType = USB_DT_ENDPOINT, .ep_tx.bEndpointAddress = CDC_TX_ENDPOINT | USB_EP_DIR_IN, .ep_tx.bmAttributes = USB_EP_TYPE_BULK, .ep_tx.wMaxPacketSize = LE16(CDC_TX_SIZE), .ep_tx.bInterval = CDC_EP_INTERVAL_DATA,                                                                                                                                                                                                                                                                                                                \
+        }
 
 COMPILER_PACK_RESET()
 
-#endif //CDC
+#endif  // CDC
 
 // **********************************************************************
 // CONFIGURATION Descriptor structure and content
@@ -778,4 +580,4 @@ typedef struct {
 
 COMPILER_PACK_RESET()
 
-#endif //_UDI_DEVICE_CONF_H_
+#endif  //_UDI_DEVICE_CONF_H_
diff --git a/tmk_core/protocol/arm_atsam/usb/udi_device_epsize.h b/tmk_core/protocol/arm_atsam/usb/udi_device_epsize.h
index 96d03c286..65339bffe 100644
--- a/tmk_core/protocol/arm_atsam/usb/udi_device_epsize.h
+++ b/tmk_core/protocol/arm_atsam/usb/udi_device_epsize.h
@@ -18,15 +18,14 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #ifndef _UDI_DEVICE_EPSIZE_H_
 #define _UDI_DEVICE_EPSIZE_H_
 
-#define KEYBOARD_EPSIZE             8
-#define MOUSE_EPSIZE                8
-#define EXTRAKEY_EPSIZE             8
-#define RAW_EPSIZE                  64
-#define CONSOLE_EPSIZE              32
-#define NKRO_EPSIZE                 32
-#define MIDI_STREAM_EPSIZE          64
-#define CDC_NOTIFICATION_EPSIZE     8
-#define CDC_EPSIZE                  16
-
-#endif //_UDI_DEVICE_EPSIZE_H_
+#define KEYBOARD_EPSIZE 8
+#define MOUSE_EPSIZE 8
+#define EXTRAKEY_EPSIZE 8
+#define RAW_EPSIZE 64
+#define CONSOLE_EPSIZE 32
+#define NKRO_EPSIZE 32
+#define MIDI_STREAM_EPSIZE 64
+#define CDC_NOTIFICATION_EPSIZE 8
+#define CDC_EPSIZE 16
 
+#endif  //_UDI_DEVICE_EPSIZE_H_
diff --git a/tmk_core/protocol/arm_atsam/usb/udi_hid.c b/tmk_core/protocol/arm_atsam/usb/udi_hid.c
index 131b7a0ec..b0bdcc693 100644
--- a/tmk_core/protocol/arm_atsam/usb/udi_hid.c
+++ b/tmk_core/protocol/arm_atsam/usb/udi_hid.c
@@ -50,7 +50,6 @@
 #include "udc.h"
 #include "udi_hid.h"
 
-
 /**
  * \ingroup udi_hid_group
  * \defgroup udi_hid_group_internal Implementation of HID common library
@@ -64,34 +63,31 @@
  */
 static bool udi_hid_reqstdifaceget_descriptor(uint8_t *report_desc);
 
-bool udi_hid_setup( uint8_t *rate, uint8_t *protocol, uint8_t *report_desc, bool (*setup_report)(void) )
-{
+bool udi_hid_setup(uint8_t *rate, uint8_t *protocol, uint8_t *report_desc, bool (*setup_report)(void)) {
     if (Udd_setup_is_in()) {
         // Requests Interface GET
         if (Udd_setup_type() == USB_REQ_TYPE_STANDARD) {
             // Requests Standard Interface Get
             switch (udd_g_ctrlreq.req.bRequest) {
-
-            case USB_REQ_GET_DESCRIPTOR:
-                return udi_hid_reqstdifaceget_descriptor(report_desc);
+                case USB_REQ_GET_DESCRIPTOR:
+                    return udi_hid_reqstdifaceget_descriptor(report_desc);
             }
         }
         if (Udd_setup_type() == USB_REQ_TYPE_CLASS) {
             // Requests Class Interface Get
             switch (udd_g_ctrlreq.req.bRequest) {
-
-            case USB_REQ_HID_GET_REPORT:
-                return setup_report();
-
-            case USB_REQ_HID_GET_IDLE:
-                udd_g_ctrlreq.payload = rate;
-                udd_g_ctrlreq.payload_size = 1;
-                return true;
-
-            case USB_REQ_HID_GET_PROTOCOL:
-                udd_g_ctrlreq.payload = protocol;
-                udd_g_ctrlreq.payload_size = 1;
-                return true;
+                case USB_REQ_HID_GET_REPORT:
+                    return setup_report();
+
+                case USB_REQ_HID_GET_IDLE:
+                    udd_g_ctrlreq.payload      = rate;
+                    udd_g_ctrlreq.payload_size = 1;
+                    return true;
+
+                case USB_REQ_HID_GET_PROTOCOL:
+                    udd_g_ctrlreq.payload      = protocol;
+                    udd_g_ctrlreq.payload_size = 1;
+                    return true;
             }
         }
     }
@@ -100,60 +96,50 @@ bool udi_hid_setup( uint8_t *rate, uint8_t *protocol, uint8_t *report_desc, bool
         if (Udd_setup_type() == USB_REQ_TYPE_CLASS) {
             // Requests Class Interface Set
             switch (udd_g_ctrlreq.req.bRequest) {
+                case USB_REQ_HID_SET_REPORT:
+                    return setup_report();
 
-            case USB_REQ_HID_SET_REPORT:
-                return setup_report();
-
-            case USB_REQ_HID_SET_IDLE:
-                *rate = udd_g_ctrlreq.req.wValue >> 8;
-                return true;
+                case USB_REQ_HID_SET_IDLE:
+                    *rate = udd_g_ctrlreq.req.wValue >> 8;
+                    return true;
 
-            case USB_REQ_HID_SET_PROTOCOL:
-                if (0 != udd_g_ctrlreq.req.wLength)
-                    return false;
-                *protocol = udd_g_ctrlreq.req.wValue;
-                return true;
+                case USB_REQ_HID_SET_PROTOCOL:
+                    if (0 != udd_g_ctrlreq.req.wLength) return false;
+                    *protocol = udd_g_ctrlreq.req.wValue;
+                    return true;
             }
         }
     }
-    return false;   // Request not supported
+    return false;  // Request not supported
 }
 
 //---------------------------------------------
 //------- Internal routines
 
-static bool udi_hid_reqstdifaceget_descriptor(uint8_t *report_desc)
-{
+static bool udi_hid_reqstdifaceget_descriptor(uint8_t *report_desc) {
     usb_hid_descriptor_t UDC_DESC_STORAGE *ptr_hid_desc;
 
     // Get the USB descriptor which is located after the interface descriptor
     // This descriptor must be the HID descriptor
-    ptr_hid_desc = (usb_hid_descriptor_t UDC_DESC_STORAGE *) ((uint8_t *)
-            udc_get_interface_desc() + sizeof(usb_iface_desc_t));
-    if (USB_DT_HID != ptr_hid_desc->bDescriptorType)
-        return false;
+    ptr_hid_desc = (usb_hid_descriptor_t UDC_DESC_STORAGE *)((uint8_t *)udc_get_interface_desc() + sizeof(usb_iface_desc_t));
+    if (USB_DT_HID != ptr_hid_desc->bDescriptorType) return false;
 
     // The SETUP request can ask for:
     // - an USB_DT_HID descriptor
     // - or USB_DT_HID_REPORT descriptor
     // - or USB_DT_HID_PHYSICAL descriptor
-    if (USB_DT_HID == (uint8_t) (udd_g_ctrlreq.req.wValue >> 8)) {
+    if (USB_DT_HID == (uint8_t)(udd_g_ctrlreq.req.wValue >> 8)) {
         // USB_DT_HID descriptor requested then send it
-        udd_g_ctrlreq.payload = (uint8_t *) ptr_hid_desc;
-        udd_g_ctrlreq.payload_size =
-                min(udd_g_ctrlreq.req.wLength,
-                ptr_hid_desc->bLength);
+        udd_g_ctrlreq.payload      = (uint8_t *)ptr_hid_desc;
+        udd_g_ctrlreq.payload_size = min(udd_g_ctrlreq.req.wLength, ptr_hid_desc->bLength);
         return true;
     }
     // The HID_X descriptor requested must correspond to report type
     // included in the HID descriptor
-    if (ptr_hid_desc->bRDescriptorType ==
-            (uint8_t) (udd_g_ctrlreq.req.wValue >> 8)) {
+    if (ptr_hid_desc->bRDescriptorType == (uint8_t)(udd_g_ctrlreq.req.wValue >> 8)) {
         // Send HID Report descriptor given by high level
-        udd_g_ctrlreq.payload = report_desc;
-        udd_g_ctrlreq.payload_size =
-                min(udd_g_ctrlreq.req.wLength,
-                le16_to_cpu(ptr_hid_desc->wDescriptorLength));
+        udd_g_ctrlreq.payload      = report_desc;
+        udd_g_ctrlreq.payload_size = min(udd_g_ctrlreq.req.wLength, le16_to_cpu(ptr_hid_desc->wDescriptorLength));
         return true;
     }
     return false;
diff --git a/tmk_core/protocol/arm_atsam/usb/udi_hid.h b/tmk_core/protocol/arm_atsam/usb/udi_hid.h
index 0edb09c1c..6fd2cabd4 100644
--- a/tmk_core/protocol/arm_atsam/usb/udi_hid.h
+++ b/tmk_core/protocol/arm_atsam/usb/udi_hid.h
@@ -75,11 +75,11 @@ extern "C" {
  *
  * \return \c 1 if function was successfully done, otherwise \c 0.
  */
-bool udi_hid_setup( uint8_t *rate, uint8_t *protocol, uint8_t *report_desc, bool (*setup_report)(void) );
+bool udi_hid_setup(uint8_t *rate, uint8_t *protocol, uint8_t *report_desc, bool (*setup_report)(void));
 
 //@}
 
 #ifdef __cplusplus
 }
 #endif
-#endif // _UDI_HID_H_
+#endif  // _UDI_HID_H_
diff --git a/tmk_core/protocol/arm_atsam/usb/udi_hid_kbd.c b/tmk_core/protocol/arm_atsam/usb/udi_hid_kbd.c
index b715b7026..c3952d50c 100644
--- a/tmk_core/protocol/arm_atsam/usb/udi_hid_kbd.c
+++ b/tmk_core/protocol/arm_atsam/usb/udi_hid_kbd.c
@@ -61,15 +61,15 @@
 //***************************************************************************
 #ifdef KBD
 
-bool udi_hid_kbd_enable(void);
-void udi_hid_kbd_disable(void);
-bool udi_hid_kbd_setup(void);
+bool    udi_hid_kbd_enable(void);
+void    udi_hid_kbd_disable(void);
+bool    udi_hid_kbd_setup(void);
 uint8_t udi_hid_kbd_getsetting(void);
 
 UDC_DESC_STORAGE udi_api_t udi_api_hid_kbd = {
-    .enable = (bool(*)(void))udi_hid_kbd_enable,
-    .disable = (void (*)(void))udi_hid_kbd_disable,
-    .setup = (bool(*)(void))udi_hid_kbd_setup,
+    .enable     = (bool (*)(void))udi_hid_kbd_enable,
+    .disable    = (void (*)(void))udi_hid_kbd_disable,
+    .setup      = (bool (*)(void))udi_hid_kbd_setup,
     .getsetting = (uint8_t(*)(void))udi_hid_kbd_getsetting,
     .sof_notify = NULL,
 };
@@ -94,40 +94,38 @@ COMPILER_WORD_ALIGNED
 static uint8_t udi_hid_kbd_report_trans[UDI_HID_KBD_REPORT_SIZE];
 
 COMPILER_WORD_ALIGNED
-UDC_DESC_STORAGE udi_hid_kbd_report_desc_t udi_hid_kbd_report_desc = {
-    {
-        0x05, 0x01,     // Usage Page (Generic Desktop)
-        0x09, 0x06,     // Usage (Keyboard)
-        0xA1, 0x01,     // Collection (Application)
-        0x05, 0x07,     //   Usage Page (Keyboard)
-        0x19, 0xE0,     //   Usage Minimum (224)
-        0x29, 0xE7,     //   Usage Maximum (231)
-        0x15, 0x00,     //   Logical Minimum (0)
-        0x25, 0x01,     //   Logical Maximum (1)
-        0x75, 0x01,     //   Report Size (1)
-        0x95, 0x08,     //   Report Count (8)
-        0x81, 0x02,     //   Input (Data, Variable, Absolute)
-        0x81, 0x01,     //   Input (Constant)
-        0x19, 0x00,     //   Usage Minimum (0)
-        0x29, 0xFF,     //   Usage Maximum (255)
-        0x15, 0x00,     //   Logical Minimum (0)
-        0x25, 0xFF,     //   Logical Maximum (255)
-        0x75, 0x08,     //   Report Size (8)
-        0x95, 0x06,     //   Report Count (6)
-        0x81, 0x00,     //   Input (Data, Array)
-        0x05, 0x08,     //   Usage Page (LED)
-        0x19, 0x01,     //   Usage Minimum (1)
-        0x29, 0x05,     //   Usage Maximum (5)
-        0x15, 0x00,     //   Logical Minimum (0)
-        0x25, 0x01,     //   Logical Maximum (1)
-        0x75, 0x01,     //   Report Size (1)
-        0x95, 0x05,     //   Report Count (5)
-        0x91, 0x02,     //   Output (Data, Variable, Absolute)
-        0x95, 0x03,     //   Report Count (3)
-        0x91, 0x01,     //   Output (Constant)
-        0xC0            // End Collection
-    }
-};
+UDC_DESC_STORAGE udi_hid_kbd_report_desc_t udi_hid_kbd_report_desc = {{
+    0x05, 0x01,  // Usage Page (Generic Desktop)
+    0x09, 0x06,  // Usage (Keyboard)
+    0xA1, 0x01,  // Collection (Application)
+    0x05, 0x07,  //   Usage Page (Keyboard)
+    0x19, 0xE0,  //   Usage Minimum (224)
+    0x29, 0xE7,  //   Usage Maximum (231)
+    0x15, 0x00,  //   Logical Minimum (0)
+    0x25, 0x01,  //   Logical Maximum (1)
+    0x75, 0x01,  //   Report Size (1)
+    0x95, 0x08,  //   Report Count (8)
+    0x81, 0x02,  //   Input (Data, Variable, Absolute)
+    0x81, 0x01,  //   Input (Constant)
+    0x19, 0x00,  //   Usage Minimum (0)
+    0x29, 0xFF,  //   Usage Maximum (255)
+    0x15, 0x00,  //   Logical Minimum (0)
+    0x25, 0xFF,  //   Logical Maximum (255)
+    0x75, 0x08,  //   Report Size (8)
+    0x95, 0x06,  //   Report Count (6)
+    0x81, 0x00,  //   Input (Data, Array)
+    0x05, 0x08,  //   Usage Page (LED)
+    0x19, 0x01,  //   Usage Minimum (1)
+    0x29, 0x05,  //   Usage Maximum (5)
+    0x15, 0x00,  //   Logical Minimum (0)
+    0x25, 0x01,  //   Logical Maximum (1)
+    0x75, 0x01,  //   Report Size (1)
+    0x95, 0x05,  //   Report Count (5)
+    0x91, 0x02,  //   Output (Data, Variable, Absolute)
+    0x95, 0x03,  //   Report Count (3)
+    0x91, 0x01,  //   Output (Constant)
+    0xC0         // End Collection
+}};
 
 static bool udi_hid_kbd_setreport(void);
 
@@ -135,51 +133,34 @@ static void udi_hid_kbd_report_sent(udd_ep_status_t status, iram_size_t nb_sent,
 
 static void udi_hid_kbd_setreport_valid(void);
 
-bool udi_hid_kbd_enable(void)
-{
+bool udi_hid_kbd_enable(void) {
     // Initialize internal values
-    udi_hid_kbd_rate = 0;
-    udi_hid_kbd_protocol = 0;
+    udi_hid_kbd_rate                   = 0;
+    udi_hid_kbd_protocol               = 0;
     udi_hid_kbd_b_report_trans_ongoing = false;
     memset(udi_hid_kbd_report, 0, UDI_HID_KBD_REPORT_SIZE);
     udi_hid_kbd_b_report_valid = false;
     return UDI_HID_KBD_ENABLE_EXT();
 }
 
-void udi_hid_kbd_disable(void)
-{
-    UDI_HID_KBD_DISABLE_EXT();
-}
+void udi_hid_kbd_disable(void) { UDI_HID_KBD_DISABLE_EXT(); }
 
-bool udi_hid_kbd_setup(void)
-{
-    return udi_hid_setup(&udi_hid_kbd_rate,
-                            &udi_hid_kbd_protocol,
-                            (uint8_t *) &udi_hid_kbd_report_desc,
-                            udi_hid_kbd_setreport);
-}
+bool udi_hid_kbd_setup(void) { return udi_hid_setup(&udi_hid_kbd_rate, &udi_hid_kbd_protocol, (uint8_t *)&udi_hid_kbd_report_desc, udi_hid_kbd_setreport); }
 
-uint8_t udi_hid_kbd_getsetting(void)
-{
-    return 0;
-}
+uint8_t udi_hid_kbd_getsetting(void) { return 0; }
 
-static bool udi_hid_kbd_setreport(void)
-{
-    if ((USB_HID_REPORT_TYPE_OUTPUT == (udd_g_ctrlreq.req.wValue >> 8))
-            && (0 == (0xFF & udd_g_ctrlreq.req.wValue))
-            && (1 == udd_g_ctrlreq.req.wLength)) {
+static bool udi_hid_kbd_setreport(void) {
+    if ((USB_HID_REPORT_TYPE_OUTPUT == (udd_g_ctrlreq.req.wValue >> 8)) && (0 == (0xFF & udd_g_ctrlreq.req.wValue)) && (1 == udd_g_ctrlreq.req.wLength)) {
         // Report OUT type on report ID 0 from USB Host
-        udd_g_ctrlreq.payload = &udi_hid_kbd_report_set;
-        udd_g_ctrlreq.callback = udi_hid_kbd_setreport_valid;
+        udd_g_ctrlreq.payload      = &udi_hid_kbd_report_set;
+        udd_g_ctrlreq.callback     = udi_hid_kbd_setreport_valid;
         udd_g_ctrlreq.payload_size = 1;
         return true;
     }
     return false;
 }
 
-bool udi_hid_kbd_send_report(void)
-{
+bool udi_hid_kbd_send_report(void) {
     if (!main_b_kbd_enable) {
         return false;
     }
@@ -189,19 +170,13 @@ bool udi_hid_kbd_send_report(void)
     }
 
     memcpy(udi_hid_kbd_report_trans, udi_hid_kbd_report, UDI_HID_KBD_REPORT_SIZE);
-    udi_hid_kbd_b_report_valid = false;
-    udi_hid_kbd_b_report_trans_ongoing =
-            udd_ep_run(UDI_HID_KBD_EP_IN | USB_EP_DIR_IN,
-                        false,
-                        udi_hid_kbd_report_trans,
-                        UDI_HID_KBD_REPORT_SIZE,
-                        udi_hid_kbd_report_sent);
+    udi_hid_kbd_b_report_valid         = false;
+    udi_hid_kbd_b_report_trans_ongoing = udd_ep_run(UDI_HID_KBD_EP_IN | USB_EP_DIR_IN, false, udi_hid_kbd_report_trans, UDI_HID_KBD_REPORT_SIZE, udi_hid_kbd_report_sent);
 
     return udi_hid_kbd_b_report_trans_ongoing;
 }
 
-static void udi_hid_kbd_report_sent(udd_ep_status_t status, iram_size_t nb_sent, udd_ep_id_t ep)
-{
+static void udi_hid_kbd_report_sent(udd_ep_status_t status, iram_size_t nb_sent, udd_ep_id_t ep) {
     UNUSED(status);
     UNUSED(nb_sent);
     UNUSED(ep);
@@ -211,27 +186,26 @@ static void udi_hid_kbd_report_sent(udd_ep_status_t status, iram_size_t nb_sent,
     }
 }
 
-static void udi_hid_kbd_setreport_valid(void)
-{
-    //UDI_HID_KBD_CHANGE_LED(udi_hid_kbd_report_set);
+static void udi_hid_kbd_setreport_valid(void) {
+    // UDI_HID_KBD_CHANGE_LED(udi_hid_kbd_report_set);
 }
 
-#endif //KBD
+#endif  // KBD
 
 //********************************************************************************************
 // NKRO Keyboard
 //********************************************************************************************
 #ifdef NKRO
 
-bool udi_hid_nkro_enable(void);
-void udi_hid_nkro_disable(void);
-bool udi_hid_nkro_setup(void);
+bool    udi_hid_nkro_enable(void);
+void    udi_hid_nkro_disable(void);
+bool    udi_hid_nkro_setup(void);
 uint8_t udi_hid_nkro_getsetting(void);
 
 UDC_DESC_STORAGE udi_api_t udi_api_hid_nkro = {
-    .enable = (bool(*)(void))udi_hid_nkro_enable,
-    .disable = (void (*)(void))udi_hid_nkro_disable,
-    .setup = (bool(*)(void))udi_hid_nkro_setup,
+    .enable     = (bool (*)(void))udi_hid_nkro_enable,
+    .disable    = (void (*)(void))udi_hid_nkro_disable,
+    .setup      = (bool (*)(void))udi_hid_nkro_setup,
     .getsetting = (uint8_t(*)(void))udi_hid_nkro_getsetting,
     .sof_notify = NULL,
 };
@@ -256,98 +230,79 @@ COMPILER_WORD_ALIGNED
 static uint8_t udi_hid_nkro_report_trans[UDI_HID_NKRO_REPORT_SIZE];
 
 COMPILER_WORD_ALIGNED
-UDC_DESC_STORAGE udi_hid_nkro_report_desc_t udi_hid_nkro_report_desc = {
-    {
-        0x05, 0x01,     // Usage Page (Generic Desktop),
-        0x09, 0x06,     // Usage (Keyboard),
-        0xA1, 0x01,     // Collection (Application) - Keyboard,
-
-        //Mods
-        0x75, 0x01,     //   Report Size (1),
-        0x95, 0x08,     //   Report Count (8),
-        0x15, 0x00,     //   Logical Minimum (0),
-        0x25, 0x01,     //   Logical Maximum (1),
-        0x05, 0x07,     //   Usage Page (Key Codes),
-        0x19, 0xE0,     //   Usage Minimum (224),
-        0x29, 0xE7,     //   Usage Maximum (231),
-        0x81, 0x02,     //   Input (Data, Variable, Absolute),
-
-        //LED Report
-        0x75, 0x01,     //   Report Size (1),
-        0x95, 0x05,     //   Report Count (5),
-        0x05, 0x08,     //   Usage Page (LEDs),
-        0x19, 0x01,     //   Usage Minimum (1),
-        0x29, 0x05,     //   Usage Maximum (5),
-        0x91, 0x02,     //   Output (Data, Variable, Absolute),
-
-        //LED Report Padding
-        0x75, 0x03,     //   Report Size (3),
-        0x95, 0x01,     //   Report Count (1),
-        0x91, 0x03,     //   Output (Constant),
-
-        //Main keys
-        0x75, 0x01,     //   Report Size (1),
-        0x95, 0xF8,     //   Report Count (248),
-        0x15, 0x00,     //   Logical Minimum (0),
-        0x25, 0x01,     //   Logical Maximum (1),
-        0x05, 0x07,     //   Usage Page (Key Codes),
-        0x19, 0x00,     //   Usage Minimum (0),
-        0x29, 0xF7,     //   Usage Maximum (247),
-        0x81, 0x02,     //   Input (Data, Variable, Absolute, Bitfield),
-        0xc0,           // End Collection - Keyboard
-    }
-};
+UDC_DESC_STORAGE udi_hid_nkro_report_desc_t udi_hid_nkro_report_desc = {{
+    0x05, 0x01,  // Usage Page (Generic Desktop),
+    0x09, 0x06,  // Usage (Keyboard),
+    0xA1, 0x01,  // Collection (Application) - Keyboard,
+
+    // Mods
+    0x75, 0x01,  //   Report Size (1),
+    0x95, 0x08,  //   Report Count (8),
+    0x15, 0x00,  //   Logical Minimum (0),
+    0x25, 0x01,  //   Logical Maximum (1),
+    0x05, 0x07,  //   Usage Page (Key Codes),
+    0x19, 0xE0,  //   Usage Minimum (224),
+    0x29, 0xE7,  //   Usage Maximum (231),
+    0x81, 0x02,  //   Input (Data, Variable, Absolute),
+
+    // LED Report
+    0x75, 0x01,  //   Report Size (1),
+    0x95, 0x05,  //   Report Count (5),
+    0x05, 0x08,  //   Usage Page (LEDs),
+    0x19, 0x01,  //   Usage Minimum (1),
+    0x29, 0x05,  //   Usage Maximum (5),
+    0x91, 0x02,  //   Output (Data, Variable, Absolute),
+
+    // LED Report Padding
+    0x75, 0x03,  //   Report Size (3),
+    0x95, 0x01,  //   Report Count (1),
+    0x91, 0x03,  //   Output (Constant),
+
+    // Main keys
+    0x75, 0x01,  //   Report Size (1),
+    0x95, 0xF8,  //   Report Count (248),
+    0x15, 0x00,  //   Logical Minimum (0),
+    0x25, 0x01,  //   Logical Maximum (1),
+    0x05, 0x07,  //   Usage Page (Key Codes),
+    0x19, 0x00,  //   Usage Minimum (0),
+    0x29, 0xF7,  //   Usage Maximum (247),
+    0x81, 0x02,  //   Input (Data, Variable, Absolute, Bitfield),
+    0xc0,        // End Collection - Keyboard
+}};
 
 static bool udi_hid_nkro_setreport(void);
 static void udi_hid_nkro_setreport_valid(void);
 static void udi_hid_nkro_report_sent(udd_ep_status_t status, iram_size_t nb_sent, udd_ep_id_t ep);
 
-bool udi_hid_nkro_enable(void)
-{
+bool udi_hid_nkro_enable(void) {
     // Initialize internal values
-    udi_hid_nkro_rate = 0;
-    udi_hid_nkro_protocol = 0;
+    udi_hid_nkro_rate                   = 0;
+    udi_hid_nkro_protocol               = 0;
     udi_hid_nkro_b_report_trans_ongoing = false;
     memset(udi_hid_nkro_report, 0, UDI_HID_NKRO_REPORT_SIZE);
     udi_hid_nkro_b_report_valid = false;
     return UDI_HID_NKRO_ENABLE_EXT();
 }
 
-void udi_hid_nkro_disable(void)
-{
-    UDI_HID_NKRO_DISABLE_EXT();
-}
+void udi_hid_nkro_disable(void) { UDI_HID_NKRO_DISABLE_EXT(); }
 
-bool udi_hid_nkro_setup(void)
-{
-    return udi_hid_setup(&udi_hid_nkro_rate,
-                            &udi_hid_nkro_protocol,
-                            (uint8_t *) &udi_hid_nkro_report_desc,
-                            udi_hid_nkro_setreport);
-}
+bool udi_hid_nkro_setup(void) { return udi_hid_setup(&udi_hid_nkro_rate, &udi_hid_nkro_protocol, (uint8_t *)&udi_hid_nkro_report_desc, udi_hid_nkro_setreport); }
 
-uint8_t udi_hid_nkro_getsetting(void)
-{
-    return 0;
-}
+uint8_t udi_hid_nkro_getsetting(void) { return 0; }
 
-//keyboard receives LED report here
-static bool udi_hid_nkro_setreport(void)
-{
-    if ((USB_HID_REPORT_TYPE_OUTPUT == (udd_g_ctrlreq.req.wValue >> 8))
-        && (0 == (0xFF & udd_g_ctrlreq.req.wValue))
-        && (1 == udd_g_ctrlreq.req.wLength)) {
+// keyboard receives LED report here
+static bool udi_hid_nkro_setreport(void) {
+    if ((USB_HID_REPORT_TYPE_OUTPUT == (udd_g_ctrlreq.req.wValue >> 8)) && (0 == (0xFF & udd_g_ctrlreq.req.wValue)) && (1 == udd_g_ctrlreq.req.wLength)) {
         // Report OUT type on report ID 0 from USB Host
-        udd_g_ctrlreq.payload = &udi_hid_nkro_report_set;
-        udd_g_ctrlreq.callback = udi_hid_nkro_setreport_valid; //must call routine to transform setreport to LED state
+        udd_g_ctrlreq.payload      = &udi_hid_nkro_report_set;
+        udd_g_ctrlreq.callback     = udi_hid_nkro_setreport_valid;  // must call routine to transform setreport to LED state
         udd_g_ctrlreq.payload_size = 1;
         return true;
     }
     return false;
 }
 
-bool udi_hid_nkro_send_report(void)
-{
+bool udi_hid_nkro_send_report(void) {
     if (!main_b_nkro_enable) {
         return false;
     }
@@ -357,19 +312,13 @@ bool udi_hid_nkro_send_report(void)
     }
 
     memcpy(udi_hid_nkro_report_trans, udi_hid_nkro_report, UDI_HID_NKRO_REPORT_SIZE);
-    udi_hid_nkro_b_report_valid = false;
-    udi_hid_nkro_b_report_trans_ongoing =
-            udd_ep_run(UDI_HID_NKRO_EP_IN | USB_EP_DIR_IN,
-                        false,
-                        udi_hid_nkro_report_trans,
-                        UDI_HID_NKRO_REPORT_SIZE,
-                        udi_hid_nkro_report_sent);
+    udi_hid_nkro_b_report_valid         = false;
+    udi_hid_nkro_b_report_trans_ongoing = udd_ep_run(UDI_HID_NKRO_EP_IN | USB_EP_DIR_IN, false, udi_hid_nkro_report_trans, UDI_HID_NKRO_REPORT_SIZE, udi_hid_nkro_report_sent);
 
     return udi_hid_nkro_b_report_trans_ongoing;
 }
 
-static void udi_hid_nkro_report_sent(udd_ep_status_t status, iram_size_t nb_sent, udd_ep_id_t ep)
-{
+static void udi_hid_nkro_report_sent(udd_ep_status_t status, iram_size_t nb_sent, udd_ep_id_t ep) {
     UNUSED(status);
     UNUSED(nb_sent);
     UNUSED(ep);
@@ -379,27 +328,26 @@ static void udi_hid_nkro_report_sent(udd_ep_status_t status, iram_size_t nb_sent
     }
 }
 
-static void udi_hid_nkro_setreport_valid(void)
-{
-    //UDI_HID_NKRO_CHANGE_LED(udi_hid_nkro_report_set);
+static void udi_hid_nkro_setreport_valid(void) {
+    // UDI_HID_NKRO_CHANGE_LED(udi_hid_nkro_report_set);
 }
 
-#endif //NKRO
+#endif  // NKRO
 
 //********************************************************************************************
 // EXK (extra-keys) SYS-CTRL  Keyboard
 //********************************************************************************************
 #ifdef EXK
 
-bool udi_hid_exk_enable(void);
-void udi_hid_exk_disable(void);
-bool udi_hid_exk_setup(void);
+bool    udi_hid_exk_enable(void);
+void    udi_hid_exk_disable(void);
+bool    udi_hid_exk_setup(void);
 uint8_t udi_hid_exk_getsetting(void);
 
 UDC_DESC_STORAGE udi_api_t udi_api_hid_exk = {
-    .enable = (bool(*)(void))udi_hid_exk_enable,
-    .disable = (void (*)(void))udi_hid_exk_disable,
-    .setup = (bool(*)(void))udi_hid_exk_setup,
+    .enable     = (bool (*)(void))udi_hid_exk_enable,
+    .disable    = (void (*)(void))udi_hid_exk_disable,
+    .setup      = (bool (*)(void))udi_hid_exk_setup,
     .getsetting = (uint8_t(*)(void))udi_hid_exk_getsetting,
     .sof_notify = NULL,
 };
@@ -424,39 +372,37 @@ COMPILER_WORD_ALIGNED
 static uint8_t udi_hid_exk_report_trans[UDI_HID_EXK_REPORT_SIZE];
 
 COMPILER_WORD_ALIGNED
-UDC_DESC_STORAGE udi_hid_exk_report_desc_t udi_hid_exk_report_desc = {
-    {
-        // System Control Collection (8 bits)
-
-        0x05, 0x01,         // Usage Page (Generic Desktop),
-        0x09, 0x80,         // Usage (System Control),
-        0xA1, 0x01,         // Collection (Application),
-        0x85, REPORT_ID_SYSTEM,         //   Report ID (2) (System),
-        0x16, 0x01, 0x00,   //   Logical Minimum (1),
-        0x26, 0x03, 0x00,   //   Logical Maximum (3),
-        0x1A, 0x81, 0x00,   //   Usage Minimum (81) (System Power Down),
-        0x2A, 0x83, 0x00,   //   Usage Maximum (83) (System Wake Up),
-        0x75, 0x10,         //   Report Size (16),
-        0x95, 0x01,         //   Report Count (1),
-        0x81, 0x00,         //   Input (Data, Array),
-        0xC0,               // End Collection - System Control
-
-        // Consumer Control Collection - Media Keys (16 bits)
-
-        0x05, 0x0C,         // Usage Page (Consumer),
-        0x09, 0x01,         // Usage (Consumer Control),
-        0xA1, 0x01,         // Collection (Application),
-        0x85, REPORT_ID_CONSUMER,         //   Report ID (3) (Consumer),
-        0x16, 0x01, 0x00,   //   Logical Minimum (1),
-        0x26, 0x9C, 0x02,   //   Logical Maximum (668),
-        0x1A, 0x01, 0x00,   //   Usage Minimum (1),
-        0x2A, 0x9C, 0x02,   //   Usage Maximum (668),
-        0x75, 0x10,         //   Report Size (16),
-        0x95, 0x01,         //   Report Count (1),
-        0x81, 0x00,         //   Input (Data, Array),
-        0xC0,               // End Collection - Consumer Control
-    }
-};
+UDC_DESC_STORAGE udi_hid_exk_report_desc_t udi_hid_exk_report_desc = {{
+    // System Control Collection (8 bits)
+
+    0x05, 0x01,              // Usage Page (Generic Desktop),
+    0x09, 0x80,              // Usage (System Control),
+    0xA1, 0x01,              // Collection (Application),
+    0x85, REPORT_ID_SYSTEM,  //   Report ID (2) (System),
+    0x16, 0x01, 0x00,        //   Logical Minimum (1),
+    0x26, 0x03, 0x00,        //   Logical Maximum (3),
+    0x1A, 0x81, 0x00,        //   Usage Minimum (81) (System Power Down),
+    0x2A, 0x83, 0x00,        //   Usage Maximum (83) (System Wake Up),
+    0x75, 0x10,              //   Report Size (16),
+    0x95, 0x01,              //   Report Count (1),
+    0x81, 0x00,              //   Input (Data, Array),
+    0xC0,                    // End Collection - System Control
+
+    // Consumer Control Collection - Media Keys (16 bits)
+
+    0x05, 0x0C,                // Usage Page (Consumer),
+    0x09, 0x01,                // Usage (Consumer Control),
+    0xA1, 0x01,                // Collection (Application),
+    0x85, REPORT_ID_CONSUMER,  //   Report ID (3) (Consumer),
+    0x16, 0x01, 0x00,          //   Logical Minimum (1),
+    0x26, 0x9C, 0x02,          //   Logical Maximum (668),
+    0x1A, 0x01, 0x00,          //   Usage Minimum (1),
+    0x2A, 0x9C, 0x02,          //   Usage Maximum (668),
+    0x75, 0x10,                //   Report Size (16),
+    0x95, 0x01,                //   Report Count (1),
+    0x81, 0x00,                //   Input (Data, Array),
+    0xC0,                      // End Collection - Consumer Control
+}};
 
 static bool udi_hid_exk_setreport(void);
 
@@ -464,51 +410,34 @@ static void udi_hid_exk_report_sent(udd_ep_status_t status, iram_size_t nb_sent,
 
 static void udi_hid_exk_setreport_valid(void);
 
-bool udi_hid_exk_enable(void)
-{
+bool udi_hid_exk_enable(void) {
     // Initialize internal values
-    udi_hid_exk_rate = 0;
-    udi_hid_exk_protocol = 0;
+    udi_hid_exk_rate                   = 0;
+    udi_hid_exk_protocol               = 0;
     udi_hid_exk_b_report_trans_ongoing = false;
     memset(udi_hid_exk_report.raw, 0, UDI_HID_EXK_REPORT_SIZE);
     udi_hid_exk_b_report_valid = false;
     return UDI_HID_EXK_ENABLE_EXT();
 }
 
-void udi_hid_exk_disable(void)
-{
-    UDI_HID_EXK_DISABLE_EXT();
-}
+void udi_hid_exk_disable(void) { UDI_HID_EXK_DISABLE_EXT(); }
 
-bool udi_hid_exk_setup(void)
-{
-    return udi_hid_setup(&udi_hid_exk_rate,
-                            &udi_hid_exk_protocol,
-                            (uint8_t *) &udi_hid_exk_report_desc,
-                            udi_hid_exk_setreport);
-}
+bool udi_hid_exk_setup(void) { return udi_hid_setup(&udi_hid_exk_rate, &udi_hid_exk_protocol, (uint8_t *)&udi_hid_exk_report_desc, udi_hid_exk_setreport); }
 
-uint8_t udi_hid_exk_getsetting(void)
-{
-    return 0;
-}
+uint8_t udi_hid_exk_getsetting(void) { return 0; }
 
-static bool udi_hid_exk_setreport(void)
-{
-    if ((USB_HID_REPORT_TYPE_OUTPUT == (udd_g_ctrlreq.req.wValue >> 8))
-            && (0 == (0xFF & udd_g_ctrlreq.req.wValue))
-            && (1 == udd_g_ctrlreq.req.wLength)) {
+static bool udi_hid_exk_setreport(void) {
+    if ((USB_HID_REPORT_TYPE_OUTPUT == (udd_g_ctrlreq.req.wValue >> 8)) && (0 == (0xFF & udd_g_ctrlreq.req.wValue)) && (1 == udd_g_ctrlreq.req.wLength)) {
         // Report OUT type on report ID 0 from USB Host
-        udd_g_ctrlreq.payload = &udi_hid_exk_report_set;
-        udd_g_ctrlreq.callback = udi_hid_exk_setreport_valid;
+        udd_g_ctrlreq.payload      = &udi_hid_exk_report_set;
+        udd_g_ctrlreq.callback     = udi_hid_exk_setreport_valid;
         udd_g_ctrlreq.payload_size = 1;
         return true;
     }
     return false;
 }
 
-bool udi_hid_exk_send_report(void)
-{
+bool udi_hid_exk_send_report(void) {
     if (!main_b_exk_enable) {
         return false;
     }
@@ -518,19 +447,13 @@ bool udi_hid_exk_send_report(void)
     }
 
     memcpy(udi_hid_exk_report_trans, udi_hid_exk_report.raw, UDI_HID_EXK_REPORT_SIZE);
-    udi_hid_exk_b_report_valid = false;
-    udi_hid_exk_b_report_trans_ongoing =
-            udd_ep_run(UDI_HID_EXK_EP_IN | USB_EP_DIR_IN,
-                        false,
-                        udi_hid_exk_report_trans,
-                        UDI_HID_EXK_REPORT_SIZE,
-                        udi_hid_exk_report_sent);
+    udi_hid_exk_b_report_valid         = false;
+    udi_hid_exk_b_report_trans_ongoing = udd_ep_run(UDI_HID_EXK_EP_IN | USB_EP_DIR_IN, false, udi_hid_exk_report_trans, UDI_HID_EXK_REPORT_SIZE, udi_hid_exk_report_sent);
 
     return udi_hid_exk_b_report_trans_ongoing;
 }
 
-static void udi_hid_exk_report_sent(udd_ep_status_t status, iram_size_t nb_sent, udd_ep_id_t ep)
-{
+static void udi_hid_exk_report_sent(udd_ep_status_t status, iram_size_t nb_sent, udd_ep_id_t ep) {
     UNUSED(status);
     UNUSED(nb_sent);
     UNUSED(ep);
@@ -540,27 +463,24 @@ static void udi_hid_exk_report_sent(udd_ep_status_t status, iram_size_t nb_sent,
     }
 }
 
-static void udi_hid_exk_setreport_valid(void)
-{
+static void udi_hid_exk_setreport_valid(void) {}
 
-}
-
-#endif //EXK
+#endif  // EXK
 
 //********************************************************************************************
 // MOU Mouse
 //********************************************************************************************
 #ifdef MOU
 
-bool udi_hid_mou_enable(void);
-void udi_hid_mou_disable(void);
-bool udi_hid_mou_setup(void);
+bool    udi_hid_mou_enable(void);
+void    udi_hid_mou_disable(void);
+bool    udi_hid_mou_setup(void);
 uint8_t udi_hid_mou_getsetting(void);
 
 UDC_DESC_STORAGE udi_api_t udi_api_hid_mou = {
-    .enable = (bool(*)(void))udi_hid_mou_enable,
-    .disable = (void (*)(void))udi_hid_mou_disable,
-    .setup = (bool(*)(void))udi_hid_mou_setup,
+    .enable     = (bool (*)(void))udi_hid_mou_enable,
+    .disable    = (void (*)(void))udi_hid_mou_disable,
+    .setup      = (bool (*)(void))udi_hid_mou_setup,
     .getsetting = (uint8_t(*)(void))udi_hid_mou_getsetting,
     .sof_notify = NULL,
 };
@@ -571,8 +491,8 @@ static uint8_t udi_hid_mou_rate;
 COMPILER_WORD_ALIGNED
 static uint8_t udi_hid_mou_protocol;
 
-//COMPILER_WORD_ALIGNED
-//uint8_t udi_hid_mou_report_set; //No set report
+// COMPILER_WORD_ALIGNED
+// uint8_t udi_hid_mou_report_set; //No set report
 
 bool udi_hid_mou_b_report_valid;
 
@@ -585,87 +505,71 @@ COMPILER_WORD_ALIGNED
 static uint8_t udi_hid_mou_report_trans[UDI_HID_MOU_REPORT_SIZE];
 
 COMPILER_WORD_ALIGNED
-UDC_DESC_STORAGE udi_hid_mou_report_desc_t udi_hid_mou_report_desc = {
-    {
-        0x05, 0x01,         // Usage Page (Generic Desktop),
-        0x09, 0x02,         // Usage (Mouse),
-        0xA1, 0x01,         // Collection (Application),
-        0x09, 0x01,         //   Usage (Pointer),
-        0xA1, 0x00,         //   Collection (Physical),
-        0x05, 0x09,         //     Usage Page (Buttons),
-        0x19, 0x01,         //     Usage Minimum (01),
-        0x29, 0x05,         //     Usage Maximun (05),
-        0x15, 0x00,         //     Logical Minimum (0),
-        0x25, 0x01,         //     Logical Maximum (1),
-        0x95, 0x05,         //     Report Count (5),
-        0x75, 0x01,         //     Report Size (1),
-        0x81, 0x02,         //     Input (Data, Variable, Absolute), ;5 button bits
-        0x95, 0x01,         //     Report Count (1),
-        0x75, 0x03,         //     Report Size (3),
-        0x81, 0x01,         //     Input (Constant), ;3 bit padding,
-
-        0x05, 0x01,         //     Usage Page (Generic Desktop),
-        0x09, 0x30,         //     Usage (X),
-        0x09, 0x31,         //     Usage (Y),
-        0x15, 0x81,         //     Logical Minimum (-127),
-        0x25, 0x7F,         //     Logical Maximum (127),
-        0x95, 0x02,         //     Report Count (2),
-        0x75, 0x08,         //     Report Size (8),
-        0x81, 0x06,         //     Input (Data, Variable, Relative), ;2 position bytes (X & Y),
-
-        0x09, 0x38,         //     Usage (Wheel),
-        0x15, 0x81,         //     Logical Minimum (-127),
-        0x25, 0x7F,         //     Logical Maximum (127),
-        0x95, 0x01,         //     Report Count (1),
-        0x75, 0x08,         //     Report Size (8),
-        0x81, 0x06,         //     Input (Data, Variable, Relative),
-
-        0x05, 0x0C,         //     Usage Page (Consumer),
-        0x0A, 0x38, 0x02,   //     Usage (AC Pan (Horizontal wheel)),
-        0x15, 0x81,         //     Logical Minimum (-127),
-        0x25, 0x7F,         //     Logical Maximum (127),
-        0x95, 0x01,         //     Report Count (1),
-        0x75, 0x08,         //     Report Size (8),
-        0x81, 0x06,         //     Input (Data, Variable, Relative),
-
-        0xC0,               //   End Collection,
-        0xC0,               // End Collection
-    }
-};
+UDC_DESC_STORAGE udi_hid_mou_report_desc_t udi_hid_mou_report_desc = {{
+    0x05, 0x01,  // Usage Page (Generic Desktop),
+    0x09, 0x02,  // Usage (Mouse),
+    0xA1, 0x01,  // Collection (Application),
+    0x09, 0x01,  //   Usage (Pointer),
+    0xA1, 0x00,  //   Collection (Physical),
+    0x05, 0x09,  //     Usage Page (Buttons),
+    0x19, 0x01,  //     Usage Minimum (01),
+    0x29, 0x05,  //     Usage Maximun (05),
+    0x15, 0x00,  //     Logical Minimum (0),
+    0x25, 0x01,  //     Logical Maximum (1),
+    0x95, 0x05,  //     Report Count (5),
+    0x75, 0x01,  //     Report Size (1),
+    0x81, 0x02,  //     Input (Data, Variable, Absolute), ;5 button bits
+    0x95, 0x01,  //     Report Count (1),
+    0x75, 0x03,  //     Report Size (3),
+    0x81, 0x01,  //     Input (Constant), ;3 bit padding,
+
+    0x05, 0x01,  //     Usage Page (Generic Desktop),
+    0x09, 0x30,  //     Usage (X),
+    0x09, 0x31,  //     Usage (Y),
+    0x15, 0x81,  //     Logical Minimum (-127),
+    0x25, 0x7F,  //     Logical Maximum (127),
+    0x95, 0x02,  //     Report Count (2),
+    0x75, 0x08,  //     Report Size (8),
+    0x81, 0x06,  //     Input (Data, Variable, Relative), ;2 position bytes (X & Y),
+
+    0x09, 0x38,  //     Usage (Wheel),
+    0x15, 0x81,  //     Logical Minimum (-127),
+    0x25, 0x7F,  //     Logical Maximum (127),
+    0x95, 0x01,  //     Report Count (1),
+    0x75, 0x08,  //     Report Size (8),
+    0x81, 0x06,  //     Input (Data, Variable, Relative),
+
+    0x05, 0x0C,        //     Usage Page (Consumer),
+    0x0A, 0x38, 0x02,  //     Usage (AC Pan (Horizontal wheel)),
+    0x15, 0x81,        //     Logical Minimum (-127),
+    0x25, 0x7F,        //     Logical Maximum (127),
+    0x95, 0x01,        //     Report Count (1),
+    0x75, 0x08,        //     Report Size (8),
+    0x81, 0x06,        //     Input (Data, Variable, Relative),
+
+    0xC0,  //   End Collection,
+    0xC0,  // End Collection
+}};
 
 static void udi_hid_mou_report_sent(udd_ep_status_t status, iram_size_t nb_sent, udd_ep_id_t ep);
 
-bool udi_hid_mou_enable(void)
-{
+bool udi_hid_mou_enable(void) {
     // Initialize internal values
-    udi_hid_mou_rate = 0;
-    udi_hid_mou_protocol = 0;
+    udi_hid_mou_rate                   = 0;
+    udi_hid_mou_protocol               = 0;
     udi_hid_mou_b_report_trans_ongoing = false;
     memset(udi_hid_mou_report, 0, UDI_HID_MOU_REPORT_SIZE);
     udi_hid_mou_b_report_valid = false;
     return UDI_HID_MOU_ENABLE_EXT();
 }
 
-void udi_hid_mou_disable(void)
-{
-    UDI_HID_MOU_DISABLE_EXT();
-}
+void udi_hid_mou_disable(void) { UDI_HID_MOU_DISABLE_EXT(); }
 
-bool udi_hid_mou_setup(void)
-{
-    return udi_hid_setup(&udi_hid_mou_rate,
-                            &udi_hid_mou_protocol,
-                            (uint8_t *) &udi_hid_mou_report_desc,
-                            NULL);
-}
+bool udi_hid_mou_setup(void) { return udi_hid_setup(&udi_hid_mou_rate, &udi_hid_mou_protocol, (uint8_t *)&udi_hid_mou_report_desc, NULL); }
 
-uint8_t udi_hid_mou_getsetting(void)
-{
-    return 0;
-}
+uint8_t udi_hid_mou_getsetting(void) { return 0; }
 
-bool udi_hid_mou_send_report(void)
-{
+bool udi_hid_mou_send_report(void) {
     if (!main_b_mou_enable) {
         return false;
     }
@@ -675,19 +579,13 @@ bool udi_hid_mou_send_report(void)
     }
 
     memcpy(udi_hid_mou_report_trans, udi_hid_mou_report, UDI_HID_MOU_REPORT_SIZE);
-    udi_hid_mou_b_report_valid = false;
-    udi_hid_mou_b_report_trans_ongoing =
-            udd_ep_run(UDI_HID_MOU_EP_IN | USB_EP_DIR_IN,
-                        false,
-                        udi_hid_mou_report_trans,
-                        UDI_HID_MOU_REPORT_SIZE,
-                        udi_hid_mou_report_sent);
+    udi_hid_mou_b_report_valid         = false;
+    udi_hid_mou_b_report_trans_ongoing = udd_ep_run(UDI_HID_MOU_EP_IN | USB_EP_DIR_IN, false, udi_hid_mou_report_trans, UDI_HID_MOU_REPORT_SIZE, udi_hid_mou_report_sent);
 
     return udi_hid_mou_b_report_trans_ongoing;
 }
 
-static void udi_hid_mou_report_sent(udd_ep_status_t status, iram_size_t nb_sent, udd_ep_id_t ep)
-{
+static void udi_hid_mou_report_sent(udd_ep_status_t status, iram_size_t nb_sent, udd_ep_id_t ep) {
     UNUSED(status);
     UNUSED(nb_sent);
     UNUSED(ep);
@@ -697,22 +595,22 @@ static void udi_hid_mou_report_sent(udd_ep_status_t status, iram_size_t nb_sent,
     }
 }
 
-#endif //MOU
+#endif  // MOU
 
 //********************************************************************************************
 // RAW
 //********************************************************************************************
 #ifdef RAW
 
-bool udi_hid_raw_enable(void);
-void udi_hid_raw_disable(void);
-bool udi_hid_raw_setup(void);
+bool    udi_hid_raw_enable(void);
+void    udi_hid_raw_disable(void);
+bool    udi_hid_raw_setup(void);
 uint8_t udi_hid_raw_getsetting(void);
 
 UDC_DESC_STORAGE udi_api_t udi_api_hid_raw = {
-    .enable = (bool(*)(void))udi_hid_raw_enable,
-    .disable = (void (*)(void))udi_hid_raw_disable,
-    .setup = (bool(*)(void))udi_hid_raw_setup,
+    .enable     = (bool (*)(void))udi_hid_raw_enable,
+    .disable    = (void (*)(void))udi_hid_raw_disable,
+    .setup      = (bool (*)(void))udi_hid_raw_setup,
     .getsetting = (uint8_t(*)(void))udi_hid_raw_getsetting,
     .sof_notify = NULL,
 };
@@ -737,76 +635,56 @@ COMPILER_WORD_ALIGNED
 static uint8_t udi_hid_raw_report_trans[UDI_HID_RAW_REPORT_SIZE];
 
 COMPILER_WORD_ALIGNED
-UDC_DESC_STORAGE udi_hid_raw_report_desc_t udi_hid_raw_report_desc = {
-    {
-        0x06,         // Usage Page (Vendor Defined)
-        0xFF, 0xFF,
-        0x0A,         // Usage (Mouse)
-        0xFF, 0xFF,
-        0xA1, 0x01,   // Collection (Application)
-        0x75, 0x08,   //   Report Size (8)
-        0x15, 0x00,   //   Logical Minimum (0)
-        0x25, 0xFF,   //   Logical Maximum (255)
-        0x95, 0x40,   //     Report Count
-        0x09, 0x01,   //     Usage (Input)
-        0x81, 0x02,   //     Input (Data
-        0x95, 0x40,   //     Report Count
-        0x09, 0x02,   //     Usage (Output)
-        0x91, 0x02,   //     Output (Data
-        0xC0,         // End Collection - Consumer Control
-    }
-};
+UDC_DESC_STORAGE udi_hid_raw_report_desc_t udi_hid_raw_report_desc = {{
+    0x06,  // Usage Page (Vendor Defined)
+    0xFF, 0xFF,
+    0x0A,                    // Usage (Mouse)
+    0xFF, 0xFF, 0xA1, 0x01,  // Collection (Application)
+    0x75, 0x08,              //   Report Size (8)
+    0x15, 0x00,              //   Logical Minimum (0)
+    0x25, 0xFF,              //   Logical Maximum (255)
+    0x95, 0x40,              //     Report Count
+    0x09, 0x01,              //     Usage (Input)
+    0x81, 0x02,              //     Input (Data
+    0x95, 0x40,              //     Report Count
+    0x09, 0x02,              //     Usage (Output)
+    0x91, 0x02,              //     Output (Data
+    0xC0,                    // End Collection - Consumer Control
+}};
 
 static bool udi_hid_raw_setreport(void);
 static void udi_hid_raw_setreport_valid(void);
 
 static void udi_hid_raw_report_sent(udd_ep_status_t status, iram_size_t nb_sent, udd_ep_id_t ep);
 
-bool udi_hid_raw_enable(void)
-{
+bool udi_hid_raw_enable(void) {
     // Initialize internal values
-    udi_hid_raw_rate = 0;
-    udi_hid_raw_protocol = 0;
+    udi_hid_raw_rate                   = 0;
+    udi_hid_raw_protocol               = 0;
     udi_hid_raw_b_report_trans_ongoing = false;
     memset(udi_hid_raw_report, 0, UDI_HID_RAW_REPORT_SIZE);
     udi_hid_raw_b_report_valid = false;
     return UDI_HID_RAW_ENABLE_EXT();
 }
 
-void udi_hid_raw_disable(void)
-{
-    UDI_HID_RAW_DISABLE_EXT();
-}
+void udi_hid_raw_disable(void) { UDI_HID_RAW_DISABLE_EXT(); }
 
-bool udi_hid_raw_setup(void)
-{
-    return udi_hid_setup(&udi_hid_raw_rate,
-                            &udi_hid_raw_protocol,
-                            (uint8_t *) &udi_hid_raw_report_desc,
-                            udi_hid_raw_setreport);
-}
+bool udi_hid_raw_setup(void) { return udi_hid_setup(&udi_hid_raw_rate, &udi_hid_raw_protocol, (uint8_t *)&udi_hid_raw_report_desc, udi_hid_raw_setreport); }
 
-uint8_t udi_hid_raw_getsetting(void)
-{
-    return 0;
-}
+uint8_t udi_hid_raw_getsetting(void) { return 0; }
 
-static bool udi_hid_raw_setreport(void)
-{
-    if ((USB_HID_REPORT_TYPE_OUTPUT == (udd_g_ctrlreq.req.wValue >> 8))
-            && (0 == (0xFF & udd_g_ctrlreq.req.wValue))
-            && (UDI_HID_RAW_REPORT_SIZE == udd_g_ctrlreq.req.wLength)) {
+static bool udi_hid_raw_setreport(void) {
+    if ((USB_HID_REPORT_TYPE_OUTPUT == (udd_g_ctrlreq.req.wValue >> 8)) && (0 == (0xFF & udd_g_ctrlreq.req.wValue)) && (UDI_HID_RAW_REPORT_SIZE == udd_g_ctrlreq.req.wLength)) {
         // Report OUT type on report ID 0 from USB Host
-        udd_g_ctrlreq.payload = udi_hid_raw_report_set;
-        udd_g_ctrlreq.callback = udi_hid_raw_setreport_valid; //must call routine to transform setreport to LED state
+        udd_g_ctrlreq.payload      = udi_hid_raw_report_set;
+        udd_g_ctrlreq.callback     = udi_hid_raw_setreport_valid;  // must call routine to transform setreport to LED state
         udd_g_ctrlreq.payload_size = UDI_HID_RAW_REPORT_SIZE;
         return true;
     }
     return false;
 }
 
-bool udi_hid_raw_send_report(void)
-{
+bool udi_hid_raw_send_report(void) {
     if (!main_b_raw_enable) {
         return false;
     }
@@ -815,20 +693,14 @@ bool udi_hid_raw_send_report(void)
         return false;
     }
 
-    memcpy(udi_hid_raw_report_trans, udi_hid_raw_report,UDI_HID_RAW_REPORT_SIZE);
-    udi_hid_raw_b_report_valid = false;
-    udi_hid_raw_b_report_trans_ongoing =
-            udd_ep_run(UDI_HID_RAW_EP_IN | USB_EP_DIR_IN,
-                        false,
-                        udi_hid_raw_report_trans,
-                        UDI_HID_RAW_REPORT_SIZE,
-                        udi_hid_raw_report_sent);
+    memcpy(udi_hid_raw_report_trans, udi_hid_raw_report, UDI_HID_RAW_REPORT_SIZE);
+    udi_hid_raw_b_report_valid         = false;
+    udi_hid_raw_b_report_trans_ongoing = udd_ep_run(UDI_HID_RAW_EP_IN | USB_EP_DIR_IN, false, udi_hid_raw_report_trans, UDI_HID_RAW_REPORT_SIZE, udi_hid_raw_report_sent);
 
     return udi_hid_raw_b_report_trans_ongoing;
 }
 
-static void udi_hid_raw_report_sent(udd_ep_status_t status, iram_size_t nb_sent, udd_ep_id_t ep)
-{
+static void udi_hid_raw_report_sent(udd_ep_status_t status, iram_size_t nb_sent, udd_ep_id_t ep) {
     UNUSED(status);
     UNUSED(nb_sent);
     UNUSED(ep);
@@ -838,27 +710,24 @@ static void udi_hid_raw_report_sent(udd_ep_status_t status, iram_size_t nb_sent,
     }
 }
 
-static void udi_hid_raw_setreport_valid(void)
-{
+static void udi_hid_raw_setreport_valid(void) {}
 
-}
-
-#endif //RAW
+#endif  // RAW
 
 //********************************************************************************************
 // CON
 //********************************************************************************************
 #ifdef CON
 
-bool udi_hid_con_enable(void);
-void udi_hid_con_disable(void);
-bool udi_hid_con_setup(void);
+bool    udi_hid_con_enable(void);
+void    udi_hid_con_disable(void);
+bool    udi_hid_con_setup(void);
 uint8_t udi_hid_con_getsetting(void);
 
 UDC_DESC_STORAGE udi_api_t udi_api_hid_con = {
-    .enable = (bool(*)(void))udi_hid_con_enable,
-    .disable = (void (*)(void))udi_hid_con_disable,
-    .setup = (bool(*)(void))udi_hid_con_setup,
+    .enable     = (bool (*)(void))udi_hid_con_enable,
+    .disable    = (void (*)(void))udi_hid_con_disable,
+    .setup      = (bool (*)(void))udi_hid_con_setup,
     .getsetting = (uint8_t(*)(void))udi_hid_con_getsetting,
     .sof_notify = NULL,
 };
@@ -883,76 +752,57 @@ COMPILER_WORD_ALIGNED
 static uint8_t udi_hid_con_report_trans[UDI_HID_CON_REPORT_SIZE];
 
 COMPILER_WORD_ALIGNED
-UDC_DESC_STORAGE udi_hid_con_report_desc_t udi_hid_con_report_desc = {
-    {
-        0x06, 0x31, 0xFF,           // Vendor Page (PJRC Teensy compatible)
-        0x09, 0x74,                 // Vendor Usage (PJRC Teensy compatible)
-        0xA1, 0x01,                 // Collection (Application)
-            0x09, 0x75,             //   Usage (Vendor)
-            0x15, 0x00,             //   Logical Minimum (0x00)
-            0x26, 0xFF, 0x00,       //   Logical Maximum (0x00FF)
-            0x95, CONSOLE_EPSIZE,   //   Report Count
-            0x75, 0x08,             //   Report Size (8)
-            0x81, 0x02,             //   Input (Data)
-            0x09, 0x76,             //   Usage (Vendor)
-            0x15, 0x00,             //   Logical Minimum (0x00)
-            0x26, 0xFF, 0x00,       //   Logical Maximum (0x00FF)
-            0x95, CONSOLE_EPSIZE,   //   Report Count
-            0x75, 0x08,             //   Report Size (8)
-            0x91, 0x02,             //   Output (Data)
-        0xC0,                       // End Collection
-    }
-};
+UDC_DESC_STORAGE udi_hid_con_report_desc_t udi_hid_con_report_desc = {{
+    0x06, 0x31,           0xFF,  // Vendor Page (PJRC Teensy compatible)
+    0x09, 0x74,                  // Vendor Usage (PJRC Teensy compatible)
+    0xA1, 0x01,                  // Collection (Application)
+    0x09, 0x75,                  //   Usage (Vendor)
+    0x15, 0x00,                  //   Logical Minimum (0x00)
+    0x26, 0xFF,           0x00,  //   Logical Maximum (0x00FF)
+    0x95, CONSOLE_EPSIZE,        //   Report Count
+    0x75, 0x08,                  //   Report Size (8)
+    0x81, 0x02,                  //   Input (Data)
+    0x09, 0x76,                  //   Usage (Vendor)
+    0x15, 0x00,                  //   Logical Minimum (0x00)
+    0x26, 0xFF,           0x00,  //   Logical Maximum (0x00FF)
+    0x95, CONSOLE_EPSIZE,        //   Report Count
+    0x75, 0x08,                  //   Report Size (8)
+    0x91, 0x02,                  //   Output (Data)
+    0xC0,                        // End Collection
+}};
 
 static bool udi_hid_con_setreport(void);
 static void udi_hid_con_setreport_valid(void);
 
 static void udi_hid_con_report_sent(udd_ep_status_t status, iram_size_t nb_sent, udd_ep_id_t ep);
 
-bool udi_hid_con_enable(void)
-{
+bool udi_hid_con_enable(void) {
     // Initialize internal values
-    udi_hid_con_rate = 0;
-    udi_hid_con_protocol = 0;
+    udi_hid_con_rate                   = 0;
+    udi_hid_con_protocol               = 0;
     udi_hid_con_b_report_trans_ongoing = false;
     memset(udi_hid_con_report, 0, UDI_HID_CON_REPORT_SIZE);
     udi_hid_con_b_report_valid = false;
     return UDI_HID_CON_ENABLE_EXT();
 }
 
-void udi_hid_con_disable(void)
-{
-    UDI_HID_CON_DISABLE_EXT();
-}
+void udi_hid_con_disable(void) { UDI_HID_CON_DISABLE_EXT(); }
 
-bool udi_hid_con_setup(void)
-{
-    return udi_hid_setup(&udi_hid_con_rate,
-                            &udi_hid_con_protocol,
-                            (uint8_t *) &udi_hid_con_report_desc,
-                            udi_hid_con_setreport);
-}
+bool udi_hid_con_setup(void) { return udi_hid_setup(&udi_hid_con_rate, &udi_hid_con_protocol, (uint8_t *)&udi_hid_con_report_desc, udi_hid_con_setreport); }
 
-uint8_t udi_hid_con_getsetting(void)
-{
-    return 0;
-}
+uint8_t udi_hid_con_getsetting(void) { return 0; }
 
-static bool udi_hid_con_setreport(void)
-{
-    if ((USB_HID_REPORT_TYPE_OUTPUT == (udd_g_ctrlreq.req.wValue >> 8))
-            && (0 == (0xFF & udd_g_ctrlreq.req.wValue))
-            && (UDI_HID_CON_REPORT_SIZE == udd_g_ctrlreq.req.wLength)) {
-        udd_g_ctrlreq.payload = udi_hid_con_report_set;
-        udd_g_ctrlreq.callback = udi_hid_con_setreport_valid;
+static bool udi_hid_con_setreport(void) {
+    if ((USB_HID_REPORT_TYPE_OUTPUT == (udd_g_ctrlreq.req.wValue >> 8)) && (0 == (0xFF & udd_g_ctrlreq.req.wValue)) && (UDI_HID_CON_REPORT_SIZE == udd_g_ctrlreq.req.wLength)) {
+        udd_g_ctrlreq.payload      = udi_hid_con_report_set;
+        udd_g_ctrlreq.callback     = udi_hid_con_setreport_valid;
         udd_g_ctrlreq.payload_size = UDI_HID_CON_REPORT_SIZE;
         return true;
     }
     return false;
 }
 
-bool udi_hid_con_send_report(void)
-{
+bool udi_hid_con_send_report(void) {
     if (!main_b_con_enable) {
         return false;
     }
@@ -961,20 +811,14 @@ bool udi_hid_con_send_report(void)
         return false;
     }
 
-    memcpy(udi_hid_con_report_trans, udi_hid_con_report,UDI_HID_CON_REPORT_SIZE);
-    udi_hid_con_b_report_valid = false;
-    udi_hid_con_b_report_trans_ongoing =
-            udd_ep_run(UDI_HID_CON_EP_IN | USB_EP_DIR_IN,
-                        false,
-                        udi_hid_con_report_trans,
-                        UDI_HID_CON_REPORT_SIZE,
-                        udi_hid_con_report_sent);
+    memcpy(udi_hid_con_report_trans, udi_hid_con_report, UDI_HID_CON_REPORT_SIZE);
+    udi_hid_con_b_report_valid         = false;
+    udi_hid_con_b_report_trans_ongoing = udd_ep_run(UDI_HID_CON_EP_IN | USB_EP_DIR_IN, false, udi_hid_con_report_trans, UDI_HID_CON_REPORT_SIZE, udi_hid_con_report_sent);
 
     return udi_hid_con_b_report_trans_ongoing;
 }
 
-static void udi_hid_con_report_sent(udd_ep_status_t status, iram_size_t nb_sent, udd_ep_id_t ep)
-{
+static void udi_hid_con_report_sent(udd_ep_status_t status, iram_size_t nb_sent, udd_ep_id_t ep) {
     UNUSED(status);
     UNUSED(nb_sent);
     UNUSED(ep);
@@ -984,9 +828,6 @@ static void udi_hid_con_report_sent(udd_ep_status_t status, iram_size_t nb_sent,
     }
 }
 
-static void udi_hid_con_setreport_valid(void)
-{
-
-}
+static void udi_hid_con_setreport_valid(void) {}
 
-#endif //CON
+#endif  // CON
diff --git a/tmk_core/protocol/arm_atsam/usb/udi_hid_kbd.h b/tmk_core/protocol/arm_atsam/usb/udi_hid_kbd.h
index e442919a9..82b1cbfe0 100644
--- a/tmk_core/protocol/arm_atsam/usb/udi_hid_kbd.h
+++ b/tmk_core/protocol/arm_atsam/usb/udi_hid_kbd.h
@@ -59,59 +59,59 @@ extern "C" {
 //******************************************************************************
 #ifdef KBD
 extern UDC_DESC_STORAGE udi_api_t udi_api_hid_kbd;
-extern bool udi_hid_kbd_b_report_valid;
-extern volatile bool udi_hid_kbd_b_report_trans_ongoing;
-extern uint8_t udi_hid_kbd_report_set;
-bool udi_hid_kbd_send_report(void);
-#endif //KBD
+extern bool                       udi_hid_kbd_b_report_valid;
+extern volatile bool              udi_hid_kbd_b_report_trans_ongoing;
+extern uint8_t                    udi_hid_kbd_report_set;
+bool                              udi_hid_kbd_send_report(void);
+#endif  // KBD
 
 //********************************************************************************************
 // NKRO Keyboard
 //********************************************************************************************
 #ifdef NKRO
 extern UDC_DESC_STORAGE udi_api_t udi_api_hid_nkro;
-extern bool udi_hid_nkro_b_report_valid;
-extern volatile bool udi_hid_nkro_b_report_trans_ongoing;
-bool udi_hid_nkro_send_report(void);
-#endif //NKRO
+extern bool                       udi_hid_nkro_b_report_valid;
+extern volatile bool              udi_hid_nkro_b_report_trans_ongoing;
+bool                              udi_hid_nkro_send_report(void);
+#endif  // NKRO
 
 //********************************************************************************************
 // SYS-CTRL interface
 //********************************************************************************************
 #ifdef EXK
 extern UDC_DESC_STORAGE udi_api_t udi_api_hid_exk;
-extern bool udi_hid_exk_b_report_valid;
-extern uint8_t udi_hid_exk_report_set;
-bool udi_hid_exk_send_report(void);
-#endif //EXK
+extern bool                       udi_hid_exk_b_report_valid;
+extern uint8_t                    udi_hid_exk_report_set;
+bool                              udi_hid_exk_send_report(void);
+#endif  // EXK
 
 //********************************************************************************************
 // CON Console
 //********************************************************************************************
 #ifdef CON
 extern UDC_DESC_STORAGE udi_api_t udi_api_hid_con;
-extern bool udi_hid_con_b_report_valid;
-extern uint8_t udi_hid_con_report_set[UDI_HID_CON_REPORT_SIZE];
-extern volatile bool udi_hid_con_b_report_trans_ongoing;
-bool udi_hid_con_send_report(void);
-#endif //CON
+extern bool                       udi_hid_con_b_report_valid;
+extern uint8_t                    udi_hid_con_report_set[UDI_HID_CON_REPORT_SIZE];
+extern volatile bool              udi_hid_con_b_report_trans_ongoing;
+bool                              udi_hid_con_send_report(void);
+#endif  // CON
 
 //********************************************************************************************
 // MOU Mouse
 //********************************************************************************************
 #ifdef MOU
 extern UDC_DESC_STORAGE udi_api_t udi_api_hid_mou;
-extern bool udi_hid_mou_b_report_valid;
-bool udi_hid_mou_send_report(void);
-#endif //MOU
+extern bool                       udi_hid_mou_b_report_valid;
+bool                              udi_hid_mou_send_report(void);
+#endif  // MOU
 
 //********************************************************************************************
 // RAW Raw
 //********************************************************************************************
 #ifdef RAW
 extern UDC_DESC_STORAGE udi_api_t udi_api_hid_raw;
-bool udi_hid_raw_send_report(void);
-#endif //RAW
+bool                              udi_hid_raw_send_report(void);
+#endif  // RAW
 
 //@}
 
@@ -119,4 +119,4 @@ bool udi_hid_raw_send_report(void);
 }
 #endif
 
-#endif // _UDC_HID_KBD_H_
+#endif  // _UDC_HID_KBD_H_
diff --git a/tmk_core/protocol/arm_atsam/usb/udi_hid_kbd_conf.h b/tmk_core/protocol/arm_atsam/usb/udi_hid_kbd_conf.h
index db5db17ed..ec73252b6 100644
--- a/tmk_core/protocol/arm_atsam/usb/udi_hid_kbd_conf.h
+++ b/tmk_core/protocol/arm_atsam/usb/udi_hid_kbd_conf.h
@@ -57,4 +57,4 @@
 
 #include "udi_hid_kbd.h"
 
-#endif // _UDI_HID_KBD_CONF_H_
+#endif  // _UDI_HID_KBD_CONF_H_
diff --git a/tmk_core/protocol/arm_atsam/usb/udi_hid_kbd_desc.c b/tmk_core/protocol/arm_atsam/usb/udi_hid_kbd_desc.c
index 2d6e35e25..4e7deaaa3 100644
--- a/tmk_core/protocol/arm_atsam/usb/udi_hid_kbd_desc.c
+++ b/tmk_core/protocol/arm_atsam/usb/udi_hid_kbd_desc.c
@@ -65,37 +65,35 @@
 
 //! USB Device Descriptor
 COMPILER_WORD_ALIGNED
-UDC_DESC_STORAGE usb_dev_desc_t udc_device_desc = {
-    .bLength                   = sizeof(usb_dev_desc_t),
-    .bDescriptorType           = USB_DT_DEVICE,
-    .bcdUSB                    = LE16(USB_V2_0),
-    .bDeviceClass              = DEVICE_CLASS,
-    .bDeviceSubClass           = DEVICE_SUBCLASS,
-    .bDeviceProtocol           = DEVICE_PROTOCOL,
-    .bMaxPacketSize0           = USB_DEVICE_EP_CTRL_SIZE,
-    .idVendor                  = LE16(USB_DEVICE_VENDOR_ID),
-    .idProduct                 = LE16(USB_DEVICE_PRODUCT_ID),
-    .bcdDevice                 = LE16(USB_DEVICE_VERSION),
+UDC_DESC_STORAGE usb_dev_desc_t udc_device_desc = {.bLength         = sizeof(usb_dev_desc_t),
+                                                   .bDescriptorType = USB_DT_DEVICE,
+                                                   .bcdUSB          = LE16(USB_V2_0),
+                                                   .bDeviceClass    = DEVICE_CLASS,
+                                                   .bDeviceSubClass = DEVICE_SUBCLASS,
+                                                   .bDeviceProtocol = DEVICE_PROTOCOL,
+                                                   .bMaxPacketSize0 = USB_DEVICE_EP_CTRL_SIZE,
+                                                   .idVendor        = LE16(USB_DEVICE_VENDOR_ID),
+                                                   .idProduct       = LE16(USB_DEVICE_PRODUCT_ID),
+                                                   .bcdDevice       = LE16(USB_DEVICE_VERSION),
 #ifdef USB_DEVICE_MANUFACTURE_NAME
-    .iManufacturer             = 1,
+                                                   .iManufacturer = 1,
 #else
-    .iManufacturer             = 0,  // No manufacture string
+                                                   .iManufacturer = 0,  // No manufacture string
 #endif
 #ifdef USB_DEVICE_PRODUCT_NAME
-    .iProduct                  = 2,
+                                                   .iProduct = 2,
 #else
-    .iProduct                  = 0,  // No product string
+                                                   .iProduct      = 0,  // No product string
 #endif
 #if (defined USB_DEVICE_SERIAL_NAME || defined USB_DEVICE_GET_SERIAL_NAME_POINTER)
-    .iSerialNumber             = 3,
+                                                   .iSerialNumber = 3,
 #else
-    .iSerialNumber             = 0,  // No serial string
+                                                   .iSerialNumber = 0,  // No serial string
 #endif
-    .bNumConfigurations        = 1
-};
+                                                   .bNumConfigurations = 1};
 
 #if 0
-#ifdef USB_DEVICE_HS_SUPPORT
+#    ifdef USB_DEVICE_HS_SUPPORT
 //! USB Device Qualifier Descriptor for HS
 COMPILER_WORD_ALIGNED
 UDC_DESC_STORAGE usb_dev_qual_desc_t udc_device_qual = {
@@ -108,77 +106,77 @@ UDC_DESC_STORAGE usb_dev_qual_desc_t udc_device_qual = {
     .bMaxPacketSize0           = USB_DEVICE_EP_CTRL_SIZE,
     .bNumConfigurations        = 1
 };
-#endif
+#    endif
 #endif
 
 //! USB Device Configuration Descriptor filled for FS and HS
 COMPILER_WORD_ALIGNED
 UDC_DESC_STORAGE udc_desc_t udc_desc = {
-    .conf.bLength              = sizeof(usb_conf_desc_t),
-    .conf.bDescriptorType      = USB_DT_CONFIGURATION,
-    .conf.wTotalLength         = LE16(sizeof(udc_desc_t)),
-    .conf.bNumInterfaces       = USB_DEVICE_NB_INTERFACE,
-    .conf.bConfigurationValue  = 1,
-    .conf.iConfiguration       = 0,
-    .conf.bmAttributes         = /* USB_CONFIG_ATTR_MUST_SET | */ USB_DEVICE_ATTR,
-    .conf.bMaxPower            = USB_CONFIG_MAX_POWER(USB_DEVICE_POWER),
+    .conf.bLength             = sizeof(usb_conf_desc_t),
+    .conf.bDescriptorType     = USB_DT_CONFIGURATION,
+    .conf.wTotalLength        = LE16(sizeof(udc_desc_t)),
+    .conf.bNumInterfaces      = USB_DEVICE_NB_INTERFACE,
+    .conf.bConfigurationValue = 1,
+    .conf.iConfiguration      = 0,
+    .conf.bmAttributes        = /* USB_CONFIG_ATTR_MUST_SET | */ USB_DEVICE_ATTR,
+    .conf.bMaxPower           = USB_CONFIG_MAX_POWER(USB_DEVICE_POWER),
 #ifdef KBD
-    .hid_kbd                   = UDI_HID_KBD_DESC,
+    .hid_kbd = UDI_HID_KBD_DESC,
 #endif
 #ifdef RAW
-    .hid_raw                   = UDI_HID_RAW_DESC,
+    .hid_raw = UDI_HID_RAW_DESC,
 #endif
 #ifdef MOU
-    .hid_mou                   = UDI_HID_MOU_DESC,
+    .hid_mou = UDI_HID_MOU_DESC,
 #endif
 #ifdef EXK
-  .hid_exk                   = UDI_HID_EXK_DESC,
+    .hid_exk = UDI_HID_EXK_DESC,
 #endif
 #ifdef CON
-  .hid_con                   = UDI_HID_CON_DESC,
+    .hid_con = UDI_HID_CON_DESC,
 #endif
 #ifdef NKRO
-  .hid_nkro                  = UDI_HID_NKRO_DESC,
+    .hid_nkro = UDI_HID_NKRO_DESC,
 #endif
 #ifdef CDC
-  .cdc_serial                = CDC_DESCRIPTOR,
+    .cdc_serial = CDC_DESCRIPTOR,
 #endif
 };
 
 UDC_DESC_STORAGE udi_api_t *udi_apis[USB_DEVICE_NB_INTERFACE] = {
-  #ifdef KBD
+#ifdef KBD
     &udi_api_hid_kbd,
-  #endif
-  #ifdef RAW
+#endif
+#ifdef RAW
     &udi_api_hid_raw,
-  #endif
-  #ifdef MOU
+#endif
+#ifdef MOU
     &udi_api_hid_mou,
-  #endif
-  #ifdef EXK
+#endif
+#ifdef EXK
     &udi_api_hid_exk,
-  #endif
-  #ifdef CON
+#endif
+#ifdef CON
     &udi_api_hid_con,
-  #endif
-  #ifdef NKRO
+#endif
+#ifdef NKRO
     &udi_api_hid_nkro,
-  #endif
-  #ifdef CDC
-  &udi_api_cdc_comm, &udi_api_cdc_data,
-  #endif
+#endif
+#ifdef CDC
+    &udi_api_cdc_comm, &udi_api_cdc_data,
+#endif
 };
 
 //! Add UDI with USB Descriptors FS & HS
-UDC_DESC_STORAGE udc_config_speed_t   udc_config_fshs[1] = {{
-    .desc          = (usb_conf_desc_t UDC_DESC_STORAGE*)&udc_desc,
-    .udi_apis      = udi_apis,
+UDC_DESC_STORAGE udc_config_speed_t udc_config_fshs[1] = {{
+    .desc     = (usb_conf_desc_t UDC_DESC_STORAGE *)&udc_desc,
+    .udi_apis = udi_apis,
 }};
 
 //! Add all information about USB Device in global structure for UDC
 UDC_DESC_STORAGE udc_config_t udc_config = {
     .confdev_lsfs = &udc_device_desc,
-    .conf_lsfs = udc_config_fshs,
+    .conf_lsfs    = udc_config_fshs,
 };
 
 //@}
diff --git a/tmk_core/protocol/arm_atsam/usb/ui.c b/tmk_core/protocol/arm_atsam/usb/ui.c
index 70a619109..86c7edc94 100644
--- a/tmk_core/protocol/arm_atsam/usb/ui.c
+++ b/tmk_core/protocol/arm_atsam/usb/ui.c
@@ -45,10 +45,10 @@
  */
 
 #ifndef ARM_MATH_CM4
- #define ARM_MATH_CM4
+#    define ARM_MATH_CM4
 #endif
 
-#undef LITTLE_ENDIAN  //redefined in samd51j18a.h
+#undef LITTLE_ENDIAN  // redefined in samd51j18a.h
 #include "samd51j18a.h"
 #include "ui.h"
 
@@ -68,37 +68,16 @@ static void ui_wakeup_handler(void)
 }
 #endif
 
-void ui_init(void)
-{
+void ui_init(void) {}
 
-}
+void ui_powerdown(void) {}
 
-void ui_powerdown(void)
-{
+void ui_wakeup_enable(void) {}
 
-}
+void ui_wakeup_disable(void) {}
 
-void ui_wakeup_enable(void)
-{
+void ui_wakeup(void) {}
 
-}
+void ui_process(uint16_t framenumber) {}
 
-void ui_wakeup_disable(void)
-{
-
-}
-
-void ui_wakeup(void)
-{
-
-}
-
-void ui_process(uint16_t framenumber)
-{
-
-}
-
-void ui_kbd_led(uint8_t value)
-{
-
-}
+void ui_kbd_led(uint8_t value) {}
diff --git a/tmk_core/protocol/arm_atsam/usb/ui.h b/tmk_core/protocol/arm_atsam/usb/ui.h
index d1c767d45..f7bc65236 100644
--- a/tmk_core/protocol/arm_atsam/usb/ui.h
+++ b/tmk_core/protocol/arm_atsam/usb/ui.h
@@ -73,4 +73,4 @@ void ui_process(uint16_t framenumber);
  */
 void ui_kbd_led(uint8_t value);
 
-#endif // _UI_H_
+#endif  // _UI_H_
diff --git a/tmk_core/protocol/arm_atsam/usb/usb.c b/tmk_core/protocol/arm_atsam/usb/usb.c
index d30d76dd1..b7393660b 100644
--- a/tmk_core/protocol/arm_atsam/usb/usb.c
+++ b/tmk_core/protocol/arm_atsam/usb/usb.c
@@ -48,11 +48,11 @@
 #define SAMD11 DEVICE_MODE_ONLY
 
 #ifndef ARM_MATH_CM4
-  #define ARM_MATH_CM4
+#    define ARM_MATH_CM4
 #endif
 
 #include "compiler.h"
-#undef LITTLE_ENDIAN  //redefined in samd51j18a.h
+#undef LITTLE_ENDIAN  // redefined in samd51j18a.h
 #include "samd51j18a.h"
 #include <stdbool.h>
 #include <string.h>
@@ -61,28 +61,28 @@
 #include "usb.h"
 
 /** Fields definition from a LPM TOKEN  */
-#define  USB_LPM_ATTRIBUT_BLINKSTATE_MASK      (0xF << 0)
-#define  USB_LPM_ATTRIBUT_HIRD_MASK            (0xF << 4)
-#define  USB_LPM_ATTRIBUT_REMOTEWAKE_MASK      (1 << 8)
-#define  USB_LPM_ATTRIBUT_BLINKSTATE(value)    ((value & 0xF) << 0)
-#define  USB_LPM_ATTRIBUT_HIRD(value)          ((value & 0xF) << 4)
-#define  USB_LPM_ATTRIBUT_REMOTEWAKE(value)    ((value & 1) << 8)
-#define  USB_LPM_ATTRIBUT_BLINKSTATE_L1        USB_LPM_ATTRIBUT_BLINKSTATE(1)
+#define USB_LPM_ATTRIBUT_BLINKSTATE_MASK (0xF << 0)
+#define USB_LPM_ATTRIBUT_HIRD_MASK (0xF << 4)
+#define USB_LPM_ATTRIBUT_REMOTEWAKE_MASK (1 << 8)
+#define USB_LPM_ATTRIBUT_BLINKSTATE(value) ((value & 0xF) << 0)
+#define USB_LPM_ATTRIBUT_HIRD(value) ((value & 0xF) << 4)
+#define USB_LPM_ATTRIBUT_REMOTEWAKE(value) ((value & 1) << 8)
+#define USB_LPM_ATTRIBUT_BLINKSTATE_L1 USB_LPM_ATTRIBUT_BLINKSTATE(1)
 
 /**
  * \brief Mask selecting the index part of an endpoint address
  */
-#define  USB_EP_ADDR_MASK     0x0f
+#define USB_EP_ADDR_MASK 0x0f
 
 /**
  * \brief Endpoint transfer direction is IN
  */
-#define  USB_EP_DIR_IN        0x80
+#define USB_EP_DIR_IN 0x80
 
 /**
  * \brief Endpoint transfer direction is OUT
  */
-#define  USB_EP_DIR_OUT       0x00
+#define USB_EP_DIR_OUT 0x00
 
 /**
  * \name USB SRAM data containing pipe descriptor table
@@ -120,24 +120,13 @@ static struct usb_endpoint_callback_parameter ep_callback_para;
  * \internal USB Device IRQ Mask Bits Map
  */
 static const uint16_t _usb_device_irq_bits[USB_DEVICE_CALLBACK_N] = {
-    USB_DEVICE_INTFLAG_SOF,
-    USB_DEVICE_INTFLAG_EORST,
-    USB_DEVICE_INTFLAG_WAKEUP | USB_DEVICE_INTFLAG_EORSM | USB_DEVICE_INTFLAG_UPRSM,
-    USB_DEVICE_INTFLAG_RAMACER,
-    USB_DEVICE_INTFLAG_SUSPEND,
-    USB_DEVICE_INTFLAG_LPMNYET,
-    USB_DEVICE_INTFLAG_LPMSUSP,
+    USB_DEVICE_INTFLAG_SOF, USB_DEVICE_INTFLAG_EORST, USB_DEVICE_INTFLAG_WAKEUP | USB_DEVICE_INTFLAG_EORSM | USB_DEVICE_INTFLAG_UPRSM, USB_DEVICE_INTFLAG_RAMACER, USB_DEVICE_INTFLAG_SUSPEND, USB_DEVICE_INTFLAG_LPMNYET, USB_DEVICE_INTFLAG_LPMSUSP,
 };
 
 /**
  * \internal USB Device IRQ Mask Bits Map
  */
-static const uint8_t _usb_endpoint_irq_bits[USB_DEVICE_EP_CALLBACK_N] = {
-    USB_DEVICE_EPINTFLAG_TRCPT_Msk,
-    USB_DEVICE_EPINTFLAG_TRFAIL_Msk,
-    USB_DEVICE_EPINTFLAG_RXSTP,
-    USB_DEVICE_EPINTFLAG_STALL_Msk
-};
+static const uint8_t _usb_endpoint_irq_bits[USB_DEVICE_EP_CALLBACK_N] = {USB_DEVICE_EPINTFLAG_TRCPT_Msk, USB_DEVICE_EPINTFLAG_TRFAIL_Msk, USB_DEVICE_EPINTFLAG_RXSTP, USB_DEVICE_EPINTFLAG_STALL_Msk};
 
 /**
  * \brief Registers a USB device callback
@@ -155,10 +144,7 @@ static const uint8_t _usb_endpoint_irq_bits[USB_DEVICE_EP_CALLBACK_N] = {
  * \return Status of the registration operation.
  * \retval STATUS_OK    The callback was registered successfully.
  */
-enum status_code usb_device_register_callback(struct usb_module *module_inst,
-        enum usb_device_callback callback_type,
-        usb_device_callback_t callback_func)
-{
+enum status_code usb_device_register_callback(struct usb_module *module_inst, enum usb_device_callback callback_type, usb_device_callback_t callback_func) {
     /* Sanity check arguments */
     Assert(module_inst);
     Assert(callback_func);
@@ -184,9 +170,7 @@ enum status_code usb_device_register_callback(struct usb_module *module_inst,
  * \return Status of the de-registration operation.
  * \retval STATUS_OK    The callback was unregistered successfully.
  */
-enum status_code usb_device_unregister_callback(struct usb_module *module_inst,
-        enum usb_device_callback callback_type)
-{
+enum status_code usb_device_unregister_callback(struct usb_module *module_inst, enum usb_device_callback callback_type) {
     /* Sanity check arguments */
     Assert(module_inst);
 
@@ -211,9 +195,7 @@ enum status_code usb_device_unregister_callback(struct usb_module *module_inst,
  * \return Status of the callback enable operation.
  * \retval STATUS_OK    The callback was enabled successfully.
  */
-enum status_code usb_device_enable_callback(struct usb_module *module_inst,
-        enum usb_device_callback callback_type)
-{
+enum status_code usb_device_enable_callback(struct usb_module *module_inst, enum usb_device_callback callback_type) {
     /* Sanity check arguments */
     Assert(module_inst);
     Assert(module_inst->hw);
@@ -240,9 +222,7 @@ enum status_code usb_device_enable_callback(struct usb_module *module_inst,
  * \return Status of the callback disable operation.
  * \retval STATUS_OK    The callback was disabled successfully.
  */
-enum status_code usb_device_disable_callback(struct usb_module *module_inst,
-        enum usb_device_callback callback_type)
-{
+enum status_code usb_device_disable_callback(struct usb_module *module_inst, enum usb_device_callback callback_type) {
     /* Sanity check arguments */
     Assert(module_inst);
     Assert(module_inst->hw);
@@ -272,11 +252,7 @@ enum status_code usb_device_disable_callback(struct usb_module *module_inst,
  * \return Status of the registration operation.
  * \retval STATUS_OK    The callback was registered successfully.
  */
-enum status_code usb_device_endpoint_register_callback(
-        struct usb_module *module_inst, uint8_t ep_num,
-        enum usb_device_endpoint_callback callback_type,
-        usb_device_endpoint_callback_t callback_func)
-{
+enum status_code usb_device_endpoint_register_callback(struct usb_module *module_inst, uint8_t ep_num, enum usb_device_endpoint_callback callback_type, usb_device_endpoint_callback_t callback_func) {
     /* Sanity check arguments */
     Assert(module_inst);
     Assert(ep_num < USB_EPT_NUM);
@@ -304,10 +280,7 @@ enum status_code usb_device_endpoint_register_callback(
  * \return Status of the de-registration operation.
  * \retval STATUS_OK    The callback was unregistered successfully.
  */
-enum status_code usb_device_endpoint_unregister_callback(
-        struct usb_module *module_inst, uint8_t ep_num,
-        enum usb_device_endpoint_callback callback_type)
-{
+enum status_code usb_device_endpoint_unregister_callback(struct usb_module *module_inst, uint8_t ep_num, enum usb_device_endpoint_callback callback_type) {
     /* Sanity check arguments */
     Assert(module_inst);
     Assert(ep_num < USB_EPT_NUM);
@@ -334,10 +307,7 @@ enum status_code usb_device_endpoint_unregister_callback(
  * \return Status of the callback enable operation.
  * \retval STATUS_OK    The callback was enabled successfully.
  */
-enum status_code usb_device_endpoint_enable_callback(
-        struct usb_module *module_inst, uint8_t ep,
-        enum usb_device_endpoint_callback callback_type)
-{
+enum status_code usb_device_endpoint_enable_callback(struct usb_module *module_inst, uint8_t ep, enum usb_device_endpoint_callback callback_type) {
     /* Sanity check arguments */
     Assert(module_inst);
     Assert(module_inst->hw);
@@ -349,7 +319,7 @@ enum status_code usb_device_endpoint_enable_callback(
     module_inst->device_endpoint_enabled_callback_mask[ep_num] |= _usb_endpoint_irq_bits[callback_type];
 
     if (callback_type == USB_DEVICE_ENDPOINT_CALLBACK_TRCPT) {
-        if (ep_num == 0) { // control endpoint
+        if (ep_num == 0) {  // control endpoint
             module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPINTENSET.reg = USB_DEVICE_EPINTENSET_TRCPT0 | USB_DEVICE_EPINTENSET_TRCPT1;
         } else if (ep & USB_EP_DIR_IN) {
             module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPINTENSET.reg = USB_DEVICE_EPINTENSET_TRCPT1;
@@ -359,7 +329,7 @@ enum status_code usb_device_endpoint_enable_callback(
     }
 
     if (callback_type == USB_DEVICE_ENDPOINT_CALLBACK_TRFAIL) {
-        if (ep_num == 0) { // control endpoint
+        if (ep_num == 0) {  // control endpoint
             module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPINTENSET.reg = USB_DEVICE_EPINTENSET_TRFAIL0 | USB_DEVICE_EPINTENSET_TRFAIL1;
         } else if (ep & USB_EP_DIR_IN) {
             module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPINTENSET.reg = USB_DEVICE_EPINTENSET_TRFAIL1;
@@ -395,10 +365,7 @@ enum status_code usb_device_endpoint_enable_callback(
  * \return Status of the callback disable operation.
  * \retval STATUS_OK    The callback was disabled successfully.
  */
-enum status_code usb_device_endpoint_disable_callback(
-        struct usb_module *module_inst, uint8_t ep,
-        enum usb_device_endpoint_callback callback_type)
-{
+enum status_code usb_device_endpoint_disable_callback(struct usb_module *module_inst, uint8_t ep, enum usb_device_endpoint_callback callback_type) {
     /* Sanity check arguments */
     Assert(module_inst);
     Assert(module_inst->hw);
@@ -410,17 +377,17 @@ enum status_code usb_device_endpoint_disable_callback(
     module_inst->device_endpoint_enabled_callback_mask[ep_num] &= ~_usb_endpoint_irq_bits[callback_type];
 
     if (callback_type == USB_DEVICE_ENDPOINT_CALLBACK_TRCPT) {
-        if (ep_num == 0) { // control endpoint
-            module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPINTENCLR.reg =  USB_DEVICE_EPINTENCLR_TRCPT0 | USB_DEVICE_EPINTENCLR_TRCPT1;
+        if (ep_num == 0) {  // control endpoint
+            module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPINTENCLR.reg = USB_DEVICE_EPINTENCLR_TRCPT0 | USB_DEVICE_EPINTENCLR_TRCPT1;
         } else if (ep & USB_EP_DIR_IN) {
-            module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPINTENCLR.reg =  USB_DEVICE_EPINTENCLR_TRCPT1;
+            module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPINTENCLR.reg = USB_DEVICE_EPINTENCLR_TRCPT1;
         } else {
-            module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPINTENCLR.reg =  USB_DEVICE_EPINTENCLR_TRCPT0;
+            module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPINTENCLR.reg = USB_DEVICE_EPINTENCLR_TRCPT0;
         }
     }
 
     if (callback_type == USB_DEVICE_ENDPOINT_CALLBACK_TRFAIL) {
-        if (ep_num == 0) { // control endpoint
+        if (ep_num == 0) {  // control endpoint
             module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPINTENCLR.reg = USB_DEVICE_EPINTENCLR_TRFAIL0 | USB_DEVICE_EPINTENCLR_TRFAIL1;
         } else if (ep & USB_EP_DIR_IN) {
             module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPINTENCLR.reg = USB_DEVICE_EPINTENCLR_TRFAIL1;
@@ -460,16 +427,15 @@ enum status_code usb_device_endpoint_disable_callback(
  *
  * \param[out] ep_config  Configuration structure to initialize to default values
  */
-void usb_device_endpoint_get_config_defaults(struct usb_device_endpoint_config *ep_config)
-{
+void usb_device_endpoint_get_config_defaults(struct usb_device_endpoint_config *ep_config) {
     /* Sanity check arguments */
     Assert(ep_config);
 
     /* Write default config to config struct */
     ep_config->ep_address = 0;
-    ep_config->ep_size = USB_ENDPOINT_8_BYTE;
-    ep_config->auto_zlp = false;
-    ep_config->ep_type = USB_DEVICE_ENDPOINT_TYPE_CONTROL;
+    ep_config->ep_size    = USB_ENDPOINT_8_BYTE;
+    ep_config->auto_zlp   = false;
+    ep_config->ep_type    = USB_DEVICE_ENDPOINT_TYPE_CONTROL;
 }
 
 /**
@@ -486,25 +452,22 @@ void usb_device_endpoint_get_config_defaults(struct usb_device_endpoint_config *
  * \retval STATUS_OK         The device endpoint was configured successfully
  * \retval STATUS_ERR_DENIED The endpoint address is already configured
  */
-enum status_code usb_device_endpoint_set_config(struct usb_module *module_inst,
-        struct usb_device_endpoint_config *ep_config)
-{
+enum status_code usb_device_endpoint_set_config(struct usb_module *module_inst, struct usb_device_endpoint_config *ep_config) {
     /* Sanity check arguments */
     Assert(module_inst);
     Assert(ep_config);
 
-    uint8_t ep_num = ep_config->ep_address & USB_EP_ADDR_MASK;
+    uint8_t ep_num  = ep_config->ep_address & USB_EP_ADDR_MASK;
     uint8_t ep_bank = (ep_config->ep_address & USB_EP_DIR_IN) ? 1 : 0;
 
     switch (ep_config->ep_type) {
         case USB_DEVICE_ENDPOINT_TYPE_DISABLE:
-            module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPCFG.reg = USB_DEVICE_EPCFG_EPTYPE0(0) |  USB_DEVICE_EPCFG_EPTYPE1(0);
+            module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPCFG.reg = USB_DEVICE_EPCFG_EPTYPE0(0) | USB_DEVICE_EPCFG_EPTYPE1(0);
             return STATUS_OK;
 
         case USB_DEVICE_ENDPOINT_TYPE_CONTROL:
-            if ((module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPCFG.reg & USB_DEVICE_EPCFG_EPTYPE0_Msk) == 0 && \
-                (module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPCFG.reg & USB_DEVICE_EPCFG_EPTYPE1_Msk) == 0) {
-                module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPCFG.reg = USB_DEVICE_EPCFG_EPTYPE0(1) | USB_DEVICE_EPCFG_EPTYPE1(1);
+            if ((module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPCFG.reg & USB_DEVICE_EPCFG_EPTYPE0_Msk) == 0 && (module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPCFG.reg & USB_DEVICE_EPCFG_EPTYPE1_Msk) == 0) {
+                module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPCFG.reg       = USB_DEVICE_EPCFG_EPTYPE0(1) | USB_DEVICE_EPCFG_EPTYPE1(1);
                 module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPSTATUSSET.reg = USB_DEVICE_EPSTATUSSET_BK0RDY;
                 module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPSTATUSCLR.reg = USB_DEVICE_EPSTATUSCLR_BK1RDY;
             } else {
@@ -523,14 +486,14 @@ enum status_code usb_device_endpoint_set_config(struct usb_module *module_inst,
 
         case USB_DEVICE_ENDPOINT_TYPE_ISOCHRONOUS:
             if (ep_bank) {
-                if ((module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPCFG.reg & USB_DEVICE_EPCFG_EPTYPE1_Msk) == 0){
+                if ((module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPCFG.reg & USB_DEVICE_EPCFG_EPTYPE1_Msk) == 0) {
                     module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPCFG.reg |= USB_DEVICE_EPCFG_EPTYPE1(2);
                     module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPSTATUSCLR.reg = USB_DEVICE_EPSTATUSCLR_BK1RDY;
                 } else {
                     return STATUS_ERR_DENIED;
                 }
             } else {
-                if ((module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPCFG.reg & USB_DEVICE_EPCFG_EPTYPE0_Msk) == 0){
+                if ((module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPCFG.reg & USB_DEVICE_EPCFG_EPTYPE0_Msk) == 0) {
                     module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPCFG.reg |= USB_DEVICE_EPCFG_EPTYPE0(2);
                     module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPSTATUSSET.reg = USB_DEVICE_EPSTATUSSET_BK0RDY;
                 } else {
@@ -541,14 +504,14 @@ enum status_code usb_device_endpoint_set_config(struct usb_module *module_inst,
 
         case USB_DEVICE_ENDPOINT_TYPE_BULK:
             if (ep_bank) {
-                if ((module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPCFG.reg & USB_DEVICE_EPCFG_EPTYPE1_Msk) == 0){
+                if ((module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPCFG.reg & USB_DEVICE_EPCFG_EPTYPE1_Msk) == 0) {
                     module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPCFG.reg |= USB_DEVICE_EPCFG_EPTYPE1(3);
                     module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPSTATUSCLR.reg = USB_DEVICE_EPSTATUSCLR_BK1RDY;
                 } else {
                     return STATUS_ERR_DENIED;
                 }
             } else {
-                if ((module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPCFG.reg & USB_DEVICE_EPCFG_EPTYPE0_Msk) == 0){
+                if ((module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPCFG.reg & USB_DEVICE_EPCFG_EPTYPE0_Msk) == 0) {
                     module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPCFG.reg |= USB_DEVICE_EPCFG_EPTYPE0(3);
                     module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPSTATUSSET.reg = USB_DEVICE_EPSTATUSSET_BK0RDY;
                 } else {
@@ -559,14 +522,14 @@ enum status_code usb_device_endpoint_set_config(struct usb_module *module_inst,
 
         case USB_DEVICE_ENDPOINT_TYPE_INTERRUPT:
             if (ep_bank) {
-                if ((module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPCFG.reg & USB_DEVICE_EPCFG_EPTYPE1_Msk) == 0){
+                if ((module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPCFG.reg & USB_DEVICE_EPCFG_EPTYPE1_Msk) == 0) {
                     module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPCFG.reg |= USB_DEVICE_EPCFG_EPTYPE1(4);
                     module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPSTATUSCLR.reg = USB_DEVICE_EPSTATUSCLR_BK1RDY;
                 } else {
                     return STATUS_ERR_DENIED;
                 }
             } else {
-                if ((module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPCFG.reg & USB_DEVICE_EPCFG_EPTYPE0_Msk) == 0){
+                if ((module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPCFG.reg & USB_DEVICE_EPCFG_EPTYPE0_Msk) == 0) {
                     module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPCFG.reg |= USB_DEVICE_EPCFG_EPTYPE0(4);
                     module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPSTATUSSET.reg = USB_DEVICE_EPSTATUSSET_BK0RDY;
                 } else {
@@ -583,7 +546,7 @@ enum status_code usb_device_endpoint_set_config(struct usb_module *module_inst,
 
     if (true == ep_config->auto_zlp) {
         usb_descriptor_table.usb_endpoint_table[ep_num].DeviceDescBank[ep_bank].PCKSIZE.reg |= USB_DEVICE_PCKSIZE_AUTO_ZLP;
-        } else {
+    } else {
         usb_descriptor_table.usb_endpoint_table[ep_num].DeviceDescBank[ep_bank].PCKSIZE.reg &= ~USB_DEVICE_PCKSIZE_AUTO_ZLP;
     }
 
@@ -598,8 +561,7 @@ enum status_code usb_device_endpoint_set_config(struct usb_module *module_inst,
  *
  * \return \c true if endpoint is configured and ready to use
  */
-bool usb_device_endpoint_is_configured(struct usb_module *module_inst, uint8_t ep)
-{
+bool usb_device_endpoint_is_configured(struct usb_module *module_inst, uint8_t ep) {
     uint8_t ep_num = ep & USB_EP_ADDR_MASK;
     uint8_t flag;
 
@@ -611,15 +573,13 @@ bool usb_device_endpoint_is_configured(struct usb_module *module_inst, uint8_t e
     return ((enum usb_device_endpoint_type)(flag) != USB_DEVICE_ENDPOINT_TYPE_DISABLE);
 }
 
-
 /**
  * \brief Abort ongoing job on the endpoint
  *
  * \param module_inst Pointer to USB software instance struct
  * \param ep          Endpoint address
  */
-void usb_device_endpoint_abort_job(struct usb_module *module_inst, uint8_t ep)
-{
+void usb_device_endpoint_abort_job(struct usb_module *module_inst, uint8_t ep) {
     uint8_t ep_num;
     ep_num = ep & USB_EP_ADDR_MASK;
 
@@ -643,8 +603,7 @@ void usb_device_endpoint_abort_job(struct usb_module *module_inst, uint8_t ep)
  *
  * \return \c true if the endpoint is halted
  */
-bool usb_device_endpoint_is_halted(struct usb_module *module_inst, uint8_t ep)
-{
+bool usb_device_endpoint_is_halted(struct usb_module *module_inst, uint8_t ep) {
     uint8_t ep_num = ep & USB_EP_ADDR_MASK;
 
     if (ep & USB_EP_DIR_IN) {
@@ -660,8 +619,7 @@ bool usb_device_endpoint_is_halted(struct usb_module *module_inst, uint8_t ep)
  * \param module_inst Pointer to USB software instance struct
  * \param ep          Endpoint address
  */
-void usb_device_endpoint_set_halt(struct usb_module *module_inst, uint8_t ep)
-{
+void usb_device_endpoint_set_halt(struct usb_module *module_inst, uint8_t ep) {
     uint8_t ep_num = ep & USB_EP_ADDR_MASK;
 
     // Stall endpoint
@@ -678,8 +636,7 @@ void usb_device_endpoint_set_halt(struct usb_module *module_inst, uint8_t ep)
  * \param module_inst Pointer to USB software instance struct
  * \param ep          Endpoint address
  */
-void usb_device_endpoint_clear_halt(struct usb_module *module_inst, uint8_t ep)
-{
+void usb_device_endpoint_clear_halt(struct usb_module *module_inst, uint8_t ep) {
     uint8_t ep_num = ep & USB_EP_ADDR_MASK;
 
     if (ep & USB_EP_DIR_IN) {
@@ -717,9 +674,7 @@ void usb_device_endpoint_clear_halt(struct usb_module *module_inst, uint8_t ep)
  * \retval STATUS_OK Job started successfully
  * \retval STATUS_ERR_DENIED Endpoint is not ready
  */
-enum status_code usb_device_endpoint_write_buffer_job(struct usb_module *module_inst,uint8_t ep_num,
-        uint8_t* pbuf, uint32_t buf_size)
-{
+enum status_code usb_device_endpoint_write_buffer_job(struct usb_module *module_inst, uint8_t ep_num, uint8_t *pbuf, uint32_t buf_size) {
     /* Sanity check arguments */
     Assert(module_inst);
     Assert(module_inst->hw);
@@ -732,10 +687,10 @@ enum status_code usb_device_endpoint_write_buffer_job(struct usb_module *module_
     };
 
     /* get endpoint configuration from setting register */
-    usb_descriptor_table.usb_endpoint_table[ep_num].DeviceDescBank[1].ADDR.reg = (uint32_t)pbuf;
+    usb_descriptor_table.usb_endpoint_table[ep_num].DeviceDescBank[1].ADDR.reg                      = (uint32_t)pbuf;
     usb_descriptor_table.usb_endpoint_table[ep_num].DeviceDescBank[1].PCKSIZE.bit.MULTI_PACKET_SIZE = 0;
-    usb_descriptor_table.usb_endpoint_table[ep_num].DeviceDescBank[1].PCKSIZE.bit.BYTE_COUNT = buf_size;
-    module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPSTATUSSET.reg = USB_DEVICE_EPSTATUSSET_BK1RDY;
+    usb_descriptor_table.usb_endpoint_table[ep_num].DeviceDescBank[1].PCKSIZE.bit.BYTE_COUNT        = buf_size;
+    module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPSTATUSSET.reg                                  = USB_DEVICE_EPSTATUSSET_BK1RDY;
 
     return STATUS_OK;
 }
@@ -752,9 +707,7 @@ enum status_code usb_device_endpoint_write_buffer_job(struct usb_module *module_
  * \retval STATUS_OK Job started successfully
  * \retval STATUS_ERR_DENIED Endpoint is not ready
  */
-enum status_code usb_device_endpoint_read_buffer_job(struct usb_module *module_inst,uint8_t ep_num,
-        uint8_t* pbuf, uint32_t buf_size)
-{
+enum status_code usb_device_endpoint_read_buffer_job(struct usb_module *module_inst, uint8_t ep_num, uint8_t *pbuf, uint32_t buf_size) {
     /* Sanity check arguments */
     Assert(module_inst);
     Assert(module_inst->hw);
@@ -767,10 +720,10 @@ enum status_code usb_device_endpoint_read_buffer_job(struct usb_module *module_i
     };
 
     /* get endpoint configuration from setting register */
-    usb_descriptor_table.usb_endpoint_table[ep_num].DeviceDescBank[0].ADDR.reg = (uint32_t)pbuf;
+    usb_descriptor_table.usb_endpoint_table[ep_num].DeviceDescBank[0].ADDR.reg                      = (uint32_t)pbuf;
     usb_descriptor_table.usb_endpoint_table[ep_num].DeviceDescBank[0].PCKSIZE.bit.MULTI_PACKET_SIZE = buf_size;
-    usb_descriptor_table.usb_endpoint_table[ep_num].DeviceDescBank[0].PCKSIZE.bit.BYTE_COUNT = 0;
-    module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPSTATUSCLR.reg = USB_DEVICE_EPSTATUSCLR_BK0RDY;
+    usb_descriptor_table.usb_endpoint_table[ep_num].DeviceDescBank[0].PCKSIZE.bit.BYTE_COUNT        = 0;
+    module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPSTATUSCLR.reg                                  = USB_DEVICE_EPSTATUSCLR_BK0RDY;
 
     return STATUS_OK;
 }
@@ -785,24 +738,21 @@ enum status_code usb_device_endpoint_read_buffer_job(struct usb_module *module_i
  * \retval STATUS_OK Job started successfully
  * \retval STATUS_ERR_DENIED Endpoint is not ready
  */
-enum status_code usb_device_endpoint_setup_buffer_job(struct usb_module *module_inst,
-        uint8_t* pbuf)
-{
+enum status_code usb_device_endpoint_setup_buffer_job(struct usb_module *module_inst, uint8_t *pbuf) {
     /* Sanity check arguments */
     Assert(module_inst);
     Assert(module_inst->hw);
 
     /* get endpoint configuration from setting register */
-    usb_descriptor_table.usb_endpoint_table[0].DeviceDescBank[0].ADDR.reg = (uint32_t)pbuf;
+    usb_descriptor_table.usb_endpoint_table[0].DeviceDescBank[0].ADDR.reg                      = (uint32_t)pbuf;
     usb_descriptor_table.usb_endpoint_table[0].DeviceDescBank[0].PCKSIZE.bit.MULTI_PACKET_SIZE = 8;
-    usb_descriptor_table.usb_endpoint_table[0].DeviceDescBank[0].PCKSIZE.bit.BYTE_COUNT = 0;
-    module_inst->hw->DEVICE.DeviceEndpoint[0].EPSTATUSCLR.reg = USB_DEVICE_EPSTATUSCLR_BK0RDY;
+    usb_descriptor_table.usb_endpoint_table[0].DeviceDescBank[0].PCKSIZE.bit.BYTE_COUNT        = 0;
+    module_inst->hw->DEVICE.DeviceEndpoint[0].EPSTATUSCLR.reg                                  = USB_DEVICE_EPSTATUSCLR_BK0RDY;
 
     return STATUS_OK;
 }
 
-static void _usb_device_interrupt_handler(void)
-{
+static void _usb_device_interrupt_handler(void) {
     uint16_t ep_inst;
     uint16_t flags, flags_run;
     ep_inst = _usb_instances->hw->DEVICE.EPINTSMRY.reg;
@@ -812,21 +762,16 @@ static void _usb_device_interrupt_handler(void)
         int i;
 
         /* get interrupt flags */
-        flags = _usb_instances->hw->DEVICE.INTFLAG.reg;
-        flags_run = flags &
-                _usb_instances->device_enabled_callback_mask &
-                _usb_instances->device_registered_callback_mask;
+        flags     = _usb_instances->hw->DEVICE.INTFLAG.reg;
+        flags_run = flags & _usb_instances->device_enabled_callback_mask & _usb_instances->device_registered_callback_mask;
 
-        for (i = 0; i < USB_DEVICE_CALLBACK_N; i ++) {
+        for (i = 0; i < USB_DEVICE_CALLBACK_N; i++) {
             if (flags & _usb_device_irq_bits[i]) {
-                _usb_instances->hw->DEVICE.INTFLAG.reg =
-                        _usb_device_irq_bits[i];
+                _usb_instances->hw->DEVICE.INTFLAG.reg = _usb_device_irq_bits[i];
             }
             if (flags_run & _usb_device_irq_bits[i]) {
                 if (i == USB_DEVICE_CALLBACK_LPMSUSP) {
-                    device_callback_lpm_wakeup_enable =
-                            usb_descriptor_table.usb_endpoint_table[0].DeviceDescBank[0].EXTREG.bit.VARIABLE
-                            & USB_LPM_ATTRIBUT_REMOTEWAKE_MASK;
+                    device_callback_lpm_wakeup_enable = usb_descriptor_table.usb_endpoint_table[0].DeviceDescBank[0].EXTREG.bit.VARIABLE & USB_LPM_ATTRIBUT_REMOTEWAKE_MASK;
                 }
                 (_usb_instances->device_callback[i])(_usb_instances, &device_callback_lpm_wakeup_enable);
             }
@@ -836,25 +781,22 @@ static void _usb_device_interrupt_handler(void)
         /* endpoint interrupt */
 
         for (uint8_t i = 0; i < USB_EPT_NUM; i++) {
-
             if (ep_inst & (1 << i)) {
-                flags = _usb_instances->hw->DEVICE.DeviceEndpoint[i].EPINTFLAG.reg;
-                flags_run = flags &
-                        _usb_instances->device_endpoint_enabled_callback_mask[i] &
-                        _usb_instances->device_endpoint_registered_callback_mask[i];
+                flags     = _usb_instances->hw->DEVICE.DeviceEndpoint[i].EPINTFLAG.reg;
+                flags_run = flags & _usb_instances->device_endpoint_enabled_callback_mask[i] & _usb_instances->device_endpoint_registered_callback_mask[i];
 
                 // endpoint transfer stall interrupt
                 if (flags & USB_DEVICE_EPINTFLAG_STALL_Msk) {
                     if (_usb_instances->hw->DEVICE.DeviceEndpoint[i].EPINTFLAG.reg & USB_DEVICE_EPINTFLAG_STALL1) {
                         _usb_instances->hw->DEVICE.DeviceEndpoint[i].EPINTFLAG.reg = USB_DEVICE_EPINTFLAG_STALL1;
-                        ep_callback_para.endpoint_address = USB_EP_DIR_IN | i;
+                        ep_callback_para.endpoint_address                          = USB_EP_DIR_IN | i;
                     } else if (_usb_instances->hw->DEVICE.DeviceEndpoint[i].EPINTFLAG.reg & USB_DEVICE_EPINTFLAG_STALL0) {
                         _usb_instances->hw->DEVICE.DeviceEndpoint[i].EPINTFLAG.reg = USB_DEVICE_EPINTFLAG_STALL0;
-                        ep_callback_para.endpoint_address = USB_EP_DIR_OUT | i;
+                        ep_callback_para.endpoint_address                          = USB_EP_DIR_OUT | i;
                     }
 
                     if (flags_run & USB_DEVICE_EPINTFLAG_STALL_Msk) {
-                        (_usb_instances->device_endpoint_callback[i][USB_DEVICE_ENDPOINT_CALLBACK_STALL])(_usb_instances,&ep_callback_para);
+                        (_usb_instances->device_endpoint_callback[i][USB_DEVICE_ENDPOINT_CALLBACK_STALL])(_usb_instances, &ep_callback_para);
                     }
                     return;
                 }
@@ -862,9 +804,9 @@ static void _usb_device_interrupt_handler(void)
                 // endpoint received setup interrupt
                 if (flags & USB_DEVICE_EPINTFLAG_RXSTP) {
                     _usb_instances->hw->DEVICE.DeviceEndpoint[i].EPINTFLAG.reg = USB_DEVICE_EPINTFLAG_RXSTP;
-                    if(_usb_instances->device_endpoint_enabled_callback_mask[i] & _usb_endpoint_irq_bits[USB_DEVICE_ENDPOINT_CALLBACK_RXSTP]) {
+                    if (_usb_instances->device_endpoint_enabled_callback_mask[i] & _usb_endpoint_irq_bits[USB_DEVICE_ENDPOINT_CALLBACK_RXSTP]) {
                         ep_callback_para.received_bytes = (uint16_t)(usb_descriptor_table.usb_endpoint_table[i].DeviceDescBank[0].PCKSIZE.bit.BYTE_COUNT);
-                        (_usb_instances->device_endpoint_callback[i][USB_DEVICE_ENDPOINT_CALLBACK_RXSTP])(_usb_instances,&ep_callback_para);
+                        (_usb_instances->device_endpoint_callback[i][USB_DEVICE_ENDPOINT_CALLBACK_RXSTP])(_usb_instances, &ep_callback_para);
                     }
                     return;
                 }
@@ -873,17 +815,17 @@ static void _usb_device_interrupt_handler(void)
                 if (flags & USB_DEVICE_EPINTFLAG_TRCPT_Msk) {
                     if (_usb_instances->hw->DEVICE.DeviceEndpoint[i].EPINTFLAG.reg & USB_DEVICE_EPINTFLAG_TRCPT1) {
                         _usb_instances->hw->DEVICE.DeviceEndpoint[i].EPINTFLAG.reg = USB_DEVICE_EPINTFLAG_TRCPT1;
-                        ep_callback_para.endpoint_address = USB_EP_DIR_IN | i;
-                        ep_callback_para.sent_bytes = (uint16_t)(usb_descriptor_table.usb_endpoint_table[i].DeviceDescBank[1].PCKSIZE.bit.BYTE_COUNT);
+                        ep_callback_para.endpoint_address                          = USB_EP_DIR_IN | i;
+                        ep_callback_para.sent_bytes                                = (uint16_t)(usb_descriptor_table.usb_endpoint_table[i].DeviceDescBank[1].PCKSIZE.bit.BYTE_COUNT);
 
                     } else if (_usb_instances->hw->DEVICE.DeviceEndpoint[i].EPINTFLAG.reg & USB_DEVICE_EPINTFLAG_TRCPT0) {
                         _usb_instances->hw->DEVICE.DeviceEndpoint[i].EPINTFLAG.reg = USB_DEVICE_EPINTFLAG_TRCPT0;
-                        ep_callback_para.endpoint_address = USB_EP_DIR_OUT | i;
-                        ep_callback_para.received_bytes = (uint16_t)(usb_descriptor_table.usb_endpoint_table[i].DeviceDescBank[0].PCKSIZE.bit.BYTE_COUNT);
-                        ep_callback_para.out_buffer_size = (uint16_t)(usb_descriptor_table.usb_endpoint_table[i].DeviceDescBank[0].PCKSIZE.bit.MULTI_PACKET_SIZE);
+                        ep_callback_para.endpoint_address                          = USB_EP_DIR_OUT | i;
+                        ep_callback_para.received_bytes                            = (uint16_t)(usb_descriptor_table.usb_endpoint_table[i].DeviceDescBank[0].PCKSIZE.bit.BYTE_COUNT);
+                        ep_callback_para.out_buffer_size                           = (uint16_t)(usb_descriptor_table.usb_endpoint_table[i].DeviceDescBank[0].PCKSIZE.bit.MULTI_PACKET_SIZE);
                     }
-                    if(flags_run & USB_DEVICE_EPINTFLAG_TRCPT_Msk) {
-                        (_usb_instances->device_endpoint_callback[i][USB_DEVICE_ENDPOINT_CALLBACK_TRCPT])(_usb_instances,&ep_callback_para);
+                    if (flags_run & USB_DEVICE_EPINTFLAG_TRCPT_Msk) {
+                        (_usb_instances->device_endpoint_callback[i][USB_DEVICE_ENDPOINT_CALLBACK_TRCPT])(_usb_instances, &ep_callback_para);
                     }
                     return;
                 }
@@ -899,7 +841,7 @@ static void _usb_device_interrupt_handler(void)
                         if (_usb_instances->hw->DEVICE.DeviceEndpoint[i].EPINTFLAG.reg & USB_DEVICE_EPINTFLAG_TRCPT1) {
                             return;
                         }
-                    } else if(_usb_instances->hw->DEVICE.DeviceEndpoint[i].EPINTFLAG.reg & USB_DEVICE_EPINTFLAG_TRFAIL0) {
+                    } else if (_usb_instances->hw->DEVICE.DeviceEndpoint[i].EPINTFLAG.reg & USB_DEVICE_EPINTFLAG_TRFAIL0) {
                         _usb_instances->hw->DEVICE.DeviceEndpoint[i].EPINTFLAG.reg = USB_DEVICE_EPINTFLAG_TRFAIL0;
                         if (usb_descriptor_table.usb_endpoint_table[i].DeviceDescBank[0].STATUS_BK.reg & USB_DEVICE_STATUS_BK_ERRORFLOW) {
                             usb_descriptor_table.usb_endpoint_table[i].DeviceDescBank[0].STATUS_BK.reg &= ~USB_DEVICE_STATUS_BK_ERRORFLOW;
@@ -910,8 +852,8 @@ static void _usb_device_interrupt_handler(void)
                         }
                     }
 
-                    if(flags_run & USB_DEVICE_EPINTFLAG_TRFAIL_Msk) {
-                        (_usb_instances->device_endpoint_callback[i][USB_DEVICE_ENDPOINT_CALLBACK_TRFAIL])(_usb_instances,&ep_callback_para);
+                    if (flags_run & USB_DEVICE_EPINTFLAG_TRFAIL_Msk) {
+                        (_usb_instances->device_endpoint_callback[i][USB_DEVICE_ENDPOINT_CALLBACK_TRFAIL])(_usb_instances, &ep_callback_para);
                     }
                     return;
                 }
@@ -925,13 +867,13 @@ static void _usb_device_interrupt_handler(void)
  *
  * \param module_inst pointer to USB module instance
  */
-void usb_enable(struct usb_module *module_inst)
-{
+void usb_enable(struct usb_module *module_inst) {
     Assert(module_inst);
     Assert(module_inst->hw);
 
     module_inst->hw->DEVICE.CTRLA.reg |= USB_CTRLA_ENABLE;
-    while (module_inst->hw->DEVICE.SYNCBUSY.reg == USB_SYNCBUSY_ENABLE);
+    while (module_inst->hw->DEVICE.SYNCBUSY.reg == USB_SYNCBUSY_ENABLE)
+        ;
 }
 
 /**
@@ -939,68 +881,56 @@ void usb_enable(struct usb_module *module_inst)
  *
  * \param module_inst pointer to USB module instance
  */
-void usb_disable(struct usb_module *module_inst)
-{
+void usb_disable(struct usb_module *module_inst) {
     Assert(module_inst);
     Assert(module_inst->hw);
 
     module_inst->hw->DEVICE.INTENCLR.reg = USB_DEVICE_INTENCLR_MASK;
-    module_inst->hw->DEVICE.INTFLAG.reg = USB_DEVICE_INTFLAG_MASK;
+    module_inst->hw->DEVICE.INTFLAG.reg  = USB_DEVICE_INTFLAG_MASK;
     module_inst->hw->DEVICE.CTRLA.reg &= ~USB_CTRLA_ENABLE;
-    while (module_inst->hw->DEVICE.SYNCBUSY.reg == USB_SYNCBUSY_ENABLE);
+    while (module_inst->hw->DEVICE.SYNCBUSY.reg == USB_SYNCBUSY_ENABLE)
+        ;
 }
 
 /**
  * \brief Interrupt handler for the USB module.
  */
-void USB_0_Handler(void)
-{
+void USB_0_Handler(void) {
     if (_usb_instances->hw->DEVICE.CTRLA.bit.MODE) {
-
     } else {
         /*device mode ISR */
         _usb_device_interrupt_handler();
     }
 }
 
-void USB_1_Handler(void)
-{
-    _usb_device_interrupt_handler();
-}
+void USB_1_Handler(void) { _usb_device_interrupt_handler(); }
 
-void USB_2_Handler(void)
-{
-    _usb_device_interrupt_handler();
-}
+void USB_2_Handler(void) { _usb_device_interrupt_handler(); }
 
-void USB_3_Handler(void)
-{
-    _usb_device_interrupt_handler();
-}
+void USB_3_Handler(void) { _usb_device_interrupt_handler(); }
 
 /**
  * \brief Get the default USB module settings
  *
  * \param[out] module_config  Configuration structure to initialize to default values
  */
-void usb_get_config_defaults(struct usb_config *module_config)
-{
+void usb_get_config_defaults(struct usb_config *module_config) {
     Assert(module_config);
 
     /* Sanity check arguments */
     Assert(module_config);
     /* Write default configuration to config struct */
     module_config->select_host_mode = 0;
-    module_config->run_in_standby = 1;
+    module_config->run_in_standby   = 1;
     module_config->source_generator = 0;
-    module_config->speed_mode = USB_SPEED_FULL;
+    module_config->speed_mode       = USB_SPEED_FULL;
 }
 
-#define NVM_USB_PAD_TRANSN_POS  45
+#define NVM_USB_PAD_TRANSN_POS 45
 #define NVM_USB_PAD_TRANSN_SIZE 5
-#define NVM_USB_PAD_TRANSP_POS  50
+#define NVM_USB_PAD_TRANSP_POS 50
 #define NVM_USB_PAD_TRANSP_SIZE 5
-#define NVM_USB_PAD_TRIM_POS  55
+#define NVM_USB_PAD_TRIM_POS 55
 #define NVM_USB_PAD_TRIM_SIZE 3
 
 /**
@@ -1020,56 +950,61 @@ void usb_get_config_defaults(struct usb_config *module_config)
 
 #define GCLK_USB 10
 
-enum status_code usb_init(struct usb_module *module_inst, Usb *const hw,
-        struct usb_config *module_config)
-{
+enum status_code usb_init(struct usb_module *module_inst, Usb *const hw, struct usb_config *module_config) {
     /* Sanity check arguments */
     Assert(hw);
     Assert(module_inst);
     Assert(module_config);
 
-    uint32_t i,j;
+    uint32_t i, j;
     uint32_t pad_transn, pad_transp, pad_trim;
 
-    Gclk *pgclk = GCLK;
-    Mclk *pmclk = MCLK;
-    Port *pport = PORT;
-    Oscctrl *posc = OSCCTRL;
+    Gclk *   pgclk = GCLK;
+    Mclk *   pmclk = MCLK;
+    Port *   pport = PORT;
+    Oscctrl *posc  = OSCCTRL;
 
     _usb_instances = module_inst;
 
     /* Associate the software module instance with the hardware module */
     module_inst->hw = hw;
 
-    //setup peripheral and synchronous bus clocks to USB
-    pmclk->AHBMASK.bit.USB_ = 1;
+    // setup peripheral and synchronous bus clocks to USB
+    pmclk->AHBMASK.bit.USB_  = 1;
     pmclk->APBBMASK.bit.USB_ = 1;
 
     /* Set up the USB DP/DN pins */
-    pport->Group[0].PMUX[12].reg = 0x77; //PA24, PA25, function column H for USB D-, D+
+    pport->Group[0].PMUX[12].reg          = 0x77;  // PA24, PA25, function column H for USB D-, D+
     pport->Group[0].PINCFG[24].bit.PMUXEN = 1;
     pport->Group[0].PINCFG[25].bit.PMUXEN = 1;
-    pport->Group[1].PMUX[11].bit.PMUXE = 7; //PB22, function column H for USB SOF_1KHz output
+    pport->Group[1].PMUX[11].bit.PMUXE    = 7;  // PB22, function column H for USB SOF_1KHz output
     pport->Group[1].PINCFG[22].bit.PMUXEN = 1;
 
-    //configure and enable DFLL for USB clock recovery mode at 48MHz
+    // configure and enable DFLL for USB clock recovery mode at 48MHz
     posc->DFLLCTRLA.bit.ENABLE = 0;
-    while (posc->DFLLSYNC.bit.ENABLE);
-    while (posc->DFLLSYNC.bit.DFLLCTRLB);
+    while (posc->DFLLSYNC.bit.ENABLE)
+        ;
+    while (posc->DFLLSYNC.bit.DFLLCTRLB)
+        ;
     posc->DFLLCTRLB.bit.USBCRM = 1;
-    while (posc->DFLLSYNC.bit.DFLLCTRLB);
+    while (posc->DFLLSYNC.bit.DFLLCTRLB)
+        ;
     posc->DFLLCTRLB.bit.MODE = 1;
-    while (posc->DFLLSYNC.bit.DFLLCTRLB);
+    while (posc->DFLLSYNC.bit.DFLLCTRLB)
+        ;
     posc->DFLLCTRLB.bit.QLDIS = 0;
-    while (posc->DFLLSYNC.bit.DFLLCTRLB);
+    while (posc->DFLLSYNC.bit.DFLLCTRLB)
+        ;
     posc->DFLLCTRLB.bit.CCDIS = 1;
-    posc->DFLLMUL.bit.MUL = 0xbb80;   //4800 x 1KHz
-    while (posc->DFLLSYNC.bit.DFLLMUL);
+    posc->DFLLMUL.bit.MUL     = 0xbb80;  // 4800 x 1KHz
+    while (posc->DFLLSYNC.bit.DFLLMUL)
+        ;
     posc->DFLLCTRLA.bit.ENABLE = 1;
-    while (posc->DFLLSYNC.bit.ENABLE);
+    while (posc->DFLLSYNC.bit.ENABLE)
+        ;
 
     /* Setup clock for module */
-    pgclk->PCHCTRL[GCLK_USB].bit.GEN = 0;
+    pgclk->PCHCTRL[GCLK_USB].bit.GEN  = 0;
     pgclk->PCHCTRL[GCLK_USB].bit.CHEN = 1;
 
     /* Reset */
@@ -1084,21 +1019,21 @@ enum status_code usb_init(struct usb_module *module_inst, Usb *const hw,
 
     /* Load Pad Calibration */
 
-    pad_transn = (USB_FUSES_TRANSN_ADDR >>  USB_FUSES_TRANSN_Pos) & USB_FUSES_TRANSN_Msk;
+    pad_transn = (USB_FUSES_TRANSN_ADDR >> USB_FUSES_TRANSN_Pos) & USB_FUSES_TRANSN_Msk;
     if (pad_transn == 0x1F) {
         pad_transn = 5;
     }
 
     hw->DEVICE.PADCAL.bit.TRANSN = pad_transn;
 
-    pad_transp = (USB_FUSES_TRANSP_ADDR >>  USB_FUSES_TRANSP_Pos) & USB_FUSES_TRANSP_Msk;
+    pad_transp = (USB_FUSES_TRANSP_ADDR >> USB_FUSES_TRANSP_Pos) & USB_FUSES_TRANSP_Msk;
     if (pad_transp == 0x1F) {
         pad_transp = 29;
     }
 
     hw->DEVICE.PADCAL.bit.TRANSP = pad_transp;
 
-    pad_trim = (USB_FUSES_TRIM_ADDR >>  USB_FUSES_TRIM_Pos) & USB_FUSES_TRIM_Msk;
+    pad_trim = (USB_FUSES_TRIM_ADDR >> USB_FUSES_TRIM_Pos) & USB_FUSES_TRIM_Msk;
     if (pad_trim == 0x07) {
         pad_trim = 3;
     }
@@ -1106,32 +1041,31 @@ enum status_code usb_init(struct usb_module *module_inst, Usb *const hw,
     hw->DEVICE.PADCAL.bit.TRIM = pad_trim;
 
     /* Set the configuration */
-    hw->DEVICE.CTRLA.bit.MODE = module_config->select_host_mode;
+    hw->DEVICE.CTRLA.bit.MODE     = module_config->select_host_mode;
     hw->DEVICE.CTRLA.bit.RUNSTDBY = module_config->run_in_standby;
-    hw->DEVICE.DESCADD.reg = (uint32_t)(&usb_descriptor_table.usb_endpoint_table[0]);
+    hw->DEVICE.DESCADD.reg        = (uint32_t)(&usb_descriptor_table.usb_endpoint_table[0]);
     if (USB_SPEED_FULL == module_config->speed_mode) {
         module_inst->hw->DEVICE.CTRLB.bit.SPDCONF = USB_DEVICE_CTRLB_SPDCONF_FS_Val;
-    } else if(USB_SPEED_LOW == module_config->speed_mode) {
+    } else if (USB_SPEED_LOW == module_config->speed_mode) {
         module_inst->hw->DEVICE.CTRLB.bit.SPDCONF = USB_DEVICE_CTRLB_SPDCONF_LS_Val;
     }
 
-    memset((uint8_t *)(&usb_descriptor_table.usb_endpoint_table[0]), 0,
-            sizeof(usb_descriptor_table.usb_endpoint_table));
+    memset((uint8_t *)(&usb_descriptor_table.usb_endpoint_table[0]), 0, sizeof(usb_descriptor_table.usb_endpoint_table));
 
     /*  device callback related */
     for (i = 0; i < USB_DEVICE_CALLBACK_N; i++) {
         module_inst->device_callback[i] = NULL;
     }
     for (i = 0; i < USB_EPT_NUM; i++) {
-        for(j = 0; j < USB_DEVICE_EP_CALLBACK_N; j++) {
+        for (j = 0; j < USB_DEVICE_EP_CALLBACK_N; j++) {
             module_inst->device_endpoint_callback[i][j] = NULL;
         }
     }
     module_inst->device_registered_callback_mask = 0;
-    module_inst->device_enabled_callback_mask = 0;
+    module_inst->device_enabled_callback_mask    = 0;
     for (j = 0; j < USB_EPT_NUM; j++) {
         module_inst->device_endpoint_registered_callback_mask[j] = 0;
-        module_inst->device_endpoint_enabled_callback_mask[j] = 0;
+        module_inst->device_endpoint_enabled_callback_mask[j]    = 0;
     }
 
     /* Enable interrupts for this USB module */
@@ -1141,4 +1075,3 @@ enum status_code usb_init(struct usb_module *module_inst, Usb *const hw,
 
     return STATUS_OK;
 }
-
diff --git a/tmk_core/protocol/arm_atsam/usb/usb.h b/tmk_core/protocol/arm_atsam/usb/usb.h
index 9a452881a..4c937ecdc 100644
--- a/tmk_core/protocol/arm_atsam/usb/usb.h
+++ b/tmk_core/protocol/arm_atsam/usb/usb.h
@@ -233,8 +233,8 @@ typedef void (*usb_host_pipe_callback_t)(struct usb_module *module_inst, void *)
  * \name Device Callback Functions Types
  * @{
  */
-typedef void (*usb_device_callback_t)(struct usb_module *module_inst, void* pointer);
-typedef void (*usb_device_endpoint_callback_t)(struct usb_module *module_inst, void* pointer);
+typedef void (*usb_device_callback_t)(struct usb_module *module_inst, void *pointer);
+typedef void (*usb_device_endpoint_callback_t)(struct usb_module *module_inst, void *pointer);
 /** @} */
 
 /** USB configurations */
@@ -247,7 +247,7 @@ struct usb_config {
     // enum gclk_generator source_generator;
     uint8_t source_generator;
     /** Speed mode */
-    //enum usb_speed speed_mode;
+    // enum usb_speed speed_mode;
     uint8_t speed_mode;
 };
 
@@ -263,7 +263,7 @@ struct usb_module {
     Usb *hw;
 
     /** Array to store device related callback functions */
-    usb_device_callback_t device_callback[USB_DEVICE_CALLBACK_N];
+    usb_device_callback_t          device_callback[USB_DEVICE_CALLBACK_N];
     usb_device_endpoint_callback_t device_endpoint_callback[USB_EPT_NUM][USB_DEVICE_EP_CALLBACK_N];
     /** Bit mask for device callbacks registered */
     uint16_t device_registered_callback_mask;
@@ -292,7 +292,7 @@ struct usb_endpoint_callback_parameter {
     uint16_t received_bytes;
     uint16_t sent_bytes;
     uint16_t out_buffer_size;
-    uint8_t endpoint_address;
+    uint8_t  endpoint_address;
 };
 
 void usb_enable(struct usb_module *module_inst);
@@ -303,8 +303,7 @@ void usb_disable(struct usb_module *module_inst);
  *
  * \param module_inst Pointer to USB module instance
  */
-static inline uint8_t usb_get_state_machine_status(struct usb_module *module_inst)
-{
+static inline uint8_t usb_get_state_machine_status(struct usb_module *module_inst) {
     /* Sanity check arguments */
     Assert(module_inst);
     Assert(module_inst->hw);
@@ -312,29 +311,22 @@ static inline uint8_t usb_get_state_machine_status(struct usb_module *module_ins
     return module_inst->hw->DEVICE.FSMSTATUS.reg;
 }
 
-void usb_get_config_defaults(struct usb_config *module_config);
-enum status_code usb_init(struct usb_module *module_inst, Usb *const hw,
-        struct usb_config *module_config);
+void             usb_get_config_defaults(struct usb_config *module_config);
+enum status_code usb_init(struct usb_module *module_inst, Usb *const hw, struct usb_config *module_config);
 
 /**
  * \brief Attach USB device to the bus
  *
  * \param module_inst Pointer to USB device module instance
  */
-static inline void usb_device_attach(struct usb_module *module_inst)
-{
-    module_inst->hw->DEVICE.CTRLB.reg &= ~USB_DEVICE_CTRLB_DETACH;
-}
+static inline void usb_device_attach(struct usb_module *module_inst) { module_inst->hw->DEVICE.CTRLB.reg &= ~USB_DEVICE_CTRLB_DETACH; }
 
 /**
  * \brief Detach USB device from the bus
  *
  * \param module_inst Pointer to USB device module instance
  */
-static inline void usb_device_detach(struct usb_module *module_inst)
-{
-    module_inst->hw->DEVICE.CTRLB.reg |= USB_DEVICE_CTRLB_DETACH;
-}
+static inline void usb_device_detach(struct usb_module *module_inst) { module_inst->hw->DEVICE.CTRLB.reg |= USB_DEVICE_CTRLB_DETACH; }
 
 /**
  * \brief Get the speed mode of USB device
@@ -342,8 +334,7 @@ static inline void usb_device_detach(struct usb_module *module_inst)
  * \param module_inst Pointer to USB device module instance
  * \return USB Speed mode (\ref usb_speed).
  */
-static inline enum usb_speed usb_device_get_speed(struct usb_module *module_inst)
-{
+static inline enum usb_speed usb_device_get_speed(struct usb_module *module_inst) {
     if (!(module_inst->hw->DEVICE.STATUS.reg & USB_DEVICE_STATUS_SPEED_Msk)) {
         return USB_SPEED_FULL;
     } else {
@@ -357,10 +348,7 @@ static inline enum usb_speed usb_device_get_speed(struct usb_module *module_inst
  * \param module_inst Pointer to USB device module instance
  * \return USB device address value.
  */
-static inline uint8_t usb_device_get_address(struct usb_module *module_inst)
-{
-    return ((uint8_t)(module_inst->hw->DEVICE.DADD.bit.DADD));
-}
+static inline uint8_t usb_device_get_address(struct usb_module *module_inst) { return ((uint8_t)(module_inst->hw->DEVICE.DADD.bit.DADD)); }
 
 /**
  * \brief Set the speed mode of USB device
@@ -368,10 +356,7 @@ static inline uint8_t usb_device_get_address(struct usb_module *module_inst)
  * \param module_inst Pointer to USB device module instance
  * \param address     USB device address value
  */
-static inline void usb_device_set_address(struct usb_module *module_inst, uint8_t address)
-{
-    module_inst->hw->DEVICE.DADD.reg = USB_DEVICE_DADD_ADDEN | address;
-}
+static inline void usb_device_set_address(struct usb_module *module_inst, uint8_t address) { module_inst->hw->DEVICE.DADD.reg = USB_DEVICE_DADD_ADDEN | address; }
 
 /**
  * \brief Get the frame number of USB device
@@ -379,10 +364,7 @@ static inline void usb_device_set_address(struct usb_module *module_inst, uint8_
  * \param module_inst Pointer to USB device module instance
  * \return USB device frame number value.
  */
-static inline uint16_t usb_device_get_frame_number(struct usb_module *module_inst)
-{
-    return ((uint16_t)(module_inst->hw->DEVICE.FNUM.bit.FNUM));
-}
+static inline uint16_t usb_device_get_frame_number(struct usb_module *module_inst) { return ((uint16_t)(module_inst->hw->DEVICE.FNUM.bit.FNUM)); }
 
 /**
  * \brief Get the micro-frame number of USB device
@@ -390,20 +372,14 @@ static inline uint16_t usb_device_get_frame_number(struct usb_module *module_ins
  * \param module_inst Pointer to USB device module instance
  * \return USB device micro-frame number value.
  */
-static inline uint16_t usb_device_get_micro_frame_number(struct usb_module *module_inst)
-{
-    return ((uint16_t)(module_inst->hw->DEVICE.FNUM.reg));
-}
+static inline uint16_t usb_device_get_micro_frame_number(struct usb_module *module_inst) { return ((uint16_t)(module_inst->hw->DEVICE.FNUM.reg)); }
 
 /**
  * \brief USB device send the resume wakeup
  *
  * \param module_inst Pointer to USB device module instance
  */
-static inline void usb_device_send_remote_wake_up(struct usb_module *module_inst)
-{
-    module_inst->hw->DEVICE.CTRLB.reg |= USB_DEVICE_CTRLB_UPRSM;
-}
+static inline void usb_device_send_remote_wake_up(struct usb_module *module_inst) { module_inst->hw->DEVICE.CTRLB.reg |= USB_DEVICE_CTRLB_UPRSM; }
 
 /**
  * \brief USB device set the LPM mode
@@ -411,67 +387,45 @@ static inline void usb_device_send_remote_wake_up(struct usb_module *module_inst
  * \param module_inst Pointer to USB device module instance
  * \param lpm_mode    LPM mode
  */
-static inline void usb_device_set_lpm_mode(struct usb_module *module_inst,
-        enum usb_device_lpm_mode lpm_mode)
-{
-    module_inst->hw->DEVICE.CTRLB.bit.LPMHDSK = lpm_mode;
-}
+static inline void usb_device_set_lpm_mode(struct usb_module *module_inst, enum usb_device_lpm_mode lpm_mode) { module_inst->hw->DEVICE.CTRLB.bit.LPMHDSK = lpm_mode; }
 
 /**
  * \name USB Device Callback Management
  * @{
  */
-enum status_code usb_device_register_callback(struct usb_module *module_inst,
-        enum usb_device_callback callback_type,
-        usb_device_callback_t callback_func);
-enum status_code usb_device_unregister_callback(struct usb_module *module_inst,
-        enum usb_device_callback callback_type);
-enum status_code usb_device_enable_callback(struct usb_module *module_inst,
-        enum usb_device_callback callback_type);
-enum status_code usb_device_disable_callback(struct usb_module *module_inst,
-        enum usb_device_callback callback_type);
+enum status_code usb_device_register_callback(struct usb_module *module_inst, enum usb_device_callback callback_type, usb_device_callback_t callback_func);
+enum status_code usb_device_unregister_callback(struct usb_module *module_inst, enum usb_device_callback callback_type);
+enum status_code usb_device_enable_callback(struct usb_module *module_inst, enum usb_device_callback callback_type);
+enum status_code usb_device_disable_callback(struct usb_module *module_inst, enum usb_device_callback callback_type);
 /** @} */
 
 /**
  * \name USB Device Endpoint Configuration
  * @{
  */
-void usb_device_endpoint_get_config_defaults(struct usb_device_endpoint_config *ep_config);
-enum status_code usb_device_endpoint_set_config(struct usb_module *module_inst,
-        struct usb_device_endpoint_config *ep_config);
-bool usb_device_endpoint_is_configured(struct usb_module *module_inst, uint8_t ep);
+void             usb_device_endpoint_get_config_defaults(struct usb_device_endpoint_config *ep_config);
+enum status_code usb_device_endpoint_set_config(struct usb_module *module_inst, struct usb_device_endpoint_config *ep_config);
+bool             usb_device_endpoint_is_configured(struct usb_module *module_inst, uint8_t ep);
 /** @} */
 
 /**
  * \name USB Device Endpoint Callback Management
  * @{
  */
-enum status_code usb_device_endpoint_register_callback(
-        struct usb_module *module_inst, uint8_t ep_num,
-        enum usb_device_endpoint_callback callback_type,
-        usb_device_endpoint_callback_t callback_func);
-enum status_code usb_device_endpoint_unregister_callback(
-        struct usb_module *module_inst, uint8_t ep_num,
-        enum usb_device_endpoint_callback callback_type);
-enum status_code usb_device_endpoint_enable_callback(
-        struct usb_module *module_inst, uint8_t ep,
-        enum usb_device_endpoint_callback callback_type);
-enum status_code usb_device_endpoint_disable_callback(
-        struct usb_module *module_inst, uint8_t ep,
-        enum usb_device_endpoint_callback callback_type);
+enum status_code usb_device_endpoint_register_callback(struct usb_module *module_inst, uint8_t ep_num, enum usb_device_endpoint_callback callback_type, usb_device_endpoint_callback_t callback_func);
+enum status_code usb_device_endpoint_unregister_callback(struct usb_module *module_inst, uint8_t ep_num, enum usb_device_endpoint_callback callback_type);
+enum status_code usb_device_endpoint_enable_callback(struct usb_module *module_inst, uint8_t ep, enum usb_device_endpoint_callback callback_type);
+enum status_code usb_device_endpoint_disable_callback(struct usb_module *module_inst, uint8_t ep, enum usb_device_endpoint_callback callback_type);
 /** @} */
 
 /**
  * \name USB Device Endpoint Job Management
  * @{
  */
-enum status_code usb_device_endpoint_write_buffer_job(struct usb_module *module_inst,uint8_t ep_num,
-        uint8_t* pbuf, uint32_t buf_size);
-enum status_code usb_device_endpoint_read_buffer_job(struct usb_module *module_inst,uint8_t ep_num,
-        uint8_t* pbuf, uint32_t buf_size);
-enum status_code usb_device_endpoint_setup_buffer_job(struct usb_module *module_inst,
-        uint8_t* pbuf);
-void usb_device_endpoint_abort_job(struct usb_module *module_inst, uint8_t ep);
+enum status_code usb_device_endpoint_write_buffer_job(struct usb_module *module_inst, uint8_t ep_num, uint8_t *pbuf, uint32_t buf_size);
+enum status_code usb_device_endpoint_read_buffer_job(struct usb_module *module_inst, uint8_t ep_num, uint8_t *pbuf, uint32_t buf_size);
+enum status_code usb_device_endpoint_setup_buffer_job(struct usb_module *module_inst, uint8_t *pbuf);
+void             usb_device_endpoint_abort_job(struct usb_module *module_inst, uint8_t ep);
 /** @} */
 
 /**
diff --git a/tmk_core/protocol/arm_atsam/usb/usb2422.c b/tmk_core/protocol/arm_atsam/usb/usb2422.c
index 76ec3aaaa..a878cb6b7 100644
--- a/tmk_core/protocol/arm_atsam/usb/usb2422.c
+++ b/tmk_core/protocol/arm_atsam/usb/usb2422.c
@@ -18,23 +18,22 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include "arm_atsam_protocol.h"
 #include <string.h>
 
-Usb2422 USB2422_shadow;
+Usb2422       USB2422_shadow;
 unsigned char i2c0_buf[34];
 
-const uint16_t MFRNAME[] = { 'M','a','s','s','d','r','o','p',' ','I','n','c','.' }; //Massdrop Inc.
-const uint16_t PRDNAME[] = { 'M','a','s','s','d','r','o','p',' ','H','u','b' }; //Massdrop Hub
+const uint16_t MFRNAME[] = {'M', 'a', 's', 's', 'd', 'r', 'o', 'p', ' ', 'I', 'n', 'c', '.'};  // Massdrop Inc.
+const uint16_t PRDNAME[] = {'M', 'a', 's', 's', 'd', 'r', 'o', 'p', ' ', 'H', 'u', 'b'};       // Massdrop Hub
 #ifndef MD_BOOTLOADER
-//Serial number reported stops before first found space character or at last found character
-const uint16_t SERNAME[] = { 'U','n','a','v','a','i','l','a','b','l','e' }; //Unavailable
+// Serial number reported stops before first found space character or at last found character
+const uint16_t SERNAME[] = {'U', 'n', 'a', 'v', 'a', 'i', 'l', 'a', 'b', 'l', 'e'};  // Unavailable
 #else
-//In production, this field is found, modified, and offset noted as the last 32-bit word in the bootloader space
-//The offset allows the application to use the factory programmed serial (which may differ from the physical serial label)
-//Serial number reported stops before first found space character or when max size is reached
-__attribute__((__aligned__(4)))
-const uint16_t SERNAME[BOOTLOADER_SERIAL_MAX_SIZE] = { 'M','D','H','U','B','B','O','O','T','L','0','0','0','0','0','0','0','0','0','0' };
-//NOTE: Serial replacer will not write a string longer than given here as a precaution, so give enough
+// In production, this field is found, modified, and offset noted as the last 32-bit word in the bootloader space
+// The offset allows the application to use the factory programmed serial (which may differ from the physical serial label)
+// Serial number reported stops before first found space character or when max size is reached
+__attribute__((__aligned__(4))) const uint16_t SERNAME[BOOTLOADER_SERIAL_MAX_SIZE] = {'M', 'D', 'H', 'U', 'B', 'B', 'O', 'O', 'T', 'L', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0'};
+// NOTE: Serial replacer will not write a string longer than given here as a precaution, so give enough
 //      space as needed and adjust BOOTLOADER_SERIAL_MAX_SIZE to match amount given
-#endif //MD_BOOTLOADER
+#endif  // MD_BOOTLOADER
 
 uint8_t usb_host_port;
 
@@ -44,95 +43,116 @@ uint8_t usb_extra_state;
 uint8_t usb_extra_manual;
 uint8_t usb_gcr_auto;
 
-#endif //MD_BOOTLOADER
+#endif  // MD_BOOTLOADER
 
 uint16_t adc_extra;
 
-void USB_write2422_block(void)
-{
+void USB_write2422_block(void) {
     unsigned char *dest = i2c0_buf;
     unsigned char *src;
     unsigned char *base = (unsigned char *)&USB2422_shadow;
 
     DBGC(DC_USB_WRITE2422_BLOCK_BEGIN);
 
-    for (src =  base; src < base + 256; src += 32)
-    {
+    for (src = base; src < base + 256; src += 32) {
         dest[0] = src - base;
         dest[1] = 32;
         memcpy(&dest[2], src, 32);
         i2c0_transmit(USB2422_ADDR, dest, 34, 50000);
         SERCOM0->I2CM.CTRLB.bit.CMD = 0x03;
-        while (SERCOM0->I2CM.SYNCBUSY.bit.SYSOP) { DBGC(DC_USB_WRITE2422_BLOCK_SYNC_SYSOP); }
+        while (SERCOM0->I2CM.SYNCBUSY.bit.SYSOP) {
+            DBGC(DC_USB_WRITE2422_BLOCK_SYNC_SYSOP);
+        }
         wait_us(100);
     }
 
     DBGC(DC_USB_WRITE2422_BLOCK_COMPLETE);
 }
 
-void USB2422_init(void)
-{
-    Gclk *pgclk = GCLK;
-    Mclk *pmclk = MCLK;
-    Port *pport = PORT;
-    Oscctrl *posc = OSCCTRL;
-    Usb *pusb = USB;
+void USB2422_init(void) {
+    Gclk *   pgclk = GCLK;
+    Mclk *   pmclk = MCLK;
+    Port *   pport = PORT;
+    Oscctrl *posc  = OSCCTRL;
+    Usb *    pusb  = USB;
 
     DBGC(DC_USB2422_INIT_BEGIN);
 
-    while ((v_5v = adc_get(ADC_5V)) < ADC_5V_START_LEVEL) { DBGC(DC_USB2422_INIT_WAIT_5V_LOW); }
+    while ((v_5v = adc_get(ADC_5V)) < ADC_5V_START_LEVEL) {
+        DBGC(DC_USB2422_INIT_WAIT_5V_LOW);
+    }
 
-    //setup peripheral and synchronous bus clocks to USB
-    pgclk->PCHCTRL[10].bit.GEN = 0;
+    // setup peripheral and synchronous bus clocks to USB
+    pgclk->PCHCTRL[10].bit.GEN  = 0;
     pgclk->PCHCTRL[10].bit.CHEN = 1;
-    pmclk->AHBMASK.bit.USB_ = 1;
-    pmclk->APBBMASK.bit.USB_ = 1;
+    pmclk->AHBMASK.bit.USB_     = 1;
+    pmclk->APBBMASK.bit.USB_    = 1;
 
-    //setup port pins for D-, D+, and SOF_1KHZ
-    pport->Group[0].PMUX[12].reg = 0x77; //PA24, PA25, function column H for USB D-, D+
+    // setup port pins for D-, D+, and SOF_1KHZ
+    pport->Group[0].PMUX[12].reg          = 0x77;  // PA24, PA25, function column H for USB D-, D+
     pport->Group[0].PINCFG[24].bit.PMUXEN = 1;
     pport->Group[0].PINCFG[25].bit.PMUXEN = 1;
-    pport->Group[1].PMUX[11].bit.PMUXE = 7; //PB22, function column H for USB SOF_1KHz output
+    pport->Group[1].PMUX[11].bit.PMUXE    = 7;  // PB22, function column H for USB SOF_1KHz output
     pport->Group[1].PINCFG[22].bit.PMUXEN = 1;
 
-    //configure and enable DFLL for USB clock recovery mode at 48MHz
+    // configure and enable DFLL for USB clock recovery mode at 48MHz
     posc->DFLLCTRLA.bit.ENABLE = 0;
-    while (posc->DFLLSYNC.bit.ENABLE) { DBGC(DC_USB2422_INIT_OSC_SYNC_DISABLING); }
-    while (posc->DFLLSYNC.bit.DFLLCTRLB) { DBGC(DC_USB2422_INIT_OSC_SYNC_DFLLCTRLB_1); }
+    while (posc->DFLLSYNC.bit.ENABLE) {
+        DBGC(DC_USB2422_INIT_OSC_SYNC_DISABLING);
+    }
+    while (posc->DFLLSYNC.bit.DFLLCTRLB) {
+        DBGC(DC_USB2422_INIT_OSC_SYNC_DFLLCTRLB_1);
+    }
     posc->DFLLCTRLB.bit.USBCRM = 1;
-    while (posc->DFLLSYNC.bit.DFLLCTRLB) { DBGC(DC_USB2422_INIT_OSC_SYNC_DFLLCTRLB_2); }
+    while (posc->DFLLSYNC.bit.DFLLCTRLB) {
+        DBGC(DC_USB2422_INIT_OSC_SYNC_DFLLCTRLB_2);
+    }
     posc->DFLLCTRLB.bit.MODE = 1;
-    while (posc->DFLLSYNC.bit.DFLLCTRLB) { DBGC(DC_USB2422_INIT_OSC_SYNC_DFLLCTRLB_3); }
+    while (posc->DFLLSYNC.bit.DFLLCTRLB) {
+        DBGC(DC_USB2422_INIT_OSC_SYNC_DFLLCTRLB_3);
+    }
     posc->DFLLCTRLB.bit.QLDIS = 0;
-    while (posc->DFLLSYNC.bit.DFLLCTRLB) { DBGC(DC_USB2422_INIT_OSC_SYNC_DFLLCTRLB_4); }
+    while (posc->DFLLSYNC.bit.DFLLCTRLB) {
+        DBGC(DC_USB2422_INIT_OSC_SYNC_DFLLCTRLB_4);
+    }
     posc->DFLLCTRLB.bit.CCDIS = 1;
-    posc->DFLLMUL.bit.MUL = 0xBB80; //4800 x 1KHz
-    while (posc->DFLLSYNC.bit.DFLLMUL) { DBGC(DC_USB2422_INIT_OSC_SYNC_DFLLMUL); }
+    posc->DFLLMUL.bit.MUL     = 0xBB80;  // 4800 x 1KHz
+    while (posc->DFLLSYNC.bit.DFLLMUL) {
+        DBGC(DC_USB2422_INIT_OSC_SYNC_DFLLMUL);
+    }
     posc->DFLLCTRLA.bit.ENABLE = 1;
-    while (posc->DFLLSYNC.bit.ENABLE) { DBGC(DC_USB2422_INIT_OSC_SYNC_ENABLING); }
+    while (posc->DFLLSYNC.bit.ENABLE) {
+        DBGC(DC_USB2422_INIT_OSC_SYNC_ENABLING);
+    }
 
     pusb->DEVICE.CTRLA.bit.SWRST = 1;
-    while (pusb->DEVICE.SYNCBUSY.bit.SWRST) { DBGC(DC_USB2422_INIT_USB_SYNC_SWRST); }
-    while (pusb->DEVICE.CTRLA.bit.SWRST) { DBGC(DC_USB2422_INIT_USB_WAIT_SWRST); }
-    //calibration from factory presets
+    while (pusb->DEVICE.SYNCBUSY.bit.SWRST) {
+        DBGC(DC_USB2422_INIT_USB_SYNC_SWRST);
+    }
+    while (pusb->DEVICE.CTRLA.bit.SWRST) {
+        DBGC(DC_USB2422_INIT_USB_WAIT_SWRST);
+    }
+    // calibration from factory presets
     pusb->DEVICE.PADCAL.bit.TRANSN = (USB_FUSES_TRANSN_ADDR >> USB_FUSES_TRANSN_Pos) & USB_FUSES_TRANSN_Msk;
     pusb->DEVICE.PADCAL.bit.TRANSP = (USB_FUSES_TRANSP_ADDR >> USB_FUSES_TRANSP_Pos) & USB_FUSES_TRANSP_Msk;
-    pusb->DEVICE.PADCAL.bit.TRIM = (USB_FUSES_TRIM_ADDR >> USB_FUSES_TRIM_Pos) & USB_FUSES_TRIM_Msk;
-    //device mode, enabled
-    pusb->DEVICE.CTRLB.bit.SPDCONF = 0; //full speed
-    pusb->DEVICE.CTRLA.bit.MODE = 0;
-    pusb->DEVICE.CTRLA.bit.ENABLE = 1;
-    while (pusb->DEVICE.SYNCBUSY.bit.ENABLE) { DBGC(DC_USB2422_INIT_USB_SYNC_ENABLING); }
+    pusb->DEVICE.PADCAL.bit.TRIM   = (USB_FUSES_TRIM_ADDR >> USB_FUSES_TRIM_Pos) & USB_FUSES_TRIM_Msk;
+    // device mode, enabled
+    pusb->DEVICE.CTRLB.bit.SPDCONF = 0;  // full speed
+    pusb->DEVICE.CTRLA.bit.MODE    = 0;
+    pusb->DEVICE.CTRLA.bit.ENABLE  = 1;
+    while (pusb->DEVICE.SYNCBUSY.bit.ENABLE) {
+        DBGC(DC_USB2422_INIT_USB_SYNC_ENABLING);
+    }
 
     pusb->DEVICE.QOSCTRL.bit.DQOS = 2;
     pusb->DEVICE.QOSCTRL.bit.CQOS = 2;
 
     pport->Group[USB2422_HUB_ACTIVE_GROUP].PINCFG[USB2422_HUB_ACTIVE_PIN].bit.INEN = 1;
 
-    i2c0_init(); //IC2 clk must be high at USB2422 reset release time to signal SMB configuration
+    i2c0_init();  // IC2 clk must be high at USB2422 reset release time to signal SMB configuration
 
-    sr_exp_data.bit.HUB_CONNECT = 1; //connect signal
-    sr_exp_data.bit.HUB_RESET_N = 1; //reset high
+    sr_exp_data.bit.HUB_CONNECT = 1;  // connect signal
+    sr_exp_data.bit.HUB_RESET_N = 1;  // reset high
     SR_EXP_WriteData();
 
     wait_us(100);
@@ -140,78 +160,74 @@ void USB2422_init(void)
 #ifndef MD_BOOTLOADER
 
     usb_extra_manual = 0;
-    usb_gcr_auto = 1;
+    usb_gcr_auto     = 1;
 
-#endif //MD_BOOTLOADER
+#endif  // MD_BOOTLOADER
 
     DBGC(DC_USB2422_INIT_COMPLETE);
 }
 
-void USB_reset(void)
-{
+void USB_reset(void) {
     DBGC(DC_USB_RESET_BEGIN);
 
-    //pulse reset for at least 1 usec
-    sr_exp_data.bit.HUB_RESET_N = 0; //reset low
+    // pulse reset for at least 1 usec
+    sr_exp_data.bit.HUB_RESET_N = 0;  // reset low
     SR_EXP_WriteData();
     wait_us(2);
-    sr_exp_data.bit.HUB_RESET_N = 1; //reset high to run
+    sr_exp_data.bit.HUB_RESET_N = 1;  // reset high to run
     SR_EXP_WriteData();
 
     DBGC(DC_USB_RESET_COMPLETE);
 }
 
-void USB_configure(void)
-{
+void USB_configure(void) {
     Usb2422 *pusb2422 = &USB2422_shadow;
     memset(pusb2422, 0, sizeof(Usb2422));
 
-    uint16_t *serial_use = (uint16_t *)SERNAME; //Default to use SERNAME from this file
-    uint8_t serial_length = sizeof(SERNAME) / sizeof(uint16_t); //Default to use SERNAME from this file
+    uint16_t *serial_use    = (uint16_t *)SERNAME;                 // Default to use SERNAME from this file
+    uint8_t   serial_length = sizeof(SERNAME) / sizeof(uint16_t);  // Default to use SERNAME from this file
 #ifndef MD_BOOTLOADER
     uint32_t serial_ptrloc = (uint32_t)&_srom - 4;
-#else //MD_BOOTLOADER
+#else                                                      // MD_BOOTLOADER
     uint32_t serial_ptrloc = (uint32_t)&_erom - 4;
-#endif //MD_BOOTLOADER
-    uint32_t serial_address = *(uint32_t *)serial_ptrloc; //Address of bootloader's serial number if available
+#endif                                                     // MD_BOOTLOADER
+    uint32_t serial_address = *(uint32_t *)serial_ptrloc;  // Address of bootloader's serial number if available
 
     DBGC(DC_USB_CONFIGURE_BEGIN);
 
-    if (serial_address != 0xFFFFFFFF && serial_address < serial_ptrloc) //Check for factory programmed serial address
+    if (serial_address != 0xFFFFFFFF && serial_address < serial_ptrloc)  // Check for factory programmed serial address
     {
-        if ((serial_address & 0xFF) % 4 == 0) //Check alignment
+        if ((serial_address & 0xFF) % 4 == 0)  // Check alignment
         {
-            serial_use = (uint16_t *)(serial_address);
+            serial_use    = (uint16_t *)(serial_address);
             serial_length = 0;
-            while ((*(serial_use + serial_length) > 32 && *(serial_use + serial_length) < 127) &&
-                   serial_length < BOOTLOADER_SERIAL_MAX_SIZE)
-            {
+            while ((*(serial_use + serial_length) > 32 && *(serial_use + serial_length) < 127) && serial_length < BOOTLOADER_SERIAL_MAX_SIZE) {
                 serial_length++;
                 DBGC(DC_USB_CONFIGURE_GET_SERIAL);
             }
         }
     }
 
-    //configure Usb2422 registers
-    pusb2422->VID.reg = 0x04D8; // from Microchip 4/19/2018
-    pusb2422->PID.reg = 0xEEC5; // from Microchip 4/19/2018 = Massdrop, Inc. USB Hub
-    pusb2422->DID.reg = 0x0101; // BCD 01.01
-    pusb2422->CFG1.bit.SELF_BUS_PWR = 1; // self powered for now
-    pusb2422->CFG1.bit.HS_DISABLE = 1; // full or high speed
-    //pusb2422->CFG2.bit.COMPOUND = 0; // compound device
-    pusb2422->CFG3.bit.STRING_EN = 1; // strings enabled
-    //pusb2422->NRD.bit.PORT2_NR = 0; // MCU is non-removable
-    pusb2422->MAXPB.reg = 20; // 0mA
-    pusb2422->HCMCB.reg = 20; // 0mA
+    // configure Usb2422 registers
+    pusb2422->VID.reg               = 0x04D8;  // from Microchip 4/19/2018
+    pusb2422->PID.reg               = 0xEEC5;  // from Microchip 4/19/2018 = Massdrop, Inc. USB Hub
+    pusb2422->DID.reg               = 0x0101;  // BCD 01.01
+    pusb2422->CFG1.bit.SELF_BUS_PWR = 1;       // self powered for now
+    pusb2422->CFG1.bit.HS_DISABLE   = 1;       // full or high speed
+    // pusb2422->CFG2.bit.COMPOUND = 0; // compound device
+    pusb2422->CFG3.bit.STRING_EN = 1;  // strings enabled
+    // pusb2422->NRD.bit.PORT2_NR = 0; // MCU is non-removable
+    pusb2422->MAXPB.reg = 20;  // 0mA
+    pusb2422->HCMCB.reg = 20;  // 0mA
     pusb2422->MFRSL.reg = sizeof(MFRNAME) / sizeof(uint16_t);
     pusb2422->PRDSL.reg = sizeof(PRDNAME) / sizeof(uint16_t);
     pusb2422->SERSL.reg = serial_length;
     memcpy(pusb2422->MFRSTR, MFRNAME, sizeof(MFRNAME));
     memcpy(pusb2422->PRDSTR, PRDNAME, sizeof(PRDNAME));
     memcpy(pusb2422->SERSTR, serial_use, serial_length * sizeof(uint16_t));
-    //pusb2422->BOOSTUP.bit.BOOST=3;    //upstream port
-    //pusb2422->BOOSTDOWN.bit.BOOST1=0; // extra port
-    //pusb2422->BOOSTDOWN.bit.BOOST2=2; //MCU is close
+    // pusb2422->BOOSTUP.bit.BOOST=3;    //upstream port
+    // pusb2422->BOOSTDOWN.bit.BOOST1=0; // extra port
+    // pusb2422->BOOSTDOWN.bit.BOOST2=2; //MCU is close
     pusb2422->STCD.bit.USB_ATTACH = 1;
     USB_write2422_block();
 
@@ -220,35 +236,33 @@ void USB_configure(void)
     DBGC(DC_USB_CONFIGURE_COMPLETE);
 }
 
-uint16_t USB_active(void)
-{
-    return (PORT->Group[USB2422_HUB_ACTIVE_GROUP].IN.reg & (1 << USB2422_HUB_ACTIVE_PIN)) != 0;
-}
+uint16_t USB_active(void) { return (PORT->Group[USB2422_HUB_ACTIVE_GROUP].IN.reg & (1 << USB2422_HUB_ACTIVE_PIN)) != 0; }
 
-void USB_set_host_by_voltage(void)
-{
-    //UP is upstream device (HOST)
-    //DN1 is downstream device (EXTRA)
-    //DN2 is keyboard (KEYB)
+void USB_set_host_by_voltage(void) {
+    // UP is upstream device (HOST)
+    // DN1 is downstream device (EXTRA)
+    // DN2 is keyboard (KEYB)
 
     DBGC(DC_USB_SET_HOST_BY_VOLTAGE_BEGIN);
 
     usb_host_port = USB_HOST_PORT_UNKNOWN;
 #ifndef MD_BOOTLOADER
     usb_extra_state = USB_EXTRA_STATE_UNKNOWN;
-#endif //MD_BOOTLOADER
-    sr_exp_data.bit.SRC_1 = 1;       //USBC-1 available for test
-    sr_exp_data.bit.SRC_2 = 1;       //USBC-2 available for test
-    sr_exp_data.bit.E_UP_N = 1;      //HOST disable
-    sr_exp_data.bit.E_DN1_N = 1;     //EXTRA disable
-    sr_exp_data.bit.E_VBUS_1 = 0;    //USBC-1 disable full power I/O
-    sr_exp_data.bit.E_VBUS_2 = 0;    //USBC-2 disable full power I/O
+#endif                             // MD_BOOTLOADER
+    sr_exp_data.bit.SRC_1    = 1;  // USBC-1 available for test
+    sr_exp_data.bit.SRC_2    = 1;  // USBC-2 available for test
+    sr_exp_data.bit.E_UP_N   = 1;  // HOST disable
+    sr_exp_data.bit.E_DN1_N  = 1;  // EXTRA disable
+    sr_exp_data.bit.E_VBUS_1 = 0;  // USBC-1 disable full power I/O
+    sr_exp_data.bit.E_VBUS_2 = 0;  // USBC-2 disable full power I/O
 
     SR_EXP_WriteData();
 
     wait_ms(250);
 
-    while ((v_5v = adc_get(ADC_5V)) < ADC_5V_START_LEVEL) { DBGC(DC_USB_SET_HOST_5V_LOW_WAITING); }
+    while ((v_5v = adc_get(ADC_5V)) < ADC_5V_START_LEVEL) {
+        DBGC(DC_USB_SET_HOST_5V_LOW_WAITING);
+    }
 
     v_con_1 = adc_get(ADC_CON1);
     v_con_2 = adc_get(ADC_CON2);
@@ -256,37 +270,34 @@ void USB_set_host_by_voltage(void)
     v_con_1_boot = v_con_1;
     v_con_2_boot = v_con_2;
 
-    if (v_con_1 > v_con_2)
-    {
-        sr_exp_data.bit.S_UP = 0;        //HOST to USBC-1
-        sr_exp_data.bit.S_DN1 = 1;       //EXTRA to USBC-2
-        sr_exp_data.bit.SRC_1 = 1;       //HOST on USBC-1
-        sr_exp_data.bit.SRC_2 = 0;       //EXTRA available on USBC-2
+    if (v_con_1 > v_con_2) {
+        sr_exp_data.bit.S_UP  = 0;  // HOST to USBC-1
+        sr_exp_data.bit.S_DN1 = 1;  // EXTRA to USBC-2
+        sr_exp_data.bit.SRC_1 = 1;  // HOST on USBC-1
+        sr_exp_data.bit.SRC_2 = 0;  // EXTRA available on USBC-2
 
-        sr_exp_data.bit.E_VBUS_1 = 1;    //USBC-1 enable full power I/O
-        sr_exp_data.bit.E_VBUS_2 = 0;    //USBC-2 disable full power I/O
+        sr_exp_data.bit.E_VBUS_1 = 1;  // USBC-1 enable full power I/O
+        sr_exp_data.bit.E_VBUS_2 = 0;  // USBC-2 disable full power I/O
 
         SR_EXP_WriteData();
 
-        sr_exp_data.bit.E_UP_N = 0;      //HOST enable
+        sr_exp_data.bit.E_UP_N = 0;  // HOST enable
 
         SR_EXP_WriteData();
 
         usb_host_port = USB_HOST_PORT_1;
-    }
-    else
-    {
-        sr_exp_data.bit.S_UP = 1;        //EXTRA to USBC-1
-        sr_exp_data.bit.S_DN1 = 0;       //HOST to USBC-2
-        sr_exp_data.bit.SRC_1 = 0;       //EXTRA available on USBC-1
-        sr_exp_data.bit.SRC_2 = 1;       //HOST on USBC-2
+    } else {
+        sr_exp_data.bit.S_UP  = 1;  // EXTRA to USBC-1
+        sr_exp_data.bit.S_DN1 = 0;  // HOST to USBC-2
+        sr_exp_data.bit.SRC_1 = 0;  // EXTRA available on USBC-1
+        sr_exp_data.bit.SRC_2 = 1;  // HOST on USBC-2
 
-        sr_exp_data.bit.E_VBUS_1 = 0;    //USBC-1 disable full power I/O
-        sr_exp_data.bit.E_VBUS_2 = 1;    //USBC-2 enable full power I/O
+        sr_exp_data.bit.E_VBUS_1 = 0;  // USBC-1 disable full power I/O
+        sr_exp_data.bit.E_VBUS_2 = 1;  // USBC-2 enable full power I/O
 
         SR_EXP_WriteData();
 
-        sr_exp_data.bit.E_UP_N = 0;      //HOST enable
+        sr_exp_data.bit.E_UP_N = 0;  // HOST enable
 
         SR_EXP_WriteData();
 
@@ -295,7 +306,7 @@ void USB_set_host_by_voltage(void)
 
 #ifndef MD_BOOTLOADER
     usb_extra_state = USB_EXTRA_STATE_DISABLED;
-#endif //MD_BOOTLOADER
+#endif  // MD_BOOTLOADER
 
     USB_reset();
     USB_configure();
@@ -303,8 +314,7 @@ void USB_set_host_by_voltage(void)
     DBGC(DC_USB_SET_HOST_BY_VOLTAGE_COMPLETE);
 }
 
-uint8_t USB2422_Port_Detect_Init(void)
-{
+uint8_t USB2422_Port_Detect_Init(void) {
     uint32_t port_detect_retry_ms;
     uint32_t tmod;
 
@@ -314,26 +324,30 @@ uint8_t USB2422_Port_Detect_Init(void)
 
     port_detect_retry_ms = timer_read64() + PORT_DETECT_RETRY_INTERVAL;
 
-    while (!USB_active())
-    {
+    while (!USB_active()) {
         tmod = timer_read64() % PORT_DETECT_RETRY_INTERVAL;
 
-        if (v_con_1 > v_con_2) //Values updated from USB_set_host_by_voltage();
+        if (v_con_1 > v_con_2)  // Values updated from USB_set_host_by_voltage();
         {
-            //1 flash for port 1 detected
-            if (tmod > 500 && tmod < 600) { DBG_LED_ON; }
-            else { DBG_LED_OFF; }
-        }
-        else if (v_con_2 > v_con_1) //Values updated from USB_set_host_by_voltage();
+            // 1 flash for port 1 detected
+            if (tmod > 500 && tmod < 600) {
+                DBG_LED_ON;
+            } else {
+                DBG_LED_OFF;
+            }
+        } else if (v_con_2 > v_con_1)  // Values updated from USB_set_host_by_voltage();
         {
-            //2 flash for port 2 detected
-            if (tmod > 500 && tmod < 600) { DBG_LED_ON; }
-            else if (tmod > 700 && tmod < 800) { DBG_LED_ON; }
-            else { DBG_LED_OFF; }
+            // 2 flash for port 2 detected
+            if (tmod > 500 && tmod < 600) {
+                DBG_LED_ON;
+            } else if (tmod > 700 && tmod < 800) {
+                DBG_LED_ON;
+            } else {
+                DBG_LED_OFF;
+            }
         }
 
-        if (timer_read64() > port_detect_retry_ms)
-        {
+        if (timer_read64() > port_detect_retry_ms) {
             DBGC(DC_PORT_DETECT_INIT_FAILED);
             return 0;
         }
@@ -346,65 +360,67 @@ uint8_t USB2422_Port_Detect_Init(void)
 
 #ifndef MD_BOOTLOADER
 
-void USB_ExtraSetState(uint8_t state)
-{
+void USB_ExtraSetState(uint8_t state) {
     uint8_t state_save = state;
 
-    if (state == USB_EXTRA_STATE_DISABLED_UNTIL_REPLUG)
-        state = USB_EXTRA_STATE_DISABLED;
+    if (state == USB_EXTRA_STATE_DISABLED_UNTIL_REPLUG) state = USB_EXTRA_STATE_DISABLED;
 
-    if (usb_host_port == USB_HOST_PORT_1) sr_exp_data.bit.E_VBUS_2 = state;
-    else if (usb_host_port == USB_HOST_PORT_2) sr_exp_data.bit.E_VBUS_1 = state;
-    else return;
+    if (usb_host_port == USB_HOST_PORT_1)
+        sr_exp_data.bit.E_VBUS_2 = state;
+    else if (usb_host_port == USB_HOST_PORT_2)
+        sr_exp_data.bit.E_VBUS_1 = state;
+    else
+        return;
 
     sr_exp_data.bit.E_DN1_N = !state;
     SR_EXP_WriteData();
 
     usb_extra_state = state_save;
 
-    if (usb_extra_state == USB_EXTRA_STATE_ENABLED) CDC_print("USB: Extra enabled\r\n");
-    else if (usb_extra_state == USB_EXTRA_STATE_DISABLED)
-    {
+    if (usb_extra_state == USB_EXTRA_STATE_ENABLED)
+        CDC_print("USB: Extra enabled\r\n");
+    else if (usb_extra_state == USB_EXTRA_STATE_DISABLED) {
         CDC_print("USB: Extra disabled\r\n");
-#ifdef USE_MASSDROP_CONFIGURATOR
+#    ifdef USE_MASSDROP_CONFIGURATOR
         if (led_animation_breathing) gcr_breathe = gcr_desired;
-#endif
-    }
-    else if (usb_extra_state == USB_EXTRA_STATE_DISABLED_UNTIL_REPLUG) CDC_print("USB: Extra disabled until replug\r\n");
-    else CDC_print("USB: Extra state unknown\r\n");
+#    endif
+    } else if (usb_extra_state == USB_EXTRA_STATE_DISABLED_UNTIL_REPLUG)
+        CDC_print("USB: Extra disabled until replug\r\n");
+    else
+        CDC_print("USB: Extra state unknown\r\n");
 }
 
-void USB_HandleExtraDevice(void)
-{
+void USB_HandleExtraDevice(void) {
     uint16_t adcval;
 
-    if (usb_host_port == USB_HOST_PORT_1) adcval = adc_get(ADC_CON2);
-    else if (usb_host_port == USB_HOST_PORT_2) adcval = adc_get(ADC_CON1);
-    else return;
+    if (usb_host_port == USB_HOST_PORT_1)
+        adcval = adc_get(ADC_CON2);
+    else if (usb_host_port == USB_HOST_PORT_2)
+        adcval = adc_get(ADC_CON1);
+    else
+        return;
 
     adc_extra = adc_extra * 0.9 + adcval * 0.1;
 
-    //Check for a forced disable state (such as overload prevention)
-    if (usb_extra_state == USB_EXTRA_STATE_DISABLED_UNTIL_REPLUG)
-    {
-        //Detect unplug and reset state to disabled
+    // Check for a forced disable state (such as overload prevention)
+    if (usb_extra_state == USB_EXTRA_STATE_DISABLED_UNTIL_REPLUG) {
+        // Detect unplug and reset state to disabled
         if (adc_extra > USB_EXTRA_ADC_THRESHOLD) usb_extra_state = USB_EXTRA_STATE_DISABLED;
 
-        return; //Return even if unplug detected
+        return;  // Return even if unplug detected
     }
 
-    if (usb_extra_manual)
-    {
-        if (usb_extra_state == USB_EXTRA_STATE_DISABLED)
-        USB_ExtraSetState(USB_EXTRA_STATE_ENABLED);
+    if (usb_extra_manual) {
+        if (usb_extra_state == USB_EXTRA_STATE_DISABLED) USB_ExtraSetState(USB_EXTRA_STATE_ENABLED);
 
         return;
     }
 
-    //dpf("a %i %i\r\n",adcval, adc_extra);
-    if (usb_extra_state == USB_EXTRA_STATE_DISABLED && adc_extra < USB_EXTRA_ADC_THRESHOLD) USB_ExtraSetState(USB_EXTRA_STATE_ENABLED);
-    else if (usb_extra_state == USB_EXTRA_STATE_ENABLED && adc_extra > USB_EXTRA_ADC_THRESHOLD) USB_ExtraSetState(USB_EXTRA_STATE_DISABLED);
+    // dpf("a %i %i\r\n",adcval, adc_extra);
+    if (usb_extra_state == USB_EXTRA_STATE_DISABLED && adc_extra < USB_EXTRA_ADC_THRESHOLD)
+        USB_ExtraSetState(USB_EXTRA_STATE_ENABLED);
+    else if (usb_extra_state == USB_EXTRA_STATE_ENABLED && adc_extra > USB_EXTRA_ADC_THRESHOLD)
+        USB_ExtraSetState(USB_EXTRA_STATE_DISABLED);
 }
 
-#endif //MD_BOOTLOADER
-
+#endif  // MD_BOOTLOADER
diff --git a/tmk_core/protocol/arm_atsam/usb/usb2422.h b/tmk_core/protocol/arm_atsam/usb/usb2422.h
index 85ad596a6..b4830b5bc 100644
--- a/tmk_core/protocol/arm_atsam/usb/usb2422.h
+++ b/tmk_core/protocol/arm_atsam/usb/usb2422.h
@@ -18,226 +18,225 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #ifndef _USB2422_H_
 #define _USB2422_H_
 
-#define REV_USB2422        0x100
+#define REV_USB2422 0x100
 
-#define USB2422_ADDR       0x58 //I2C device address, one instance
+#define USB2422_ADDR 0x58  // I2C device address, one instance
 
-#define USB2422_HUB_ACTIVE_GROUP    0   //PA
-#define USB2422_HUB_ACTIVE_PIN      18  //18
+#define USB2422_HUB_ACTIVE_GROUP 0  // PA
+#define USB2422_HUB_ACTIVE_PIN 18   // 18
 
 /* -------- USB2422_VID : (USB2422L Offset: 0x00) (R/W 16) Vendor ID -------- */
 #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__))
 typedef union {
-  struct {
-    uint16_t VID_LSB : 8;
-    uint16_t VID_MSB : 8;
-  } bit;                       /*!< Structure used for bit  access                  */
-  uint16_t reg;                /*!< Type      used for register access              */
+    struct {
+        uint16_t VID_LSB : 8;
+        uint16_t VID_MSB : 8;
+    } bit;        /*!< Structure used for bit  access                  */
+    uint16_t reg; /*!< Type      used for register access              */
 } USB2422_VID_Type;
 #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */
 
 /* -------- USB2422_PID : (USB2422L Offset: 0x02) (R/W 16) Product ID -------- */
 #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__))
 typedef union {
-  struct {
-    uint16_t PID_LSB : 8;
-    uint16_t PID_MSB : 8;
-  } bit;                       /*!< Structure used for bit  access                  */
-  uint16_t reg;                /*!< Type      used for register access              */
+    struct {
+        uint16_t PID_LSB : 8;
+        uint16_t PID_MSB : 8;
+    } bit;        /*!< Structure used for bit  access                  */
+    uint16_t reg; /*!< Type      used for register access              */
 } USB2422_PID_Type;
 #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */
 
 /* -------- USB2422_DID : (USB2422L Offset: 0x04) (R/W 16) Device ID -------- */
 #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__))
 typedef union {
-  struct {
-    uint16_t DID_LSB : 8;
-    uint16_t DID_MSB : 8;
-  } bit;                       /*!< Structure used for bit  access                  */
-  uint16_t reg;                /*!< Type      used for register access              */
+    struct {
+        uint16_t DID_LSB : 8;
+        uint16_t DID_MSB : 8;
+    } bit;        /*!< Structure used for bit  access                  */
+    uint16_t reg; /*!< Type      used for register access              */
 } USB2422_DID_Type;
 #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */
 
 /* -------- USB2422_CFG1 : (USB2422L Offset: 0x06) (R/W 8) Configuration Data Byte 1-------- */
 #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__))
 typedef union {
-  struct {
-    uint8_t PORT_PWR : 1;
-    uint8_t CURRENT_SNS : 2;
-    uint8_t EOP_DISABLE : 1;
-    uint8_t MTT_ENABLE : 1;
-    uint8_t HS_DISABLE :1;
-    uint8_t :1;
-    uint8_t SELF_BUS_PWR : 1;
-  } bit;                       /*!< Structure used for bit  access                  */
-  uint8_t reg;                 /*!< Type      used for register access              */
+    struct {
+        uint8_t PORT_PWR : 1;
+        uint8_t CURRENT_SNS : 2;
+        uint8_t EOP_DISABLE : 1;
+        uint8_t MTT_ENABLE : 1;
+        uint8_t HS_DISABLE : 1;
+        uint8_t : 1;
+        uint8_t SELF_BUS_PWR : 1;
+    } bit;       /*!< Structure used for bit  access                  */
+    uint8_t reg; /*!< Type      used for register access              */
 } USB2422_CFG1_Type;
 #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */
 
 /* -------- USB2422_CFG2 : (USB2422L Offset: 0x07) (R/W 8) Configuration Data Byte 2-------- */
 #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__))
 typedef union {
-  struct {
-    uint8_t : 3;
-    uint8_t COMPOUND : 1;
-    uint8_t OC_TIMER :2;
-    uint8_t :1;
-    uint8_t DYNAMIC : 1;
-  } bit;                       /*!< Structure used for bit  access                  */
-  uint8_t reg;                 /*!< Type      used for register access              */
+    struct {
+        uint8_t : 3;
+        uint8_t COMPOUND : 1;
+        uint8_t OC_TIMER : 2;
+        uint8_t : 1;
+        uint8_t DYNAMIC : 1;
+    } bit;       /*!< Structure used for bit  access                  */
+    uint8_t reg; /*!< Type      used for register access              */
 } USB2422_CFG2_Type;
 #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */
 
 /* -------- USB2422_CFG3 : (USB2422L Offset: 0x08) (R/W 16) Configuration Data Byte 3-------- */
 #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__))
 typedef union {
-  struct {
-    uint8_t STRING_EN : 1;
-    uint8_t  :2;
-    uint8_t PRTMAP_EN :1;
-    uint8_t : 4;
-  } bit;                       /*!< Structure used for bit  access                  */
-  uint8_t reg;                 /*!< Type      used for register access              */
+    struct {
+        uint8_t STRING_EN : 1;
+        uint8_t : 2;
+        uint8_t PRTMAP_EN : 1;
+        uint8_t : 4;
+    } bit;       /*!< Structure used for bit  access                  */
+    uint8_t reg; /*!< Type      used for register access              */
 } USB2422_CFG3_Type;
 #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */
 
 /* -------- USB2422_NRD : (USB2422L Offset: 0x09) (R/W 8) Non Removable Device -------- */
 #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__))
 typedef union {
-  struct {
-    uint8_t : 5;
-    uint8_t PORT2_NR :1;
-    uint8_t PORT1_NR :1;
-    uint8_t : 1;
-  } bit;                       /*!< Structure used for bit  access                  */
-  uint8_t reg;                 /*!< Type      used for register access              */
+    struct {
+        uint8_t : 5;
+        uint8_t PORT2_NR : 1;
+        uint8_t PORT1_NR : 1;
+        uint8_t : 1;
+    } bit;       /*!< Structure used for bit  access                  */
+    uint8_t reg; /*!< Type      used for register access              */
 } USB2422_NRD_Type;
 #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */
 
 /* -------- USB2422_PDS : (USB2422L Offset: 0x0A) (R/W 8) Port Diable for Self-Powered Operation -------- */
 #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__))
 typedef union {
-  struct {
-    uint8_t : 1;
-    uint8_t PORT1_DIS :1;
-    uint8_t PORT2_DIS :1;
-    uint8_t : 5;
-  } bit;                       /*!< Structure used for bit  access                  */
-  uint8_t reg;                 /*!< Type      used for register access              */
+    struct {
+        uint8_t : 1;
+        uint8_t PORT1_DIS : 1;
+        uint8_t PORT2_DIS : 1;
+        uint8_t : 5;
+    } bit;       /*!< Structure used for bit  access                  */
+    uint8_t reg; /*!< Type      used for register access              */
 } USB2422_PDS_Type;
 #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */
 
 /* -------- USB2422_PDB : (USB2422L Offset: 0x0B) (R/W 8) Port Diable for Bus-Powered Operation -------- */
 #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__))
 typedef union {
-  struct {
-    uint8_t : 1;
-    uint8_t PORT1_DIS :1;
-    uint8_t PORT2_DIS :1;
-    uint8_t : 5;
-  } bit;                       /*!< Structure used for bit  access                  */
-  uint8_t reg;                 /*!< Type      used for register access              */
+    struct {
+        uint8_t : 1;
+        uint8_t PORT1_DIS : 1;
+        uint8_t PORT2_DIS : 1;
+        uint8_t : 5;
+    } bit;       /*!< Structure used for bit  access                  */
+    uint8_t reg; /*!< Type      used for register access              */
 } USB2422_PDB_Type;
 #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */
 
 /* -------- USB2422_MAXPS : (USB2422L Offset: 0x0C) (R/W 8) Max Power for Self-Powered Operation -------- */
 #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__))
 typedef union {
-  struct {
-    uint8_t MAX_PWR_SP : 8;
-  } bit;                       /*!< Structure used for bit  access                  */
-  uint8_t reg;                 /*!< Type      used for register access              */
+    struct {
+        uint8_t MAX_PWR_SP : 8;
+    } bit;       /*!< Structure used for bit  access                  */
+    uint8_t reg; /*!< Type      used for register access              */
 } USB2422_MAXPS_Type;
 #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */
 
 /* -------- USB2422_MAXPB : (USB2422L Offset: 0x0D) (R/W 8) Max Power for Bus-Powered Operation -------- */
 #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__))
 typedef union {
-  struct {
-    uint8_t MAX_PWR_BP : 8;
-  } bit;                       /*!< Structure used for bit  access                  */
-  uint8_t reg;                 /*!< Type      used for register access              */
+    struct {
+        uint8_t MAX_PWR_BP : 8;
+    } bit;       /*!< Structure used for bit  access                  */
+    uint8_t reg; /*!< Type      used for register access              */
 } USB2422_MAXPB_Type;
 #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */
 
 /* -------- USB2422_HCMCS : (USB2422L Offset: 0x0E) (R/W 8) Hub Controller Max Current for Self-Powered Operation -------- */
 #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__))
 typedef union {
-  struct {
-    uint8_t HC_MAX_C_SP : 8;
-  } bit;                       /*!< Structure used for bit  access                  */
-  uint8_t reg;                 /*!< Type      used for register access              */
+    struct {
+        uint8_t HC_MAX_C_SP : 8;
+    } bit;       /*!< Structure used for bit  access                  */
+    uint8_t reg; /*!< Type      used for register access              */
 } USB2422_HCMCS_Type;
 #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */
 
 /* -------- USB2422_HCMCB : (USB2422L Offset: 0x0F) (R/W 8) Hub Controller Max Current for Bus-Powered Operation -------- */
 #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__))
 typedef union {
-  struct {
-    uint8_t HC_MAX_C_BP : 8;
-  } bit;                       /*!< Structure used for bit  access                  */
-  uint8_t reg;                 /*!< Type      used for register access              */
+    struct {
+        uint8_t HC_MAX_C_BP : 8;
+    } bit;       /*!< Structure used for bit  access                  */
+    uint8_t reg; /*!< Type      used for register access              */
 } USB2422_HCMCB_Type;
 #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */
 
 /* -------- USB2422_PWRT : (USB2422L Offset: 0x10) (R/W 8) Power On Time -------- */
 #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__))
 typedef union {
-  struct {
-    uint8_t POWER_ON_TIME : 8;
-  } bit;                       /*!< Structure used for bit  access                  */
-  uint8_t reg;                 /*!< Type      used for register access              */
+    struct {
+        uint8_t POWER_ON_TIME : 8;
+    } bit;       /*!< Structure used for bit  access                  */
+    uint8_t reg; /*!< Type      used for register access              */
 } USB2422_PWRT_Type;
 #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */
 
 /* -------- USB2422_LANGID LSB : (USB2422L Offset: 0x11) (R/W 16) Language ID -------- */
 #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__))
 typedef union {
-  struct {
-    uint8_t LANGID_LSB : 8;
-  } bit;                       /*!< Structure used for bit  access                  */
-  uint8_t reg;                 /*!< Type      used for register access              */
+    struct {
+        uint8_t LANGID_LSB : 8;
+    } bit;       /*!< Structure used for bit  access                  */
+    uint8_t reg; /*!< Type      used for register access              */
 } USB2422_LANGID_LSB_Type;
 #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */
 
 /* -------- USB2422_LANGID MSB : (USB2422L Offset: 0x12) (R/W 16) Language ID -------- */
 #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__))
 typedef union {
-  struct {
-    uint8_t LANGID_MSB : 8;
-  } bit;                       /*!< Structure used for bit  access                  */
-  uint8_t reg;                 /*!< Type      used for register access              */
+    struct {
+        uint8_t LANGID_MSB : 8;
+    } bit;       /*!< Structure used for bit  access                  */
+    uint8_t reg; /*!< Type      used for register access              */
 } USB2422_LANGID_MSB_Type;
 #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */
 
-
 /* -------- USB2422_MFRSL : (USB2422L Offset: 0x13) (R/W 8) Manufacturer String Length -------- */
 #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__))
 typedef union {
-  struct {
-    uint8_t MFR_STR_LEN : 8;
-  } bit;                       /*!< Structure used for bit  access                  */
-  uint8_t reg;                 /*!< Type      used for register access              */
+    struct {
+        uint8_t MFR_STR_LEN : 8;
+    } bit;       /*!< Structure used for bit  access                  */
+    uint8_t reg; /*!< Type      used for register access              */
 } USB2422_MFRSL_Type;
 #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */
 
 /* -------- USB2422_PRDSL : (USB2422L Offset: 0x14) (R/W 8) Product String Length -------- */
 #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__))
 typedef union {
-  struct {
-    uint8_t PRD_STR_LEN : 8;
-  } bit;                       /*!< Structure used for bit  access                  */
-  uint8_t reg;                 /*!< Type      used for register access              */
+    struct {
+        uint8_t PRD_STR_LEN : 8;
+    } bit;       /*!< Structure used for bit  access                  */
+    uint8_t reg; /*!< Type      used for register access              */
 } USB2422_PRDSL_Type;
 #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */
 
 /* -------- USB2422_SERSL : (USB2422L Offset: 0x15) (R/W 8) Serial String Length -------- */
 #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__))
 typedef union {
-  struct {
-    uint8_t SER_STR_LEN : 8;
-  } bit;                       /*!< Structure used for bit  access                  */
-  uint8_t reg;                 /*!< Type      used for register access              */
+    struct {
+        uint8_t SER_STR_LEN : 8;
+    } bit;       /*!< Structure used for bit  access                  */
+    uint8_t reg; /*!< Type      used for register access              */
 } USB2422_SERSL_Type;
 #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */
 
@@ -259,60 +258,60 @@ typedef uint16_t USB2422_SERSTR_Type;
 /* -------- USB2422_BCEN : (USB2422L Offset: 0xD0) (R/W 8) Battery Charging Enable -------- */
 #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__))
 typedef union {
-  struct {
-    uint8_t : 1;
-    uint8_t PORT1_BCE :1;
-    uint8_t PORT2_BCE :1;
-    uint8_t : 5;
-  } bit;                       /*!< Structure used for bit  access                  */
-  uint8_t reg;                 /*!< Type      used for register access              */
+    struct {
+        uint8_t : 1;
+        uint8_t PORT1_BCE : 1;
+        uint8_t PORT2_BCE : 1;
+        uint8_t : 5;
+    } bit;       /*!< Structure used for bit  access                  */
+    uint8_t reg; /*!< Type      used for register access              */
 } USB2422_BCEN_Type;
 #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */
 
 /* -------- USB2422_BOOSTUP : (USB2422L Offset: 0xF6) (R/W 8) Boost Upstream -------- */
 #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__))
 typedef union {
-  struct {
-    uint8_t BOOST :2;
-    uint8_t : 6;
-  } bit;                       /*!< Structure used for bit  access                  */
-  uint8_t reg;                 /*!< Type      used for register access              */
+    struct {
+        uint8_t BOOST : 2;
+        uint8_t : 6;
+    } bit;       /*!< Structure used for bit  access                  */
+    uint8_t reg; /*!< Type      used for register access              */
 } USB2422_BOOSTUP_Type;
 #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */
 
 /* -------- USB2422_BOOSTDOWN : (USB2422L Offset: 0xF8) (R/W 8) Boost Downstream -------- */
 #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__))
 typedef union {
-  struct {
-    uint8_t BOOST1 :2;
-    uint8_t BOOST2 :2;
-    uint8_t : 4;
-  } bit;                       /*!< Structure used for bit  access                  */
-  uint8_t reg;                 /*!< Type      used for register access              */
+    struct {
+        uint8_t BOOST1 : 2;
+        uint8_t BOOST2 : 2;
+        uint8_t : 4;
+    } bit;       /*!< Structure used for bit  access                  */
+    uint8_t reg; /*!< Type      used for register access              */
 } USB2422_BOOSTDOWN_Type;
 #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */
 
 /* -------- USB2422_PRTSP : (USB2422L Offset: 0xFA) (R/W 8) Port Swap -------- */
 #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__))
 typedef union {
-  struct {
-    uint8_t : 1;
-    uint8_t PORT1_SP :1;
-    uint8_t PORT2_SP :1;
-    uint8_t : 5;
-  } bit;                       /*!< Structure used for bit  access                  */
-  uint8_t reg;                 /*!< Type      used for register access              */
+    struct {
+        uint8_t : 1;
+        uint8_t PORT1_SP : 1;
+        uint8_t PORT2_SP : 1;
+        uint8_t : 5;
+    } bit;       /*!< Structure used for bit  access                  */
+    uint8_t reg; /*!< Type      used for register access              */
 } USB2422_PRTSP_Type;
 #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */
 
 /* -------- USB2422_PRTR12 : (USB2422L Offset: 0xFB) (R/W 8) Port 1/2 Remap -------- */
 #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__))
 typedef union {
-  struct {
-    uint8_t PORT1_REMAP: 4;
-    uint8_t PORT2_REMAP: 4;
-  } bit;                       /*!< Structure used for bit  access                  */
-  uint8_t reg;                 /*!< Type      used for register access              */
+    struct {
+        uint8_t PORT1_REMAP : 4;
+        uint8_t PORT2_REMAP : 4;
+    } bit;       /*!< Structure used for bit  access                  */
+    uint8_t reg; /*!< Type      used for register access              */
 } USB2422_PRTR12_Type;
 #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */
 #define USB2422_PRTR12_DISABLE 0
@@ -324,81 +323,80 @@ typedef union {
 /* -------- USB2422_STCD : (USB2422L Offset: 0xFF) (R/W 8) Status Command -------- */
 #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__))
 typedef union {
-  struct {
-    uint8_t USB_ATTACH: 1;
-    uint8_t RESET: 1;
-    uint8_t INTF_PWRDN: 1;
-    uint8_t : 5;
-  } bit;                       /*!< Structure used for bit  access                  */
-  uint8_t reg;                 /*!< Type      used for register access              */
+    struct {
+        uint8_t USB_ATTACH : 1;
+        uint8_t RESET : 1;
+        uint8_t INTF_PWRDN : 1;
+        uint8_t : 5;
+    } bit;       /*!< Structure used for bit  access                  */
+    uint8_t reg; /*!< Type      used for register access              */
 } USB2422_STCD_Type;
 #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */
 
 /** \brief USB2422 device hardware registers */
 #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__))
 typedef struct {
-  USB2422_VID_Type          VID;        /**< \brief Offset: 0x00*/
-  USB2422_PID_Type          PID;        /**< \brief Offset: 0x02*/
-  USB2422_DID_Type          DID;        /**< \brief Offset: 0x04*/
-  USB2422_CFG1_Type         CFG1;       /**< \brief Offset: 0x06*/
-  USB2422_CFG2_Type         CFG2;       /**< \brief Offset: 0x07*/
-  USB2422_CFG3_Type         CFG3;       /**< \brief Offset: 0x08*/
-  USB2422_NRD_Type          NRD;        /**< \brief Offset: 0x09*/
-  USB2422_PDS_Type          PDS;        /**< \brief Offset: 0x0A*/
-  USB2422_PDB_Type          PDB;        /**< \brief Offset: 0x0B*/
-  USB2422_MAXPS_Type        MAXPS;      /**< \brief Offset: 0x0C*/
-  USB2422_MAXPB_Type        MAXPB;      /**< \brief Offset: 0x0D*/
-  USB2422_HCMCS_Type        HCMCS;      /**< \brief Offset: 0x0E*/
-  USB2422_HCMCB_Type        HCMCB;      /**< \brief Offset: 0x0F*/
-  USB2422_PWRT_Type         PWRT;       /**< \brief Offset: 0x10*/
-  USB2422_LANGID_LSB_Type   LANGID_LSB; /**< \brief Offset: 0x11*/
-  USB2422_LANGID_MSB_Type   LANGID_MSB; /**< \brief Offset: 0x12*/
-  USB2422_MFRSL_Type        MFRSL;      /**< \brief Offset: 0x13*/
-  USB2422_PRDSL_Type        PRDSL;      /**< \brief Offset: 0x14*/
-  USB2422_SERSL_Type        SERSL;      /**< \brief Offset: 0x15*/
-  USB2422_MFRSTR_Type       MFRSTR[31]; /**< \brief Offset: 0x16*/
-  USB2422_PRDSTR_Type       PRDSTR[31]; /**< \brief Offset: 0x54*/
-  USB2422_SERSTR_Type       SERSTR[31]; /**< \brief Offset: 0x92*/
-  USB2422_BCEN_Type         BCEN;       /**< \brief Offset: 0xD0*/
-  uint8_t                   Reserved1[0x25];
-  USB2422_BOOSTUP_Type      BOOSTUP;    /**< \brief Offset: 0xF6*/
-  uint8_t                   Reserved2[0x1];
-  USB2422_BOOSTDOWN_Type    BOOSTDOWN;  /**< \brief Offset: 0xF8*/
-  uint8_t                   Reserved3[0x1];
-  USB2422_PRTSP_Type        PRTSP;      /**< \brief Offset: 0xFA*/
-  USB2422_PRTR12_Type       PRTR12;     /**< \brief Offset: 0xFB*/
-  uint8_t                   Reserved4[0x3];
-  USB2422_STCD_Type         STCD;       /**< \brief Offset: 0xFF*/
+    USB2422_VID_Type        VID;        /**< \brief Offset: 0x00*/
+    USB2422_PID_Type        PID;        /**< \brief Offset: 0x02*/
+    USB2422_DID_Type        DID;        /**< \brief Offset: 0x04*/
+    USB2422_CFG1_Type       CFG1;       /**< \brief Offset: 0x06*/
+    USB2422_CFG2_Type       CFG2;       /**< \brief Offset: 0x07*/
+    USB2422_CFG3_Type       CFG3;       /**< \brief Offset: 0x08*/
+    USB2422_NRD_Type        NRD;        /**< \brief Offset: 0x09*/
+    USB2422_PDS_Type        PDS;        /**< \brief Offset: 0x0A*/
+    USB2422_PDB_Type        PDB;        /**< \brief Offset: 0x0B*/
+    USB2422_MAXPS_Type      MAXPS;      /**< \brief Offset: 0x0C*/
+    USB2422_MAXPB_Type      MAXPB;      /**< \brief Offset: 0x0D*/
+    USB2422_HCMCS_Type      HCMCS;      /**< \brief Offset: 0x0E*/
+    USB2422_HCMCB_Type      HCMCB;      /**< \brief Offset: 0x0F*/
+    USB2422_PWRT_Type       PWRT;       /**< \brief Offset: 0x10*/
+    USB2422_LANGID_LSB_Type LANGID_LSB; /**< \brief Offset: 0x11*/
+    USB2422_LANGID_MSB_Type LANGID_MSB; /**< \brief Offset: 0x12*/
+    USB2422_MFRSL_Type      MFRSL;      /**< \brief Offset: 0x13*/
+    USB2422_PRDSL_Type      PRDSL;      /**< \brief Offset: 0x14*/
+    USB2422_SERSL_Type      SERSL;      /**< \brief Offset: 0x15*/
+    USB2422_MFRSTR_Type     MFRSTR[31]; /**< \brief Offset: 0x16*/
+    USB2422_PRDSTR_Type     PRDSTR[31]; /**< \brief Offset: 0x54*/
+    USB2422_SERSTR_Type     SERSTR[31]; /**< \brief Offset: 0x92*/
+    USB2422_BCEN_Type       BCEN;       /**< \brief Offset: 0xD0*/
+    uint8_t                 Reserved1[0x25];
+    USB2422_BOOSTUP_Type    BOOSTUP; /**< \brief Offset: 0xF6*/
+    uint8_t                 Reserved2[0x1];
+    USB2422_BOOSTDOWN_Type  BOOSTDOWN; /**< \brief Offset: 0xF8*/
+    uint8_t                 Reserved3[0x1];
+    USB2422_PRTSP_Type      PRTSP;  /**< \brief Offset: 0xFA*/
+    USB2422_PRTR12_Type     PRTR12; /**< \brief Offset: 0xFB*/
+    uint8_t                 Reserved4[0x3];
+    USB2422_STCD_Type       STCD; /**< \brief Offset: 0xFF*/
 } Usb2422;
 #endif
 
-#define PORT_DETECT_RETRY_INTERVAL      2000
+#define PORT_DETECT_RETRY_INTERVAL 2000
 
-#define USB_EXTRA_ADC_THRESHOLD         900
+#define USB_EXTRA_ADC_THRESHOLD 900
 
-#define USB_EXTRA_STATE_DISABLED                0
-#define USB_EXTRA_STATE_ENABLED                 1
-#define USB_EXTRA_STATE_UNKNOWN                 2
-#define USB_EXTRA_STATE_DISABLED_UNTIL_REPLUG   3
+#define USB_EXTRA_STATE_DISABLED 0
+#define USB_EXTRA_STATE_ENABLED 1
+#define USB_EXTRA_STATE_UNKNOWN 2
+#define USB_EXTRA_STATE_DISABLED_UNTIL_REPLUG 3
 
-#define USB_HOST_PORT_1             0
-#define USB_HOST_PORT_2             1
-#define USB_HOST_PORT_UNKNOWN       2
+#define USB_HOST_PORT_1 0
+#define USB_HOST_PORT_2 1
+#define USB_HOST_PORT_UNKNOWN 2
 
 extern uint8_t usb_host_port;
 extern uint8_t usb_extra_state;
 extern uint8_t usb_extra_manual;
 extern uint8_t usb_gcr_auto;
 
-void USB2422_init(void);
-void USB_reset(void);
-void USB_configure(void);
+void     USB2422_init(void);
+void     USB_reset(void);
+void     USB_configure(void);
 uint16_t USB_active(void);
-void USB_set_host_by_voltage(void);
+void     USB_set_host_by_voltage(void);
 uint16_t adc_get(uint8_t muxpos);
-uint8_t USB2422_Port_Detect_Init(void);
-void USB_HandleExtraDevice(void);
-void USB_ExtraSetState(uint8_t state);
-
-#endif //_USB2422_H_
+uint8_t  USB2422_Port_Detect_Init(void);
+void     USB_HandleExtraDevice(void);
+void     USB_ExtraSetState(uint8_t state);
 
+#endif  //_USB2422_H_
diff --git a/tmk_core/protocol/arm_atsam/usb/usb_atmel.h b/tmk_core/protocol/arm_atsam/usb/usb_atmel.h
index 7febdc9ec..1cef70378 100644
--- a/tmk_core/protocol/arm_atsam/usb/usb_atmel.h
+++ b/tmk_core/protocol/arm_atsam/usb/usb_atmel.h
@@ -67,118 +67,118 @@
  */
 
 //! \name Vendor Identifier assigned by USB org to ATMEL
-#define  USB_VID_ATMEL                             0x03EB
+#define USB_VID_ATMEL 0x03EB
 
 //! \name Product Identifier assigned by ATMEL to AVR applications
 //! @{
 
 //! \name The range from 2000h to 20FFh is reserved to the old PID for C51, MEGA, and others.
 //! @{
-#define  USB_PID_ATMEL_MEGA_HIDGENERIC             0x2013
-#define  USB_PID_ATMEL_MEGA_HIDKEYBOARD            0x2017
-#define  USB_PID_ATMEL_MEGA_CDC                    0x2018
-#define  USB_PID_ATMEL_MEGA_AUDIO_IN               0x2019
-#define  USB_PID_ATMEL_MEGA_MS                     0x201A
-#define  USB_PID_ATMEL_MEGA_AUDIO_IN_OUT           0x201B
-#define  USB_PID_ATMEL_MEGA_HIDMOUSE               0x201C
-#define  USB_PID_ATMEL_MEGA_HIDMOUSE_CERTIF_U4     0x201D
-#define  USB_PID_ATMEL_MEGA_CDC_MULTI              0x201E
-#define  USB_PID_ATMEL_MEGA_MS_HIDMS_HID_USBKEY    0x2022
-#define  USB_PID_ATMEL_MEGA_MS_HIDMS_HID_STK525    0x2023
-#define  USB_PID_ATMEL_MEGA_MS_2                   0x2029
-#define  USB_PID_ATMEL_MEGA_MS_HIDMS               0x202A
-#define  USB_PID_ATMEL_MEGA_MS_3                   0x2032
-#define  USB_PID_ATMEL_MEGA_LIBUSB                 0x2050
+#define USB_PID_ATMEL_MEGA_HIDGENERIC 0x2013
+#define USB_PID_ATMEL_MEGA_HIDKEYBOARD 0x2017
+#define USB_PID_ATMEL_MEGA_CDC 0x2018
+#define USB_PID_ATMEL_MEGA_AUDIO_IN 0x2019
+#define USB_PID_ATMEL_MEGA_MS 0x201A
+#define USB_PID_ATMEL_MEGA_AUDIO_IN_OUT 0x201B
+#define USB_PID_ATMEL_MEGA_HIDMOUSE 0x201C
+#define USB_PID_ATMEL_MEGA_HIDMOUSE_CERTIF_U4 0x201D
+#define USB_PID_ATMEL_MEGA_CDC_MULTI 0x201E
+#define USB_PID_ATMEL_MEGA_MS_HIDMS_HID_USBKEY 0x2022
+#define USB_PID_ATMEL_MEGA_MS_HIDMS_HID_STK525 0x2023
+#define USB_PID_ATMEL_MEGA_MS_2 0x2029
+#define USB_PID_ATMEL_MEGA_MS_HIDMS 0x202A
+#define USB_PID_ATMEL_MEGA_MS_3 0x2032
+#define USB_PID_ATMEL_MEGA_LIBUSB 0x2050
 //! @}
 
 //! \name The range 2100h to 21FFh is reserved to PIDs for AVR Tools.
 //! @{
-#define  USB_PID_ATMEL_XPLAINED                    0x2122
-#define  USB_PID_ATMEL_XMEGA_USB_ZIGBIT_2_4GHZ     0x214A
-#define  USB_PID_ATMEL_XMEGA_USB_ZIGBIT_SUBGHZ     0x214B
+#define USB_PID_ATMEL_XPLAINED 0x2122
+#define USB_PID_ATMEL_XMEGA_USB_ZIGBIT_2_4GHZ 0x214A
+#define USB_PID_ATMEL_XMEGA_USB_ZIGBIT_SUBGHZ 0x214B
 //! @}
 
 //! \name The range 2300h to 23FFh is reserved to PIDs for demo from ASF1.7=>
 //! @{
-#define  USB_PID_ATMEL_UC3_ENUM                    0x2300
-#define  USB_PID_ATMEL_UC3_MS                      0x2301
-#define  USB_PID_ATMEL_UC3_MS_SDRAM_LOADER         0x2302
-#define  USB_PID_ATMEL_UC3_EVK1100_CTRLPANEL       0x2303
-#define  USB_PID_ATMEL_UC3_HID                     0x2304
-#define  USB_PID_ATMEL_UC3_EVK1101_CTRLPANEL_HID   0x2305
-#define  USB_PID_ATMEL_UC3_EVK1101_CTRLPANEL_HID_MS 0x2306
-#define  USB_PID_ATMEL_UC3_CDC                     0x2307
-#define  USB_PID_ATMEL_UC3_AUDIO_MICRO             0x2308
-#define  USB_PID_ATMEL_UC3_CDC_DEBUG               0x2310 // Virtual Com (debug interface) on EVK11xx
-#define  USB_PID_ATMEL_UC3_AUDIO_SPEAKER_MICRO     0x2311
-#define  USB_PID_ATMEL_UC3_CDC_MSC                 0x2312
+#define USB_PID_ATMEL_UC3_ENUM 0x2300
+#define USB_PID_ATMEL_UC3_MS 0x2301
+#define USB_PID_ATMEL_UC3_MS_SDRAM_LOADER 0x2302
+#define USB_PID_ATMEL_UC3_EVK1100_CTRLPANEL 0x2303
+#define USB_PID_ATMEL_UC3_HID 0x2304
+#define USB_PID_ATMEL_UC3_EVK1101_CTRLPANEL_HID 0x2305
+#define USB_PID_ATMEL_UC3_EVK1101_CTRLPANEL_HID_MS 0x2306
+#define USB_PID_ATMEL_UC3_CDC 0x2307
+#define USB_PID_ATMEL_UC3_AUDIO_MICRO 0x2308
+#define USB_PID_ATMEL_UC3_CDC_DEBUG 0x2310  // Virtual Com (debug interface) on EVK11xx
+#define USB_PID_ATMEL_UC3_AUDIO_SPEAKER_MICRO 0x2311
+#define USB_PID_ATMEL_UC3_CDC_MSC 0x2312
 //! @}
 
 //! \name The range 2400h to 24FFh is reserved to PIDs for ASF applications
 //! @{
-#define  USB_PID_ATMEL_ASF_HIDMOUSE                0x2400
-#define  USB_PID_ATMEL_ASF_HIDKEYBOARD             0x2401
-#define  USB_PID_ATMEL_ASF_HIDGENERIC              0x2402
-#define  USB_PID_ATMEL_ASF_MSC                     0x2403
-#define  USB_PID_ATMEL_ASF_CDC                     0x2404
-#define  USB_PID_ATMEL_ASF_PHDC                    0x2405
-#define  USB_PID_ATMEL_ASF_HIDMTOUCH               0x2406
-#define  USB_PID_ATMEL_ASF_MSC_HIDMOUSE            0x2420
-#define  USB_PID_ATMEL_ASF_MSC_HIDS_CDC            0x2421
-#define  USB_PID_ATMEL_ASF_MSC_HIDKEYBOARD         0x2422
-#define  USB_PID_ATMEL_ASF_VENDOR_CLASS            0x2423
-#define  USB_PID_ATMEL_ASF_MSC_CDC                 0x2424
-#define  USB_PID_ATMEL_ASF_TWO_CDC                 0x2425
-#define  USB_PID_ATMEL_ASF_SEVEN_CDC               0x2426
-#define  USB_PID_ATMEL_ASF_XPLAIN_BC_POWERONLY     0x2430
-#define  USB_PID_ATMEL_ASF_XPLAIN_BC_TERMINAL      0x2431
-#define  USB_PID_ATMEL_ASF_XPLAIN_BC_TOUCH         0x2432
-#define  USB_PID_ATMEL_ASF_AUDIO_SPEAKER           0x2433
-#define  USB_PID_ATMEL_ASF_XMEGA_B1_XPLAINED       0x2434
+#define USB_PID_ATMEL_ASF_HIDMOUSE 0x2400
+#define USB_PID_ATMEL_ASF_HIDKEYBOARD 0x2401
+#define USB_PID_ATMEL_ASF_HIDGENERIC 0x2402
+#define USB_PID_ATMEL_ASF_MSC 0x2403
+#define USB_PID_ATMEL_ASF_CDC 0x2404
+#define USB_PID_ATMEL_ASF_PHDC 0x2405
+#define USB_PID_ATMEL_ASF_HIDMTOUCH 0x2406
+#define USB_PID_ATMEL_ASF_MSC_HIDMOUSE 0x2420
+#define USB_PID_ATMEL_ASF_MSC_HIDS_CDC 0x2421
+#define USB_PID_ATMEL_ASF_MSC_HIDKEYBOARD 0x2422
+#define USB_PID_ATMEL_ASF_VENDOR_CLASS 0x2423
+#define USB_PID_ATMEL_ASF_MSC_CDC 0x2424
+#define USB_PID_ATMEL_ASF_TWO_CDC 0x2425
+#define USB_PID_ATMEL_ASF_SEVEN_CDC 0x2426
+#define USB_PID_ATMEL_ASF_XPLAIN_BC_POWERONLY 0x2430
+#define USB_PID_ATMEL_ASF_XPLAIN_BC_TERMINAL 0x2431
+#define USB_PID_ATMEL_ASF_XPLAIN_BC_TOUCH 0x2432
+#define USB_PID_ATMEL_ASF_AUDIO_SPEAKER 0x2433
+#define USB_PID_ATMEL_ASF_XMEGA_B1_XPLAINED 0x2434
 //! @}
 
 //! \name The range 2F00h to 2FFFh is reserved to official PIDs for AVR bootloaders
 //! Note, !!!! don't use this range for demos or examples !!!!
 //! @{
-#define  USB_PID_ATMEL_DFU_ATXMEGA64C3             0x2FD6
-#define  USB_PID_ATMEL_DFU_ATXMEGA128C3            0x2FD7
-#define  USB_PID_ATMEL_DFU_ATXMEGA16C4             0x2FD8
-#define  USB_PID_ATMEL_DFU_ATXMEGA32C4             0x2FD9
-#define  USB_PID_ATMEL_DFU_ATXMEGA256C3            0x2FDA
-#define  USB_PID_ATMEL_DFU_ATXMEGA384C3            0x2FDB
-#define  USB_PID_ATMEL_DFU_ATUCL3_L4               0x2FDC
-#define  USB_PID_ATMEL_DFU_ATXMEGA64A4U            0x2FDD
-#define  USB_PID_ATMEL_DFU_ATXMEGA128A4U           0x2FDE
-
-#define  USB_PID_ATMEL_DFU_ATXMEGA64B3             0x2FDF
-#define  USB_PID_ATMEL_DFU_ATXMEGA128B3            0x2FE0
-#define  USB_PID_ATMEL_DFU_ATXMEGA64B1             0x2FE1
-#define  USB_PID_ATMEL_DFU_ATXMEGA256A3BU          0x2FE2
-#define  USB_PID_ATMEL_DFU_ATXMEGA16A4U            0x2FE3
-#define  USB_PID_ATMEL_DFU_ATXMEGA32A4U            0x2FE4
-#define  USB_PID_ATMEL_DFU_ATXMEGA64A3U            0x2FE5
-#define  USB_PID_ATMEL_DFU_ATXMEGA128A3U           0x2FE6
-#define  USB_PID_ATMEL_DFU_ATXMEGA192A3U           0x2FE7
-#define  USB_PID_ATMEL_DFU_ATXMEGA64A1U            0x2FE8
-#define  USB_PID_ATMEL_DFU_ATUC3D                  0x2FE9
-#define  USB_PID_ATMEL_DFU_ATXMEGA128B1            0x2FEA
-#define  USB_PID_ATMEL_DFU_AT32UC3C                0x2FEB
-#define  USB_PID_ATMEL_DFU_ATXMEGA256A3U           0x2FEC
-#define  USB_PID_ATMEL_DFU_ATXMEGA128A1U           0x2FED
-#define  USB_PID_ATMEL_DFU_ATMEGA8U2               0x2FEE
-#define  USB_PID_ATMEL_DFU_ATMEGA16U2              0x2FEF
-#define  USB_PID_ATMEL_DFU_ATMEGA32U2              0x2FF0
-#define  USB_PID_ATMEL_DFU_AT32UC3A3               0x2FF1
-#define  USB_PID_ATMEL_DFU_ATMEGA32U6              0x2FF2
-#define  USB_PID_ATMEL_DFU_ATMEGA16U4              0x2FF3
-#define  USB_PID_ATMEL_DFU_ATMEGA32U4              0x2FF4
-#define  USB_PID_ATMEL_DFU_AT32AP7200              0x2FF5
-#define  USB_PID_ATMEL_DFU_AT32UC3B                0x2FF6
-#define  USB_PID_ATMEL_DFU_AT90USB82               0x2FF7
-#define  USB_PID_ATMEL_DFU_AT32UC3A                0x2FF8
-#define  USB_PID_ATMEL_DFU_AT90USB64               0x2FF9
-#define  USB_PID_ATMEL_DFU_AT90USB162              0x2FFA
-#define  USB_PID_ATMEL_DFU_AT90USB128              0x2FFB
+#define USB_PID_ATMEL_DFU_ATXMEGA64C3 0x2FD6
+#define USB_PID_ATMEL_DFU_ATXMEGA128C3 0x2FD7
+#define USB_PID_ATMEL_DFU_ATXMEGA16C4 0x2FD8
+#define USB_PID_ATMEL_DFU_ATXMEGA32C4 0x2FD9
+#define USB_PID_ATMEL_DFU_ATXMEGA256C3 0x2FDA
+#define USB_PID_ATMEL_DFU_ATXMEGA384C3 0x2FDB
+#define USB_PID_ATMEL_DFU_ATUCL3_L4 0x2FDC
+#define USB_PID_ATMEL_DFU_ATXMEGA64A4U 0x2FDD
+#define USB_PID_ATMEL_DFU_ATXMEGA128A4U 0x2FDE
+
+#define USB_PID_ATMEL_DFU_ATXMEGA64B3 0x2FDF
+#define USB_PID_ATMEL_DFU_ATXMEGA128B3 0x2FE0
+#define USB_PID_ATMEL_DFU_ATXMEGA64B1 0x2FE1
+#define USB_PID_ATMEL_DFU_ATXMEGA256A3BU 0x2FE2
+#define USB_PID_ATMEL_DFU_ATXMEGA16A4U 0x2FE3
+#define USB_PID_ATMEL_DFU_ATXMEGA32A4U 0x2FE4
+#define USB_PID_ATMEL_DFU_ATXMEGA64A3U 0x2FE5
+#define USB_PID_ATMEL_DFU_ATXMEGA128A3U 0x2FE6
+#define USB_PID_ATMEL_DFU_ATXMEGA192A3U 0x2FE7
+#define USB_PID_ATMEL_DFU_ATXMEGA64A1U 0x2FE8
+#define USB_PID_ATMEL_DFU_ATUC3D 0x2FE9
+#define USB_PID_ATMEL_DFU_ATXMEGA128B1 0x2FEA
+#define USB_PID_ATMEL_DFU_AT32UC3C 0x2FEB
+#define USB_PID_ATMEL_DFU_ATXMEGA256A3U 0x2FEC
+#define USB_PID_ATMEL_DFU_ATXMEGA128A1U 0x2FED
+#define USB_PID_ATMEL_DFU_ATMEGA8U2 0x2FEE
+#define USB_PID_ATMEL_DFU_ATMEGA16U2 0x2FEF
+#define USB_PID_ATMEL_DFU_ATMEGA32U2 0x2FF0
+#define USB_PID_ATMEL_DFU_AT32UC3A3 0x2FF1
+#define USB_PID_ATMEL_DFU_ATMEGA32U6 0x2FF2
+#define USB_PID_ATMEL_DFU_ATMEGA16U4 0x2FF3
+#define USB_PID_ATMEL_DFU_ATMEGA32U4 0x2FF4
+#define USB_PID_ATMEL_DFU_AT32AP7200 0x2FF5
+#define USB_PID_ATMEL_DFU_AT32UC3B 0x2FF6
+#define USB_PID_ATMEL_DFU_AT90USB82 0x2FF7
+#define USB_PID_ATMEL_DFU_AT32UC3A 0x2FF8
+#define USB_PID_ATMEL_DFU_AT90USB64 0x2FF9
+#define USB_PID_ATMEL_DFU_AT90USB162 0x2FFA
+#define USB_PID_ATMEL_DFU_AT90USB128 0x2FFB
 // 2FFCh to 2FFFh used by C51 family products
 //! @}
 
@@ -186,5 +186,4 @@
 
 //! @}
 
-
-#endif // _USB_ATMEL_H_
+#endif  // _USB_ATMEL_H_
diff --git a/tmk_core/protocol/arm_atsam/usb/usb_device_udd.c b/tmk_core/protocol/arm_atsam/usb/usb_device_udd.c
index b31256df7..f138b4278 100644
--- a/tmk_core/protocol/arm_atsam/usb/usb_device_udd.c
+++ b/tmk_core/protocol/arm_atsam/usb/usb_device_udd.c
@@ -61,30 +61,30 @@
  */
 // Check USB device configuration
 #ifdef USB_DEVICE_HS_SUPPORT
-#  error The High speed mode is not supported on this part, please remove USB_DEVICE_HS_SUPPORT in conf_usb.h
+#    error The High speed mode is not supported on this part, please remove USB_DEVICE_HS_SUPPORT in conf_usb.h
 #endif
 
-//Note: This driver is adapted for SAMD51
+// Note: This driver is adapted for SAMD51
 
 #ifndef UDC_REMOTEWAKEUP_LPM_ENABLE
-#define UDC_REMOTEWAKEUP_LPM_ENABLE()
+#    define UDC_REMOTEWAKEUP_LPM_ENABLE()
 #endif
 #ifndef UDC_REMOTEWAKEUP_LPM_DISABLE
-#define UDC_REMOTEWAKEUP_LPM_DISABLE()
+#    define UDC_REMOTEWAKEUP_LPM_DISABLE()
 #endif
 #ifndef UDC_SUSPEND_LPM_EVENT
-#define UDC_SUSPEND_LPM_EVENT()
+#    define UDC_SUSPEND_LPM_EVENT()
 #endif
 
 /* for debug text */
 #ifdef USB_DEBUG
-#   define dbg_print printf
+#    define dbg_print printf
 #else
-#   define dbg_print(...)
+#    define dbg_print(...)
 #endif
 
 /** Maximum size of a transfer in multi-packet mode */
-#define UDD_ENDPOINT_MAX_TRANS ((8*1024)-1)
+#define UDD_ENDPOINT_MAX_TRANS ((8 * 1024) - 1)
 
 /** USB software device instance structure */
 struct usb_module usb_device;
@@ -97,10 +97,7 @@ struct usb_module usb_device;
 
 #define UDD_CLOCK_GEN 0
 
-static inline void udd_wait_clock_ready(void)
-{
-
-}
+static inline void udd_wait_clock_ready(void) {}
 
 /**
  * \name Power management
@@ -130,12 +127,12 @@ uint8_t udd_ctrl_buffer[USB_DEVICE_EP_CTRL_SIZE];
 
 /** Bit definitions about endpoint control state machine for udd_ep_control_state */
 typedef enum {
-    UDD_EPCTRL_SETUP                  = 0, //!< Wait a SETUP packet
-    UDD_EPCTRL_DATA_OUT               = 1, //!< Wait a OUT data packet
-    UDD_EPCTRL_DATA_IN                = 2, //!< Wait a IN data packet
-    UDD_EPCTRL_HANDSHAKE_WAIT_IN_ZLP  = 3, //!< Wait a IN ZLP packet
-    UDD_EPCTRL_HANDSHAKE_WAIT_OUT_ZLP = 4, //!< Wait a OUT ZLP packet
-    UDD_EPCTRL_STALL_REQ              = 5, //!< STALL enabled on IN & OUT packet
+    UDD_EPCTRL_SETUP                  = 0,  //!< Wait a SETUP packet
+    UDD_EPCTRL_DATA_OUT               = 1,  //!< Wait a OUT data packet
+    UDD_EPCTRL_DATA_IN                = 2,  //!< Wait a IN data packet
+    UDD_EPCTRL_HANDSHAKE_WAIT_IN_ZLP  = 3,  //!< Wait a IN ZLP packet
+    UDD_EPCTRL_HANDSHAKE_WAIT_OUT_ZLP = 4,  //!< Wait a OUT ZLP packet
+    UDD_EPCTRL_STALL_REQ              = 5,  //!< STALL enabled on IN & OUT packet
 } udd_ctrl_ep_state_t;
 
 /** Global variable to give and record information of the set up request management */
@@ -200,11 +197,11 @@ typedef struct {
     //! Endpoint size
     uint16_t ep_size;
     //! A job is registered on this endpoint
-    uint8_t busy:1;
+    uint8_t busy : 1;
     //! A short packet is requested for this job on endpoint IN
-    uint8_t b_shortpacket:1;
+    uint8_t b_shortpacket : 1;
     //! The cache buffer is currently used on endpoint OUT
-    uint8_t b_use_out_cache_buffer:1;
+    uint8_t b_use_out_cache_buffer : 1;
 } udd_ep_job_t;
 
 /** Array to register a job on bulk/interrupt/isochronous endpoint */
@@ -217,8 +214,7 @@ static udd_ep_job_t udd_ep_job[2 * USB_DEVICE_MAX_EP];
  * \param[in] ep  Endpoint Address
  * \retval    pointer to an udd_ep_job_t structure instance
  */
-static udd_ep_job_t* udd_ep_get_job(udd_ep_id_t ep)
-{
+static udd_ep_job_t *udd_ep_get_job(udd_ep_id_t ep) {
     if ((ep == 0) || (ep == 0x80)) {
         return NULL;
     } else {
@@ -230,17 +226,16 @@ static udd_ep_job_t* udd_ep_get_job(udd_ep_id_t ep)
  * \brief     Endpoint IN process, continue to send packets or zero length packet
  * \param[in] pointer Pointer to the endpoint transfer status parameter struct from driver layer.
  */
-static void udd_ep_trans_in_next(void* pointer)
-{
-    struct usb_endpoint_callback_parameter *ep_callback_para = (struct usb_endpoint_callback_parameter*)pointer;
-    udd_ep_id_t ep = ep_callback_para->endpoint_address;
-    uint16_t ep_size, nb_trans;
-    uint16_t next_trans;
-    udd_ep_id_t ep_num;
-    udd_ep_job_t *ptr_job;
+static void udd_ep_trans_in_next(void *pointer) {
+    struct usb_endpoint_callback_parameter *ep_callback_para = (struct usb_endpoint_callback_parameter *)pointer;
+    udd_ep_id_t                             ep               = ep_callback_para->endpoint_address;
+    uint16_t                                ep_size, nb_trans;
+    uint16_t                                next_trans;
+    udd_ep_id_t                             ep_num;
+    udd_ep_job_t *                          ptr_job;
 
     ptr_job = udd_ep_get_job(ep);
-    ep_num = ep & USB_EP_ADDR_MASK;
+    ep_num  = ep & USB_EP_ADDR_MASK;
 
     ep_size = ptr_job->ep_size;
     /* Update number of data transferred */
@@ -251,13 +246,13 @@ static void udd_ep_trans_in_next(void* pointer)
     if (ptr_job->nb_trans != ptr_job->buf_size) {
         next_trans = ptr_job->buf_size - ptr_job->nb_trans;
         if (UDD_ENDPOINT_MAX_TRANS < next_trans) {
-        /* The USB hardware support a maximum
-         * transfer size of UDD_ENDPOINT_MAX_TRANS Bytes */
-            next_trans = UDD_ENDPOINT_MAX_TRANS -(UDD_ENDPOINT_MAX_TRANS % ep_size);
+            /* The USB hardware support a maximum
+             * transfer size of UDD_ENDPOINT_MAX_TRANS Bytes */
+            next_trans = UDD_ENDPOINT_MAX_TRANS - (UDD_ENDPOINT_MAX_TRANS % ep_size);
         }
         /* Need ZLP, if requested and last packet is not a short packet */
         ptr_job->b_shortpacket = ptr_job->b_shortpacket && (0 == (next_trans % ep_size));
-        usb_device_endpoint_write_buffer_job(&usb_device,ep_num,&ptr_job->buf[ptr_job->nb_trans],next_trans);
+        usb_device_endpoint_write_buffer_job(&usb_device, ep_num, &ptr_job->buf[ptr_job->nb_trans], next_trans);
         return;
     }
 
@@ -265,7 +260,7 @@ static void udd_ep_trans_in_next(void* pointer)
     if (ptr_job->b_shortpacket) {
         ptr_job->b_shortpacket = false;
         /* Start new transfer */
-        usb_device_endpoint_write_buffer_job(&usb_device,ep_num,&ptr_job->buf[ptr_job->nb_trans],0);
+        usb_device_endpoint_write_buffer_job(&usb_device, ep_num, &ptr_job->buf[ptr_job->nb_trans], 0);
         return;
     }
 
@@ -280,17 +275,16 @@ static void udd_ep_trans_in_next(void* pointer)
  * \brief     Endpoint OUT process, continue to receive packets or zero length packet
  * \param[in] pointer Pointer to the endpoint transfer status parameter struct from driver layer.
  */
-static void udd_ep_trans_out_next(void* pointer)
-{
-    struct usb_endpoint_callback_parameter *ep_callback_para = (struct usb_endpoint_callback_parameter*)pointer;
-    udd_ep_id_t ep = ep_callback_para->endpoint_address;
-    uint16_t ep_size, nb_trans;
-    uint16_t next_trans;
-    udd_ep_id_t ep_num;
-    udd_ep_job_t *ptr_job;
+static void udd_ep_trans_out_next(void *pointer) {
+    struct usb_endpoint_callback_parameter *ep_callback_para = (struct usb_endpoint_callback_parameter *)pointer;
+    udd_ep_id_t                             ep               = ep_callback_para->endpoint_address;
+    uint16_t                                ep_size, nb_trans;
+    uint16_t                                next_trans;
+    udd_ep_id_t                             ep_num;
+    udd_ep_job_t *                          ptr_job;
 
     ptr_job = udd_ep_get_job(ep);
-    ep_num = ep & USB_EP_ADDR_MASK;
+    ep_num  = ep & USB_EP_ADDR_MASK;
 
     ep_size = ptr_job->ep_size;
     /* Update number of data transferred */
@@ -312,9 +306,9 @@ static void udd_ep_trans_out_next(void* pointer)
     if ((nb_trans == ep_callback_para->out_buffer_size) && (ptr_job->nb_trans != ptr_job->buf_size)) {
         next_trans = ptr_job->buf_size - ptr_job->nb_trans;
         if (UDD_ENDPOINT_MAX_TRANS < next_trans) {
-        /* The USB hardware support a maximum transfer size
-         * of UDD_ENDPOINT_MAX_TRANS Bytes */
-        next_trans = UDD_ENDPOINT_MAX_TRANS - (UDD_ENDPOINT_MAX_TRANS % ep_size);
+            /* The USB hardware support a maximum transfer size
+             * of UDD_ENDPOINT_MAX_TRANS Bytes */
+            next_trans = UDD_ENDPOINT_MAX_TRANS - (UDD_ENDPOINT_MAX_TRANS % ep_size);
         } else {
             next_trans -= next_trans % ep_size;
         }
@@ -322,9 +316,9 @@ static void udd_ep_trans_out_next(void* pointer)
         if (next_trans < ep_size) {
             /* Use the cache buffer for Bulk or Interrupt size endpoint */
             ptr_job->b_use_out_cache_buffer = true;
-            usb_device_endpoint_read_buffer_job(&usb_device,ep_num,udd_ep_out_cache_buffer[ep_num - 1],ep_size);
+            usb_device_endpoint_read_buffer_job(&usb_device, ep_num, udd_ep_out_cache_buffer[ep_num - 1], ep_size);
         } else {
-            usb_device_endpoint_read_buffer_job(&usb_device,ep_num,&ptr_job->buf[ptr_job->nb_trans],next_trans);
+            usb_device_endpoint_read_buffer_job(&usb_device, ep_num, &ptr_job->buf[ptr_job->nb_trans], next_trans);
         }
         return;
     }
@@ -341,10 +335,9 @@ static void udd_ep_trans_out_next(void* pointer)
  * \param[in] module_inst Pointer to USB module instance
  * \param[in] pointer Pointer to the endpoint transfer status parameter struct from driver layer.
  */
-static void udd_ep_transfer_process(struct usb_module *module_inst, void* pointer)
-{
-    struct usb_endpoint_callback_parameter *ep_callback_para = (struct usb_endpoint_callback_parameter*)pointer;
-    udd_ep_id_t ep = ep_callback_para->endpoint_address;
+static void udd_ep_transfer_process(struct usb_module *module_inst, void *pointer) {
+    struct usb_endpoint_callback_parameter *ep_callback_para = (struct usb_endpoint_callback_parameter *)pointer;
+    udd_ep_id_t                             ep               = ep_callback_para->endpoint_address;
 
     if (ep & USB_EP_DIR_IN) {
         udd_ep_trans_in_next(pointer);
@@ -353,8 +346,7 @@ static void udd_ep_transfer_process(struct usb_module *module_inst, void* pointe
     }
 }
 
-void udd_ep_abort(udd_ep_id_t ep)
-{
+void udd_ep_abort(udd_ep_id_t ep) {
     udd_ep_job_t *ptr_job;
 
     usb_device_endpoint_abort_job(&usb_device, ep);
@@ -371,23 +363,13 @@ void udd_ep_abort(udd_ep_id_t ep)
     }
 }
 
-bool udd_is_high_speed(void)
-{
-    return false;
-}
+bool udd_is_high_speed(void) { return false; }
 
-uint16_t udd_get_frame_number(void)
-{
-    return usb_device_get_frame_number(&usb_device);
-}
+uint16_t udd_get_frame_number(void) { return usb_device_get_frame_number(&usb_device); }
 
-uint16_t udd_get_micro_frame_number(void)
-{
-    return usb_device_get_micro_frame_number(&usb_device);
-}
+uint16_t udd_get_micro_frame_number(void) { return usb_device_get_micro_frame_number(&usb_device); }
 
-void udd_ep_free(udd_ep_id_t ep)
-{
+void udd_ep_free(udd_ep_id_t ep) {
     struct usb_device_endpoint_config config_ep;
     usb_device_endpoint_get_config_defaults(&config_ep);
 
@@ -395,45 +377,44 @@ void udd_ep_free(udd_ep_id_t ep)
     udd_ep_abort(ep);
 
     config_ep.ep_address = ep;
-    config_ep.ep_type = USB_DEVICE_ENDPOINT_TYPE_DISABLE;
+    config_ep.ep_type    = USB_DEVICE_ENDPOINT_TYPE_DISABLE;
     usb_device_endpoint_set_config(&usb_device, &config_ep);
-    usb_device_endpoint_unregister_callback(&usb_device,ep_num,USB_DEVICE_ENDPOINT_CALLBACK_TRCPT);
-    usb_device_endpoint_disable_callback(&usb_device,ep,USB_DEVICE_ENDPOINT_CALLBACK_TRCPT);
+    usb_device_endpoint_unregister_callback(&usb_device, ep_num, USB_DEVICE_ENDPOINT_CALLBACK_TRCPT);
+    usb_device_endpoint_disable_callback(&usb_device, ep, USB_DEVICE_ENDPOINT_CALLBACK_TRCPT);
 }
 
-bool udd_ep_alloc(udd_ep_id_t ep, uint8_t bmAttributes, uint16_t MaxEndpointSize)
-{
+bool udd_ep_alloc(udd_ep_id_t ep, uint8_t bmAttributes, uint16_t MaxEndpointSize) {
     struct usb_device_endpoint_config config_ep;
     usb_device_endpoint_get_config_defaults(&config_ep);
 
     config_ep.ep_address = ep;
 
-    if(MaxEndpointSize <= 8) {
+    if (MaxEndpointSize <= 8) {
         config_ep.ep_size = USB_ENDPOINT_8_BYTE;
-    } else if(MaxEndpointSize <= 16) {
+    } else if (MaxEndpointSize <= 16) {
         config_ep.ep_size = USB_ENDPOINT_16_BYTE;
-    } else if(MaxEndpointSize <= 32) {
+    } else if (MaxEndpointSize <= 32) {
         config_ep.ep_size = USB_ENDPOINT_32_BYTE;
-    } else if(MaxEndpointSize <= 64) {
+    } else if (MaxEndpointSize <= 64) {
         config_ep.ep_size = USB_ENDPOINT_64_BYTE;
-    } else if(MaxEndpointSize <= 128) {
+    } else if (MaxEndpointSize <= 128) {
         config_ep.ep_size = USB_ENDPOINT_128_BYTE;
-    } else if(MaxEndpointSize <= 256) {
+    } else if (MaxEndpointSize <= 256) {
         config_ep.ep_size = USB_ENDPOINT_256_BYTE;
-    } else if(MaxEndpointSize <= 512) {
+    } else if (MaxEndpointSize <= 512) {
         config_ep.ep_size = USB_ENDPOINT_512_BYTE;
-    } else if(MaxEndpointSize <= 1023) {
+    } else if (MaxEndpointSize <= 1023) {
         config_ep.ep_size = USB_ENDPOINT_1023_BYTE;
     } else {
         return false;
     }
     udd_ep_job_t *ptr_job = udd_ep_get_job(ep);
-    ptr_job->ep_size = MaxEndpointSize;
+    ptr_job->ep_size      = MaxEndpointSize;
 
     bmAttributes = bmAttributes & USB_EP_TYPE_MASK;
 
     /* Check endpoint type */
-    if(USB_EP_TYPE_ISOCHRONOUS == bmAttributes) {
+    if (USB_EP_TYPE_ISOCHRONOUS == bmAttributes) {
         config_ep.ep_type = USB_DEVICE_ENDPOINT_TYPE_ISOCHRONOUS;
     } else if (USB_EP_TYPE_BULK == bmAttributes) {
         config_ep.ep_type = USB_DEVICE_ENDPOINT_TYPE_BULK;
@@ -448,20 +429,16 @@ bool udd_ep_alloc(udd_ep_id_t ep, uint8_t bmAttributes, uint16_t MaxEndpointSize
     if (STATUS_OK != usb_device_endpoint_set_config(&usb_device, &config_ep)) {
         return false;
     }
-    usb_device_endpoint_register_callback(&usb_device,ep_num,USB_DEVICE_ENDPOINT_CALLBACK_TRCPT,udd_ep_transfer_process);
-    usb_device_endpoint_enable_callback(&usb_device,ep,USB_DEVICE_ENDPOINT_CALLBACK_TRCPT);
-    usb_device_endpoint_enable_callback(&usb_device,ep,USB_DEVICE_ENDPOINT_CALLBACK_TRFAIL);
+    usb_device_endpoint_register_callback(&usb_device, ep_num, USB_DEVICE_ENDPOINT_CALLBACK_TRCPT, udd_ep_transfer_process);
+    usb_device_endpoint_enable_callback(&usb_device, ep, USB_DEVICE_ENDPOINT_CALLBACK_TRCPT);
+    usb_device_endpoint_enable_callback(&usb_device, ep, USB_DEVICE_ENDPOINT_CALLBACK_TRFAIL);
 
     return true;
 }
 
-bool udd_ep_is_halted(udd_ep_id_t ep)
-{
-    return usb_device_endpoint_is_halted(&usb_device, ep);
-}
+bool udd_ep_is_halted(udd_ep_id_t ep) { return usb_device_endpoint_is_halted(&usb_device, ep); }
 
-bool udd_ep_set_halt(udd_ep_id_t ep)
-{
+bool udd_ep_set_halt(udd_ep_id_t ep) {
     uint8_t ep_num = ep & USB_EP_ADDR_MASK;
 
     if (USB_DEVICE_MAX_EP < ep_num) {
@@ -474,10 +451,9 @@ bool udd_ep_set_halt(udd_ep_id_t ep)
     return true;
 }
 
-bool udd_ep_clear_halt(udd_ep_id_t ep)
-{
+bool udd_ep_clear_halt(udd_ep_id_t ep) {
     udd_ep_job_t *ptr_job;
-    uint8_t ep_num = ep & USB_EP_ADDR_MASK;
+    uint8_t       ep_num = ep & USB_EP_ADDR_MASK;
 
     if (USB_DEVICE_MAX_EP < ep_num) {
         return false;
@@ -495,9 +471,8 @@ bool udd_ep_clear_halt(udd_ep_id_t ep)
     return true;
 }
 
-bool udd_ep_wait_stall_clear(udd_ep_id_t ep, udd_callback_halt_cleared_t callback)
-{
-    udd_ep_id_t ep_num;
+bool udd_ep_wait_stall_clear(udd_ep_id_t ep, udd_callback_halt_cleared_t callback) {
+    udd_ep_id_t   ep_num;
     udd_ep_job_t *ptr_job;
 
     ep_num = ep & USB_EP_ADDR_MASK;
@@ -513,7 +488,7 @@ bool udd_ep_wait_stall_clear(udd_ep_id_t ep, udd_callback_halt_cleared_t callbac
     /* Wait clear halt endpoint */
     if (usb_device_endpoint_is_halted(&usb_device, ep)) {
         /* Endpoint halted then registers the callback */
-        ptr_job->busy = true;
+        ptr_job->busy        = true;
         ptr_job->call_nohalt = callback;
         return true;
     } else if (usb_device_endpoint_is_configured(&usb_device, ep)) {
@@ -527,19 +502,17 @@ bool udd_ep_wait_stall_clear(udd_ep_id_t ep, udd_callback_halt_cleared_t callbac
 /**
  * \brief Control Endpoint stall sending data
  */
-static void udd_ctrl_stall_data(void)
-{
+static void udd_ctrl_stall_data(void) {
     udd_ep_control_state = UDD_EPCTRL_STALL_REQ;
 
     usb_device_endpoint_set_halt(&usb_device, USB_EP_DIR_IN);
     usb_device_endpoint_clear_halt(&usb_device, USB_EP_DIR_OUT);
 }
 
-bool udd_ep_run(udd_ep_id_t ep, bool b_shortpacket, uint8_t *buf, iram_size_t buf_size, udd_callback_trans_t callback)
-{
-    udd_ep_id_t ep_num;
+bool udd_ep_run(udd_ep_id_t ep, bool b_shortpacket, uint8_t *buf, iram_size_t buf_size, udd_callback_trans_t callback) {
+    udd_ep_id_t   ep_num;
     udd_ep_job_t *ptr_job;
-    uint32_t irqflags;
+    uint32_t      irqflags;
 
     ep_num = ep & USB_EP_ADDR_MASK;
 
@@ -564,11 +537,11 @@ bool udd_ep_run(udd_ep_id_t ep, bool b_shortpacket, uint8_t *buf, iram_size_t bu
     __set_PRIMASK(irqflags);
 
     /* No job running, set up a new one */
-    ptr_job->buf = buf;
-    ptr_job->buf_size = buf_size;
-    ptr_job->nb_trans = 0;
-    ptr_job->call_trans = callback;
-    ptr_job->b_shortpacket = b_shortpacket;
+    ptr_job->buf                    = buf;
+    ptr_job->buf_size               = buf_size;
+    ptr_job->nb_trans               = 0;
+    ptr_job->call_trans             = callback;
+    ptr_job->b_shortpacket          = b_shortpacket;
     ptr_job->b_use_out_cache_buffer = false;
 
     /* Initialize value to simulate a empty transfer */
@@ -580,10 +553,10 @@ bool udd_ep_run(udd_ep_id_t ep, bool b_shortpacket, uint8_t *buf, iram_size_t bu
             if (UDD_ENDPOINT_MAX_TRANS < next_trans) {
                 next_trans = UDD_ENDPOINT_MAX_TRANS - (UDD_ENDPOINT_MAX_TRANS % ptr_job->ep_size);
             }
-            ptr_job->b_shortpacket = ptr_job->b_shortpacket &&  (0 == (next_trans % ptr_job->ep_size));
+            ptr_job->b_shortpacket = ptr_job->b_shortpacket && (0 == (next_trans % ptr_job->ep_size));
         } else if (true == ptr_job->b_shortpacket) {
             ptr_job->b_shortpacket = false; /* avoid to send zero length packet again */
-            next_trans = 0;
+            next_trans             = 0;
         } else {
             ptr_job->busy = false;
             if (NULL != ptr_job->call_trans) {
@@ -591,30 +564,22 @@ bool udd_ep_run(udd_ep_id_t ep, bool b_shortpacket, uint8_t *buf, iram_size_t bu
             }
             return true;
         }
-        return (STATUS_OK ==
-                usb_device_endpoint_write_buffer_job(&usb_device,
-                        ep_num,&ptr_job->buf[0],next_trans));
+        return (STATUS_OK == usb_device_endpoint_write_buffer_job(&usb_device, ep_num, &ptr_job->buf[0], next_trans));
     } else {
         if (0 != ptr_job->buf_size) {
             next_trans = ptr_job->buf_size;
             if (UDD_ENDPOINT_MAX_TRANS < next_trans) {
                 /* The USB hardware support a maximum transfer size
                  * of UDD_ENDPOINT_MAX_TRANS Bytes */
-                next_trans = UDD_ENDPOINT_MAX_TRANS -
-                        (UDD_ENDPOINT_MAX_TRANS % ptr_job->ep_size);
+                next_trans = UDD_ENDPOINT_MAX_TRANS - (UDD_ENDPOINT_MAX_TRANS % ptr_job->ep_size);
             } else {
                 next_trans -= next_trans % ptr_job->ep_size;
             }
             if (next_trans < ptr_job->ep_size) {
                 ptr_job->b_use_out_cache_buffer = true;
-                return (STATUS_OK ==
-                        usb_device_endpoint_read_buffer_job(&usb_device, ep_num,
-                                udd_ep_out_cache_buffer[ep_num - 1],
-                                ptr_job->ep_size));
+                return (STATUS_OK == usb_device_endpoint_read_buffer_job(&usb_device, ep_num, udd_ep_out_cache_buffer[ep_num - 1], ptr_job->ep_size));
             } else {
-                return (STATUS_OK ==
-                        usb_device_endpoint_read_buffer_job(&usb_device, ep_num,
-                                &ptr_job->buf[0],next_trans));
+                return (STATUS_OK == usb_device_endpoint_read_buffer_job(&usb_device, ep_num, &ptr_job->buf[0], next_trans));
             }
         } else {
             ptr_job->busy = false;
@@ -626,61 +591,51 @@ bool udd_ep_run(udd_ep_id_t ep, bool b_shortpacket, uint8_t *buf, iram_size_t bu
     }
 }
 
-void udd_set_address(uint8_t address)
-{
-    usb_device_set_address(&usb_device,address);
-}
+void udd_set_address(uint8_t address) { usb_device_set_address(&usb_device, address); }
 
-uint8_t udd_getaddress(void)
-{
-    return usb_device_get_address(&usb_device);
-}
+uint8_t udd_getaddress(void) { return usb_device_get_address(&usb_device); }
 
-void udd_send_remotewakeup(void)
-{
-    uint32_t try = 5;
+void udd_send_remotewakeup(void) {
+    uint32_t try
+        = 5;
     udd_wait_clock_ready();
     udd_sleep_mode(UDD_STATE_IDLE);
-    while(2 != usb_get_state_machine_status(&usb_device) && try --) {
+    while (2 != usb_get_state_machine_status(&usb_device) && try --) {
         usb_device_send_remote_wake_up(&usb_device);
     }
 }
 
-void udd_set_setup_payload( uint8_t *payload, uint16_t payload_size )
-{
-    udd_g_ctrlreq.payload = payload;
+void udd_set_setup_payload(uint8_t *payload, uint16_t payload_size) {
+    udd_g_ctrlreq.payload      = payload;
     udd_g_ctrlreq.payload_size = payload_size;
 }
 
 /**
  * \brief Control Endpoint translate the data in buffer into Device Request Struct
  */
-static void udd_ctrl_fetch_ram(void)
-{
+static void udd_ctrl_fetch_ram(void) {
     udd_g_ctrlreq.req.bmRequestType = udd_ctrl_buffer[0];
-    udd_g_ctrlreq.req.bRequest = udd_ctrl_buffer[1];
-    udd_g_ctrlreq.req.wValue = ((uint16_t)(udd_ctrl_buffer[3]) << 8) + udd_ctrl_buffer[2];
-    udd_g_ctrlreq.req.wIndex = ((uint16_t)(udd_ctrl_buffer[5]) << 8) + udd_ctrl_buffer[4];
-    udd_g_ctrlreq.req.wLength = ((uint16_t)(udd_ctrl_buffer[7]) << 8) + udd_ctrl_buffer[6];
+    udd_g_ctrlreq.req.bRequest      = udd_ctrl_buffer[1];
+    udd_g_ctrlreq.req.wValue        = ((uint16_t)(udd_ctrl_buffer[3]) << 8) + udd_ctrl_buffer[2];
+    udd_g_ctrlreq.req.wIndex        = ((uint16_t)(udd_ctrl_buffer[5]) << 8) + udd_ctrl_buffer[4];
+    udd_g_ctrlreq.req.wLength       = ((uint16_t)(udd_ctrl_buffer[7]) << 8) + udd_ctrl_buffer[6];
 }
 
 /**
  * \brief Control Endpoint send out zero length packet
  */
-static void udd_ctrl_send_zlp_in(void)
-{
+static void udd_ctrl_send_zlp_in(void) {
     udd_ep_control_state = UDD_EPCTRL_HANDSHAKE_WAIT_IN_ZLP;
-    usb_device_endpoint_setup_buffer_job(&usb_device,udd_ctrl_buffer);
-    usb_device_endpoint_write_buffer_job(&usb_device,0,udd_g_ctrlreq.payload,0);
+    usb_device_endpoint_setup_buffer_job(&usb_device, udd_ctrl_buffer);
+    usb_device_endpoint_write_buffer_job(&usb_device, 0, udd_g_ctrlreq.payload, 0);
 }
 
 /**
  * \brief Process control endpoint IN transaction
  */
-static void udd_ctrl_in_sent(void)
-{
+static void udd_ctrl_in_sent(void) {
     static bool b_shortpacket = false;
-    uint16_t nb_remain;
+    uint16_t    nb_remain;
 
     nb_remain = udd_g_ctrlreq.payload_size - udd_ctrl_payload_nb_trans;
 
@@ -691,7 +646,7 @@ static void udd_ctrl_in_sent(void)
             /* All data requested are transferred or a short packet has been sent, then it is the end of data phase.
              * Generate an OUT ZLP for handshake phase */
             udd_ep_control_state = UDD_EPCTRL_HANDSHAKE_WAIT_OUT_ZLP;
-            usb_device_endpoint_setup_buffer_job(&usb_device,udd_ctrl_buffer);
+            usb_device_endpoint_setup_buffer_job(&usb_device, udd_ctrl_buffer);
             return;
         }
         /* Need of new buffer because the data phase is not complete */
@@ -701,20 +656,20 @@ static void udd_ctrl_in_sent(void)
         } else {
             /* A new payload buffer is given */
             udd_ctrl_payload_nb_trans = 0;
-            nb_remain = udd_g_ctrlreq.payload_size;
+            nb_remain                 = udd_g_ctrlreq.payload_size;
         }
     }
 
     /* Continue transfer and send next data */
     if (nb_remain >= USB_DEVICE_EP_CTRL_SIZE) {
-        nb_remain = USB_DEVICE_EP_CTRL_SIZE;
+        nb_remain     = USB_DEVICE_EP_CTRL_SIZE;
         b_shortpacket = false;
     } else {
         b_shortpacket = true;
     }
 
     /* Link payload buffer directly on USB hardware */
-    usb_device_endpoint_write_buffer_job(&usb_device,0,udd_g_ctrlreq.payload + udd_ctrl_payload_nb_trans,nb_remain);
+    usb_device_endpoint_write_buffer_job(&usb_device, 0, udd_g_ctrlreq.payload + udd_ctrl_payload_nb_trans, nb_remain);
 
     udd_ctrl_payload_nb_trans += nb_remain;
 }
@@ -723,9 +678,8 @@ static void udd_ctrl_in_sent(void)
  * \brief Process control endpoint OUT transaction
  * \param[in] pointer Pointer to the endpoint transfer status parameter struct from driver layer.
  */
-static void udd_ctrl_out_received(void* pointer)
-{
-    struct usb_endpoint_callback_parameter *ep_callback_para = (struct usb_endpoint_callback_parameter*)pointer;
+static void udd_ctrl_out_received(void *pointer) {
+    struct usb_endpoint_callback_parameter *ep_callback_para = (struct usb_endpoint_callback_parameter *)pointer;
 
     uint16_t nb_data;
     nb_data = ep_callback_para->received_bytes; /* Read data received during OUT phase */
@@ -735,11 +689,10 @@ static void udd_ctrl_out_received(void* pointer)
         nb_data = udd_g_ctrlreq.payload_size - udd_ctrl_payload_nb_trans;
     }
 
-    memcpy((uint8_t *) (udd_g_ctrlreq.payload + udd_ctrl_payload_nb_trans), udd_ctrl_buffer, nb_data);
+    memcpy((uint8_t *)(udd_g_ctrlreq.payload + udd_ctrl_payload_nb_trans), udd_ctrl_buffer, nb_data);
     udd_ctrl_payload_nb_trans += nb_data;
 
-    if ((USB_DEVICE_EP_CTRL_SIZE != nb_data) || \
-    (udd_g_ctrlreq.req.wLength <= (udd_ctrl_prev_payload_nb_trans + udd_ctrl_payload_nb_trans))) {
+    if ((USB_DEVICE_EP_CTRL_SIZE != nb_data) || (udd_g_ctrlreq.req.wLength <= (udd_ctrl_prev_payload_nb_trans + udd_ctrl_payload_nb_trans))) {
         /* End of reception because it is a short packet
          * or all data are transferred */
 
@@ -786,7 +739,7 @@ static void udd_ctrl_out_received(void* pointer)
         /* Reinitialize reception on payload buffer */
         udd_ctrl_payload_nb_trans = 0;
     }
-    usb_device_endpoint_read_buffer_job(&usb_device,0,udd_ctrl_buffer,USB_DEVICE_EP_CTRL_SIZE);
+    usb_device_endpoint_read_buffer_job(&usb_device, 0, udd_ctrl_buffer, USB_DEVICE_EP_CTRL_SIZE);
 }
 
 /**
@@ -795,9 +748,8 @@ static void udd_ctrl_out_received(void* pointer)
  * \param[in] module_inst pointer to USB module instance
  * \param[in] pointer Pointer to the endpoint transfer status parameter struct from driver layer.
  */
-static void _usb_ep0_on_setup(struct usb_module *module_inst, void* pointer)
-{
-    struct usb_endpoint_callback_parameter *ep_callback_para = (struct usb_endpoint_callback_parameter*)pointer;
+static void _usb_ep0_on_setup(struct usb_module *module_inst, void *pointer) {
+    struct usb_endpoint_callback_parameter *ep_callback_para = (struct usb_endpoint_callback_parameter *)pointer;
 
     if (UDD_EPCTRL_SETUP != udd_ep_control_state) {
         if (NULL != udd_g_ctrlreq.callback) {
@@ -805,7 +757,7 @@ static void _usb_ep0_on_setup(struct usb_module *module_inst, void* pointer)
         }
         udd_ep_control_state = UDD_EPCTRL_SETUP;
     }
-    if ( 8 != ep_callback_para->received_bytes) {
+    if (8 != ep_callback_para->received_bytes) {
         udd_ctrl_stall_data();
         return;
     } else {
@@ -815,20 +767,20 @@ static void _usb_ep0_on_setup(struct usb_module *module_inst, void* pointer)
             return;
         } else if (Udd_setup_is_in()) {
             udd_ctrl_prev_payload_nb_trans = 0;
-            udd_ctrl_payload_nb_trans = 0;
-            udd_ep_control_state = UDD_EPCTRL_DATA_IN;
-            usb_device_endpoint_read_buffer_job(&usb_device,0,udd_ctrl_buffer,USB_DEVICE_EP_CTRL_SIZE);
+            udd_ctrl_payload_nb_trans      = 0;
+            udd_ep_control_state           = UDD_EPCTRL_DATA_IN;
+            usb_device_endpoint_read_buffer_job(&usb_device, 0, udd_ctrl_buffer, USB_DEVICE_EP_CTRL_SIZE);
             udd_ctrl_in_sent();
         } else {
-            if(0 == udd_g_ctrlreq.req.wLength) {
+            if (0 == udd_g_ctrlreq.req.wLength) {
                 udd_ctrl_send_zlp_in();
                 return;
             } else {
                 udd_ctrl_prev_payload_nb_trans = 0;
-                udd_ctrl_payload_nb_trans = 0;
-                udd_ep_control_state = UDD_EPCTRL_DATA_OUT;
+                udd_ctrl_payload_nb_trans      = 0;
+                udd_ep_control_state           = UDD_EPCTRL_DATA_OUT;
                 /* Initialize buffer size and enable OUT bank */
-                usb_device_endpoint_read_buffer_job(&usb_device,0,udd_ctrl_buffer,USB_DEVICE_EP_CTRL_SIZE);
+                usb_device_endpoint_read_buffer_job(&usb_device, 0, udd_ctrl_buffer, USB_DEVICE_EP_CTRL_SIZE);
             }
         }
     }
@@ -838,9 +790,8 @@ static void _usb_ep0_on_setup(struct usb_module *module_inst, void* pointer)
  * \brief Control Endpoint Process when underflow condition has occurred
  * \param[in] pointer Pointer to the endpoint transfer status parameter struct from driver layer.
  */
-static void udd_ctrl_underflow(void* pointer)
-{
-    struct usb_endpoint_callback_parameter *ep_callback_para = (struct usb_endpoint_callback_parameter*)pointer;
+static void udd_ctrl_underflow(void *pointer) {
+    struct usb_endpoint_callback_parameter *ep_callback_para = (struct usb_endpoint_callback_parameter *)pointer;
 
     if (UDD_EPCTRL_DATA_OUT == udd_ep_control_state) {
         /* Host want to stop OUT transaction
@@ -857,9 +808,8 @@ static void udd_ctrl_underflow(void* pointer)
  * \brief Control Endpoint Process when overflow condition has occurred
  * \param[in] pointer Pointer to the endpoint transfer status parameter struct from driver layer.
  */
-static void udd_ctrl_overflow(void* pointer)
-{
-    struct usb_endpoint_callback_parameter *ep_callback_para = (struct usb_endpoint_callback_parameter*)pointer;
+static void udd_ctrl_overflow(void *pointer) {
+    struct usb_endpoint_callback_parameter *ep_callback_para = (struct usb_endpoint_callback_parameter *)pointer;
 
     if (UDD_EPCTRL_DATA_IN == udd_ep_control_state) {
         /* Host want to stop IN transaction
@@ -878,11 +828,10 @@ static void udd_ctrl_overflow(void* pointer)
  * \param[in] module_inst Pointer to USB module instance
  * \param[in] pointer Pointer to the endpoint transfer status parameter struct from driver layer.
  */
-static void _usb_ep0_on_tansfer_fail(struct usb_module *module_inst, void* pointer)
-{
-    struct usb_endpoint_callback_parameter *ep_callback_para = (struct usb_endpoint_callback_parameter*)pointer;
+static void _usb_ep0_on_tansfer_fail(struct usb_module *module_inst, void *pointer) {
+    struct usb_endpoint_callback_parameter *ep_callback_para = (struct usb_endpoint_callback_parameter *)pointer;
 
-    if(ep_callback_para->endpoint_address & USB_EP_DIR_IN) {
+    if (ep_callback_para->endpoint_address & USB_EP_DIR_IN) {
         udd_ctrl_underflow(pointer);
     } else {
         udd_ctrl_overflow(pointer);
@@ -895,9 +844,8 @@ static void _usb_ep0_on_tansfer_fail(struct usb_module *module_inst, void* point
  * \param[in] module_inst Pointer to USB module instance
  * \param[in] pointer Pointer to the endpoint transfer status parameter struct from driver layer.
  */
-static void _usb_ep0_on_tansfer_ok(struct usb_module *module_inst, void *pointer)
-{
-    if (UDD_EPCTRL_DATA_OUT  == udd_ep_control_state) { /* handshake Out for status stage */
+static void _usb_ep0_on_tansfer_ok(struct usb_module *module_inst, void *pointer) {
+    if (UDD_EPCTRL_DATA_OUT == udd_ep_control_state) { /* handshake Out for status stage */
         udd_ctrl_out_received(pointer);
     } else if (UDD_EPCTRL_DATA_IN == udd_ep_control_state) { /* handshake In for status stage */
         udd_ctrl_in_sent();
@@ -913,25 +861,24 @@ static void _usb_ep0_on_tansfer_ok(struct usb_module *module_inst, void *pointer
  * \brief Enable Control Endpoint
  * \param[in] module_inst Pointer to USB module instance
  */
-static void udd_ctrl_ep_enable(struct usb_module *module_inst)
-{
+static void udd_ctrl_ep_enable(struct usb_module *module_inst) {
     /* USB Device Endpoint0 Configuration */
     struct usb_device_endpoint_config config_ep0;
 
     usb_device_endpoint_get_config_defaults(&config_ep0);
     config_ep0.ep_size = (enum usb_endpoint_size)(32 - clz(((uint32_t)Min(Max(USB_DEVICE_EP_CTRL_SIZE, 8), 1024) << 1) - 1) - 1 - 3);
-    usb_device_endpoint_set_config(module_inst,&config_ep0);
+    usb_device_endpoint_set_config(module_inst, &config_ep0);
 
-    usb_device_endpoint_setup_buffer_job(module_inst,udd_ctrl_buffer);
+    usb_device_endpoint_setup_buffer_job(module_inst, udd_ctrl_buffer);
 
-    usb_device_endpoint_register_callback(module_inst,0,USB_DEVICE_ENDPOINT_CALLBACK_RXSTP, _usb_ep0_on_setup );
-    usb_device_endpoint_register_callback(module_inst,0,USB_DEVICE_ENDPOINT_CALLBACK_TRCPT,_usb_ep0_on_tansfer_ok );
-    usb_device_endpoint_register_callback(module_inst,0,USB_DEVICE_ENDPOINT_CALLBACK_TRFAIL,_usb_ep0_on_tansfer_fail );
-    usb_device_endpoint_enable_callback(module_inst,0,USB_DEVICE_ENDPOINT_CALLBACK_RXSTP);
-    usb_device_endpoint_enable_callback(module_inst,0,USB_DEVICE_ENDPOINT_CALLBACK_TRCPT);
-    usb_device_endpoint_enable_callback(module_inst,0,USB_DEVICE_ENDPOINT_CALLBACK_TRFAIL);
+    usb_device_endpoint_register_callback(module_inst, 0, USB_DEVICE_ENDPOINT_CALLBACK_RXSTP, _usb_ep0_on_setup);
+    usb_device_endpoint_register_callback(module_inst, 0, USB_DEVICE_ENDPOINT_CALLBACK_TRCPT, _usb_ep0_on_tansfer_ok);
+    usb_device_endpoint_register_callback(module_inst, 0, USB_DEVICE_ENDPOINT_CALLBACK_TRFAIL, _usb_ep0_on_tansfer_fail);
+    usb_device_endpoint_enable_callback(module_inst, 0, USB_DEVICE_ENDPOINT_CALLBACK_RXSTP);
+    usb_device_endpoint_enable_callback(module_inst, 0, USB_DEVICE_ENDPOINT_CALLBACK_TRCPT);
+    usb_device_endpoint_enable_callback(module_inst, 0, USB_DEVICE_ENDPOINT_CALLBACK_TRFAIL);
 
-#ifdef  USB_DEVICE_LPM_SUPPORT
+#ifdef USB_DEVICE_LPM_SUPPORT
     // Enable LPM feature
     usb_device_set_lpm_mode(module_inst, USB_DEVICE_LPM_ACK);
 #endif
@@ -945,8 +892,7 @@ static void udd_ctrl_ep_enable(struct usb_module *module_inst)
  * \param[in] module_inst Pointer to USB module instance
  * \param[in] pointer Pointer to the callback parameter from driver layer.
  */
-static void _usb_on_suspend(struct usb_module *module_inst, void *pointer)
-{
+static void _usb_on_suspend(struct usb_module *module_inst, void *pointer) {
     usb_device_disable_callback(&usb_device, USB_DEVICE_CALLBACK_SUSPEND);
     usb_device_enable_callback(&usb_device, USB_DEVICE_CALLBACK_WAKEUP);
     udd_sleep_mode(UDD_STATE_SUSPEND);
@@ -955,9 +901,8 @@ static void _usb_on_suspend(struct usb_module *module_inst, void *pointer)
 #endif
 }
 
-#ifdef  USB_DEVICE_LPM_SUPPORT
-static void _usb_device_lpm_suspend(struct usb_module *module_inst, void *pointer)
-{
+#ifdef USB_DEVICE_LPM_SUPPORT
+static void _usb_device_lpm_suspend(struct usb_module *module_inst, void *pointer) {
     dbg_print("LPM_SUSP\n");
 
     uint32_t *lpm_wakeup_enable;
@@ -967,7 +912,7 @@ static void _usb_device_lpm_suspend(struct usb_module *module_inst, void *pointe
     usb_device_disable_callback(&usb_device, USB_DEVICE_CALLBACK_SUSPEND);
     usb_device_enable_callback(&usb_device, USB_DEVICE_CALLBACK_WAKEUP);
 
-//#warning Here the sleep mode must be choose to have a DFLL startup time < bmAttribut.HIRD
+    //#warning Here the sleep mode must be choose to have a DFLL startup time < bmAttribut.HIRD
     udd_sleep_mode(UDD_STATE_SUSPEND_LPM);  // Enter in LPM SUSPEND mode
     if ((*lpm_wakeup_enable)) {
         UDC_REMOTEWAKEUP_LPM_ENABLE();
@@ -985,8 +930,7 @@ static void _usb_device_lpm_suspend(struct usb_module *module_inst, void *pointe
  * \param[in] module_inst Pointer to USB module instance
  * \param[in] pointer Pointer to the callback parameter from driver layer.
  */
-static void _usb_on_sof_notify(struct usb_module *module_inst, void *pointer)
-{
+static void _usb_on_sof_notify(struct usb_module *module_inst, void *pointer) {
     udc_sof_notify();
 #ifdef UDC_SOF_EVENT
     UDC_SOF_EVENT();
@@ -999,11 +943,10 @@ static void _usb_on_sof_notify(struct usb_module *module_inst, void *pointer)
  * \param[in] module_inst Pointer to USB module instance
  * \param[in] pointer Pointer to the callback parameter from driver layer.
  */
-static void _usb_on_bus_reset(struct usb_module *module_inst, void *pointer)
-{
+static void _usb_on_bus_reset(struct usb_module *module_inst, void *pointer) {
     // Reset USB Device Stack Core
     udc_reset();
-    usb_device_set_address(module_inst,0);
+    usb_device_set_address(module_inst, 0);
     udd_ctrl_ep_enable(module_inst);
 }
 
@@ -1013,13 +956,12 @@ static void _usb_on_bus_reset(struct usb_module *module_inst, void *pointer)
  * \param[in] module_inst Pointer to USB module instance
  * \param[in] pointer Pointer to the callback parameter from driver layer.
  */
-static void _usb_on_wakeup(struct usb_module *module_inst, void *pointer)
-{
+static void _usb_on_wakeup(struct usb_module *module_inst, void *pointer) {
     udd_wait_clock_ready();
 
     usb_device_disable_callback(&usb_device, USB_DEVICE_CALLBACK_WAKEUP);
     usb_device_enable_callback(&usb_device, USB_DEVICE_CALLBACK_SUSPEND);
-#ifdef  USB_DEVICE_LPM_SUPPORT
+#ifdef USB_DEVICE_LPM_SUPPORT
     usb_device_register_callback(&usb_device, USB_DEVICE_CALLBACK_LPMSUSP, _usb_device_lpm_suspend);
     usb_device_enable_callback(&usb_device, USB_DEVICE_CALLBACK_LPMSUSP);
 #endif
@@ -1029,14 +971,12 @@ static void _usb_on_wakeup(struct usb_module *module_inst, void *pointer)
 #endif
 }
 
-void udd_detach(void)
-{
+void udd_detach(void) {
     usb_device_detach(&usb_device);
     udd_sleep_mode(UDD_STATE_SUSPEND);
 }
 
-void udd_attach(void)
-{
+void udd_attach(void) {
     udd_sleep_mode(UDD_STATE_IDLE);
     usb_device_attach(&usb_device);
 
@@ -1049,14 +989,13 @@ void udd_attach(void)
     usb_device_enable_callback(&usb_device, USB_DEVICE_CALLBACK_SOF);
     usb_device_enable_callback(&usb_device, USB_DEVICE_CALLBACK_RESET);
     usb_device_enable_callback(&usb_device, USB_DEVICE_CALLBACK_WAKEUP);
-#ifdef  USB_DEVICE_LPM_SUPPORT
+#ifdef USB_DEVICE_LPM_SUPPORT
     usb_device_register_callback(&usb_device, USB_DEVICE_CALLBACK_LPMSUSP, _usb_device_lpm_suspend);
     usb_device_enable_callback(&usb_device, USB_DEVICE_CALLBACK_LPMSUSP);
 #endif
 }
 
-void udd_enable(void)
-{
+void udd_enable(void) {
     uint32_t irqflags;
 
     /* To avoid USB interrupt before end of initialization */
@@ -1088,8 +1027,7 @@ void udd_enable(void)
     __set_PRIMASK(irqflags);
 }
 
-void udd_disable(void)
-{
+void udd_disable(void) {
     udd_detach();
 
     udd_sleep_mode(UDD_STATE_OFF);
diff --git a/tmk_core/protocol/arm_atsam/usb/usb_main.h b/tmk_core/protocol/arm_atsam/usb/usb_main.h
index 76ced474d..e1ffa3e18 100644
--- a/tmk_core/protocol/arm_atsam/usb/usb_main.h
+++ b/tmk_core/protocol/arm_atsam/usb/usb_main.h
@@ -47,57 +47,56 @@
 #ifndef _MAIN_H_
 #define _MAIN_H_
 
-//Enters the application in low power mode
-//Callback called when USB host sets USB line in suspend state
+// Enters the application in low power mode
+// Callback called when USB host sets USB line in suspend state
 void main_suspend_action(void);
 
-//Called by UDD when the USB line exit of suspend state
+// Called by UDD when the USB line exit of suspend state
 void main_resume_action(void);
 
-//Called when a start of frame is received on USB line
+// Called when a start of frame is received on USB line
 void main_sof_action(void);
 
-//Called by UDC when USB Host request to enable remote wakeup
+// Called by UDC when USB Host request to enable remote wakeup
 void main_remotewakeup_enable(void);
 
-//Called by UDC when USB Host request to disable remote wakeup
+// Called by UDC when USB Host request to disable remote wakeup
 void main_remotewakeup_disable(void);
 
-
 #ifdef KBD
 extern volatile bool main_b_kbd_enable;
-bool main_kbd_enable(void);
-void main_kbd_disable(void);
-#endif //KBD
+bool                 main_kbd_enable(void);
+void                 main_kbd_disable(void);
+#endif  // KBD
 
 #ifdef NKRO
 extern volatile bool main_b_nkro_enable;
-bool main_nkro_enable(void);
-void main_nkro_disable(void);
-#endif //NKRO
+bool                 main_nkro_enable(void);
+void                 main_nkro_disable(void);
+#endif  // NKRO
 
 #ifdef EXK
 extern volatile bool main_b_exk_enable;
-bool main_exk_enable(void);
-void main_exk_disable(void);
-#endif //EXK
+bool                 main_exk_enable(void);
+void                 main_exk_disable(void);
+#endif  // EXK
 
 #ifdef CON
 extern volatile bool main_b_con_enable;
-bool main_con_enable(void);
-void main_con_disable(void);
-#endif //CON
+bool                 main_con_enable(void);
+void                 main_con_disable(void);
+#endif  // CON
 
 #ifdef MOU
 extern volatile bool main_b_mou_enable;
-bool main_mou_enable(void);
-void main_mou_disable(void);
-#endif //MOU
+bool                 main_mou_enable(void);
+void                 main_mou_disable(void);
+#endif  // MOU
 
 #ifdef RAW
 extern volatile bool main_b_raw_enable;
-bool main_raw_enable(void);
-void main_raw_disable(void);
-#endif //RAW
+bool                 main_raw_enable(void);
+void                 main_raw_disable(void);
+#endif  // RAW
 
-#endif // _MAIN_H_
+#endif  // _MAIN_H_
diff --git a/tmk_core/protocol/arm_atsam/usb/usb_protocol.h b/tmk_core/protocol/arm_atsam/usb/usb_protocol.h
index 892a7d3a5..54d023a6e 100644
--- a/tmk_core/protocol/arm_atsam/usb/usb_protocol.h
+++ b/tmk_core/protocol/arm_atsam/usb/usb_protocol.h
@@ -63,83 +63,77 @@
  */
 
 //! Value for field bcdUSB
-#define  USB_V2_0    0x0200 //!< USB Specification version 2.00
-#define  USB_V2_1    0x0201 //!< USB Specification version 2.01
+#define USB_V2_0 0x0200  //!< USB Specification version 2.00
+#define USB_V2_1 0x0201  //!< USB Specification version 2.01
 
 /*! \name Generic definitions (Class, subclass and protocol)
  */
 //! @{
-#define  NO_CLASS                0x00
-#define  CLASS_VENDOR_SPECIFIC   0xFF
-#define  NO_SUBCLASS             0x00
-#define  NO_PROTOCOL             0x00
+#define NO_CLASS 0x00
+#define CLASS_VENDOR_SPECIFIC 0xFF
+#define NO_SUBCLASS 0x00
+#define NO_PROTOCOL 0x00
 //! @}
 
 //! \name IAD (Interface Association Descriptor) constants
 //! @{
-#define  CLASS_IAD               0xEF
-#define  SUB_CLASS_IAD           0x02
-#define  PROTOCOL_IAD            0x01
+#define CLASS_IAD 0xEF
+#define SUB_CLASS_IAD 0x02
+#define PROTOCOL_IAD 0x01
 //! @}
 
 /**
  * \brief USB request data transfer direction (bmRequestType)
  */
-#define  USB_REQ_DIR_OUT         (0<<7) //!< Host to device
-#define  USB_REQ_DIR_IN          (1<<7) //!< Device to host
-#define  USB_REQ_DIR_MASK        (1<<7) //!< Mask
+#define USB_REQ_DIR_OUT (0 << 7)   //!< Host to device
+#define USB_REQ_DIR_IN (1 << 7)    //!< Device to host
+#define USB_REQ_DIR_MASK (1 << 7)  //!< Mask
 
 /**
  * \brief USB request types (bmRequestType)
  */
-#define  USB_REQ_TYPE_STANDARD   (0<<5) //!< Standard request
-#define  USB_REQ_TYPE_CLASS      (1<<5) //!< Class-specific request
-#define  USB_REQ_TYPE_VENDOR     (2<<5) //!< Vendor-specific request
-#define  USB_REQ_TYPE_MASK       (3<<5) //!< Mask
+#define USB_REQ_TYPE_STANDARD (0 << 5)  //!< Standard request
+#define USB_REQ_TYPE_CLASS (1 << 5)     //!< Class-specific request
+#define USB_REQ_TYPE_VENDOR (2 << 5)    //!< Vendor-specific request
+#define USB_REQ_TYPE_MASK (3 << 5)      //!< Mask
 
 /**
  * \brief USB recipient codes (bmRequestType)
  */
-#define  USB_REQ_RECIP_DEVICE    (0<<0) //!< Recipient device
-#define  USB_REQ_RECIP_INTERFACE (1<<0) //!< Recipient interface
-#define  USB_REQ_RECIP_ENDPOINT  (2<<0) //!< Recipient endpoint
-#define  USB_REQ_RECIP_OTHER     (3<<0) //!< Recipient other
-#define  USB_REQ_RECIP_MASK      (0x1F) //!< Mask
+#define USB_REQ_RECIP_DEVICE (0 << 0)     //!< Recipient device
+#define USB_REQ_RECIP_INTERFACE (1 << 0)  //!< Recipient interface
+#define USB_REQ_RECIP_ENDPOINT (2 << 0)   //!< Recipient endpoint
+#define USB_REQ_RECIP_OTHER (3 << 0)      //!< Recipient other
+#define USB_REQ_RECIP_MASK (0x1F)         //!< Mask
 
 /**
  * \brief Standard USB requests (bRequest)
  */
 enum usb_reqid {
-    USB_REQ_GET_STATUS = 0,
-    USB_REQ_CLEAR_FEATURE = 1,
-    USB_REQ_SET_FEATURE = 3,
-    USB_REQ_SET_ADDRESS = 5,
-    USB_REQ_GET_DESCRIPTOR = 6,
-    USB_REQ_SET_DESCRIPTOR = 7,
+    USB_REQ_GET_STATUS        = 0,
+    USB_REQ_CLEAR_FEATURE     = 1,
+    USB_REQ_SET_FEATURE       = 3,
+    USB_REQ_SET_ADDRESS       = 5,
+    USB_REQ_GET_DESCRIPTOR    = 6,
+    USB_REQ_SET_DESCRIPTOR    = 7,
     USB_REQ_GET_CONFIGURATION = 8,
     USB_REQ_SET_CONFIGURATION = 9,
-    USB_REQ_GET_INTERFACE = 10,
-    USB_REQ_SET_INTERFACE = 11,
-    USB_REQ_SYNCH_FRAME = 12,
+    USB_REQ_GET_INTERFACE     = 10,
+    USB_REQ_SET_INTERFACE     = 11,
+    USB_REQ_SYNCH_FRAME       = 12,
 };
 
 /**
  * \brief Standard USB device status flags
  *
  */
-enum usb_device_status {
-    USB_DEV_STATUS_BUS_POWERED = 0,
-    USB_DEV_STATUS_SELF_POWERED = 1,
-    USB_DEV_STATUS_REMOTEWAKEUP = 2
-};
+enum usb_device_status { USB_DEV_STATUS_BUS_POWERED = 0, USB_DEV_STATUS_SELF_POWERED = 1, USB_DEV_STATUS_REMOTEWAKEUP = 2 };
 
 /**
  * \brief Standard USB Interface status flags
  *
  */
-enum usb_interface_status {
-    USB_IFACE_STATUS_RESERVED = 0
-};
+enum usb_interface_status { USB_IFACE_STATUS_RESERVED = 0 };
 
 /**
  * \brief Standard USB endpoint status flags
@@ -155,10 +149,10 @@ enum usb_endpoint_status {
  * \note valid for SetFeature request.
  */
 enum usb_device_feature {
-    USB_DEV_FEATURE_REMOTE_WAKEUP = 1, //!< Remote wakeup enabled
-    USB_DEV_FEATURE_TEST_MODE = 2,     //!< USB test mode
-    USB_DEV_FEATURE_OTG_B_HNP_ENABLE = 3,
-    USB_DEV_FEATURE_OTG_A_HNP_SUPPORT = 4,
+    USB_DEV_FEATURE_REMOTE_WAKEUP         = 1,  //!< Remote wakeup enabled
+    USB_DEV_FEATURE_TEST_MODE             = 2,  //!< USB test mode
+    USB_DEV_FEATURE_OTG_B_HNP_ENABLE      = 3,
+    USB_DEV_FEATURE_OTG_A_HNP_SUPPORT     = 4,
     USB_DEV_FEATURE_OTG_A_ALT_HNP_SUPPORT = 5
 };
 
@@ -168,10 +162,10 @@ enum usb_device_feature {
  * \note valid for USB_DEV_FEATURE_TEST_MODE request.
  */
 enum usb_device_hs_test_mode {
-    USB_DEV_TEST_MODE_J = 1,
-    USB_DEV_TEST_MODE_K = 2,
-    USB_DEV_TEST_MODE_SE0_NAK = 3,
-    USB_DEV_TEST_MODE_PACKET = 4,
+    USB_DEV_TEST_MODE_J            = 1,
+    USB_DEV_TEST_MODE_K            = 2,
+    USB_DEV_TEST_MODE_SE0_NAK      = 3,
+    USB_DEV_TEST_MODE_PACKET       = 4,
     USB_DEV_TEST_MODE_FORCE_ENABLE = 5,
 };
 
@@ -186,10 +180,10 @@ enum usb_endpoint_feature {
  * \brief Standard USB Test Mode Selectors
  */
 enum usb_test_mode_selector {
-    USB_TEST_J = 0x01,
-    USB_TEST_K = 0x02,
-    USB_TEST_SE0_NAK = 0x03,
-    USB_TEST_PACKET = 0x04,
+    USB_TEST_J            = 0x01,
+    USB_TEST_K            = 0x02,
+    USB_TEST_SE0_NAK      = 0x03,
+    USB_TEST_PACKET       = 0x04,
     USB_TEST_FORCE_ENABLE = 0x05,
 };
 
@@ -197,18 +191,18 @@ enum usb_test_mode_selector {
  * \brief Standard USB descriptor types
  */
 enum usb_descriptor_type {
-    USB_DT_DEVICE = 1,
-    USB_DT_CONFIGURATION = 2,
-    USB_DT_STRING = 3,
-    USB_DT_INTERFACE = 4,
-    USB_DT_ENDPOINT = 5,
-    USB_DT_DEVICE_QUALIFIER = 6,
+    USB_DT_DEVICE                    = 1,
+    USB_DT_CONFIGURATION             = 2,
+    USB_DT_STRING                    = 3,
+    USB_DT_INTERFACE                 = 4,
+    USB_DT_ENDPOINT                  = 5,
+    USB_DT_DEVICE_QUALIFIER          = 6,
     USB_DT_OTHER_SPEED_CONFIGURATION = 7,
-    USB_DT_INTERFACE_POWER = 8,
-    USB_DT_OTG = 9,
-    USB_DT_IAD = 0x0B,
-    USB_DT_BOS = 0x0F,
-    USB_DT_DEVICE_CAPABILITY = 0x10,
+    USB_DT_INTERFACE_POWER           = 8,
+    USB_DT_OTG                       = 9,
+    USB_DT_IAD                       = 0x0B,
+    USB_DT_BOS                       = 0x0F,
+    USB_DT_DEVICE_CAPABILITY         = 0x10,
 };
 
 /**
@@ -223,57 +217,57 @@ enum usb_capability_type {
  * To fill bmAttributes field of usb_capa_ext_desc_t structure.
  */
 enum usb_capability_extension_attr {
-    USB_DC_EXT_LPM  = 0x00000002,
+    USB_DC_EXT_LPM = 0x00000002,
 };
 
-#define HIRD_50_US    0
-#define HIRD_125_US   1
-#define HIRD_200_US   2
-#define HIRD_275_US   3
-#define HIRD_350_US   4
-#define HIRD_425_US   5
-#define HIRD_500_US   6
-#define HIRD_575_US  7
-#define HIRD_650_US  8
-#define HIRD_725_US  9
-#define HIRD_800_US  10
-#define HIRD_875_US  11
-#define HIRD_950_US  12
-#define HIRD_1025_US  13
-#define HIRD_1100_US  14
-#define HIRD_1175_US  15
+#define HIRD_50_US 0
+#define HIRD_125_US 1
+#define HIRD_200_US 2
+#define HIRD_275_US 3
+#define HIRD_350_US 4
+#define HIRD_425_US 5
+#define HIRD_500_US 6
+#define HIRD_575_US 7
+#define HIRD_650_US 8
+#define HIRD_725_US 9
+#define HIRD_800_US 10
+#define HIRD_875_US 11
+#define HIRD_950_US 12
+#define HIRD_1025_US 13
+#define HIRD_1100_US 14
+#define HIRD_1175_US 15
 
 /** Fields definition from a LPM TOKEN  */
-#define  USB_LPM_ATTRIBUT_BLINKSTATE_MASK      (0xF << 0)
-#define  USB_LPM_ATTRIBUT_FIRD_MASK            (0xF << 4)
-#define  USB_LPM_ATTRIBUT_REMOTEWAKE_MASK      (1 << 8)
-#define  USB_LPM_ATTRIBUT_BLINKSTATE(value)    ((value & 0xF) << 0)
-#define  USB_LPM_ATTRIBUT_FIRD(value)          ((value & 0xF) << 4)
-#define  USB_LPM_ATTRIBUT_REMOTEWAKE(value)    ((value & 1) << 8)
-#define  USB_LPM_ATTRIBUT_BLINKSTATE_L1        USB_LPM_ATTRIBUT_BLINKSTATE(1)
+#define USB_LPM_ATTRIBUT_BLINKSTATE_MASK (0xF << 0)
+#define USB_LPM_ATTRIBUT_FIRD_MASK (0xF << 4)
+#define USB_LPM_ATTRIBUT_REMOTEWAKE_MASK (1 << 8)
+#define USB_LPM_ATTRIBUT_BLINKSTATE(value) ((value & 0xF) << 0)
+#define USB_LPM_ATTRIBUT_FIRD(value) ((value & 0xF) << 4)
+#define USB_LPM_ATTRIBUT_REMOTEWAKE(value) ((value & 1) << 8)
+#define USB_LPM_ATTRIBUT_BLINKSTATE_L1 USB_LPM_ATTRIBUT_BLINKSTATE(1)
 
 /**
  * \brief Standard USB endpoint transfer types
  */
 enum usb_ep_type {
-    USB_EP_TYPE_CONTROL = 0x00,
+    USB_EP_TYPE_CONTROL     = 0x00,
     USB_EP_TYPE_ISOCHRONOUS = 0x01,
-    USB_EP_TYPE_BULK = 0x02,
-    USB_EP_TYPE_INTERRUPT = 0x03,
-    USB_EP_TYPE_MASK = 0x03,
+    USB_EP_TYPE_BULK        = 0x02,
+    USB_EP_TYPE_INTERRUPT   = 0x03,
+    USB_EP_TYPE_MASK        = 0x03,
 };
 
 /**
  * \brief Standard USB language IDs for string descriptors
  */
 enum usb_langid {
-    USB_LANGID_EN_US = 0x0409, //!< English (United States)
+    USB_LANGID_EN_US = 0x0409,  //!< English (United States)
 };
 
 /**
  * \brief Mask selecting the index part of an endpoint address
  */
-#define  USB_EP_ADDR_MASK     0x0f
+#define USB_EP_ADDR_MASK 0x0f
 
 //! \brief USB address identifier
 typedef uint8_t usb_add_t;
@@ -281,12 +275,12 @@ typedef uint8_t usb_add_t;
 /**
  * \brief Endpoint transfer direction is IN
  */
-#define  USB_EP_DIR_IN        0x80
+#define USB_EP_DIR_IN 0x80
 
 /**
  * \brief Endpoint transfer direction is OUT
  */
-#define  USB_EP_DIR_OUT       0x00
+#define USB_EP_DIR_OUT 0x00
 
 //! \brief Endpoint identifier
 typedef uint8_t usb_ep_t;
@@ -297,7 +291,7 @@ typedef uint8_t usb_ep_t;
  * The maximum length of a USB descriptor is limited by the 8-bit
  * bLength field.
  */
-#define  USB_MAX_DESC_LEN     255
+#define USB_MAX_DESC_LEN 255
 
 /*
  * 2-byte alignment requested for all USB structures.
@@ -312,9 +306,9 @@ COMPILER_PACK_SET(1)
 typedef struct {
     uint8_t bmRequestType;
     uint8_t bRequest;
-    le16_t wValue;
-    le16_t wIndex;
-    le16_t wLength;
+    le16_t  wValue;
+    le16_t  wIndex;
+    le16_t  wLength;
 } usb_setup_req_t;
 
 /**
@@ -323,14 +317,14 @@ typedef struct {
 typedef struct {
     uint8_t bLength;
     uint8_t bDescriptorType;
-    le16_t bcdUSB;
+    le16_t  bcdUSB;
     uint8_t bDeviceClass;
     uint8_t bDeviceSubClass;
     uint8_t bDeviceProtocol;
     uint8_t bMaxPacketSize0;
-    le16_t idVendor;
-    le16_t idProduct;
-    le16_t bcdDevice;
+    le16_t  idVendor;
+    le16_t  idProduct;
+    le16_t  bcdDevice;
     uint8_t iManufacturer;
     uint8_t iProduct;
     uint8_t iSerialNumber;
@@ -348,7 +342,7 @@ typedef struct {
 typedef struct {
     uint8_t bLength;
     uint8_t bDescriptorType;
-    le16_t bcdUSB;
+    le16_t  bcdUSB;
     uint8_t bDeviceClass;
     uint8_t bDeviceSubClass;
     uint8_t bDeviceProtocol;
@@ -376,7 +370,6 @@ typedef struct {
     uint8_t bNumDeviceCaps;
 } usb_dev_bos_desc_t;
 
-
 /**
  * \brief USB Device Capabilities - USB 2.0 Extension Descriptor structure
  *
@@ -395,7 +388,7 @@ typedef struct {
  * The BOS descriptor and capabilities descriptors for LPM.
  */
 typedef struct {
-    usb_dev_bos_desc_t bos;
+    usb_dev_bos_desc_t      bos;
     usb_dev_capa_ext_desc_t capa_ext;
 } usb_dev_lpm_desc_t;
 
@@ -403,24 +396,23 @@ typedef struct {
  * \brief Standard USB Interface Association Descriptor structure
  */
 typedef struct {
-    uint8_t bLength;          //!< size of this descriptor in bytes
-    uint8_t bDescriptorType;  //!< INTERFACE descriptor type
-    uint8_t bFirstInterface;  //!< Number of interface
-    uint8_t bInterfaceCount;  //!< value to select alternate setting
-    uint8_t bFunctionClass;   //!< Class code assigned by the USB
-    uint8_t bFunctionSubClass;//!< Sub-class code assigned by the USB
-    uint8_t bFunctionProtocol;//!< Protocol code assigned by the USB
-    uint8_t iFunction;        //!< Index of string descriptor
+    uint8_t bLength;            //!< size of this descriptor in bytes
+    uint8_t bDescriptorType;    //!< INTERFACE descriptor type
+    uint8_t bFirstInterface;    //!< Number of interface
+    uint8_t bInterfaceCount;    //!< value to select alternate setting
+    uint8_t bFunctionClass;     //!< Class code assigned by the USB
+    uint8_t bFunctionSubClass;  //!< Sub-class code assigned by the USB
+    uint8_t bFunctionProtocol;  //!< Protocol code assigned by the USB
+    uint8_t iFunction;          //!< Index of string descriptor
 } usb_association_desc_t;
 
-
 /**
  * \brief Standard USB configuration descriptor structure
  */
 typedef struct {
     uint8_t bLength;
     uint8_t bDescriptorType;
-    le16_t wTotalLength;
+    le16_t  wTotalLength;
     uint8_t bNumInterfaces;
     uint8_t bConfigurationValue;
     uint8_t iConfiguration;
@@ -428,26 +420,25 @@ typedef struct {
     uint8_t bMaxPower;
 } usb_conf_desc_t;
 
+#define USB_CONFIG_ATTR_MUST_SET (1 << 7)       //!< Must always be set
+#define USB_CONFIG_ATTR_BUS_POWERED (0 << 6)    //!< Bus-powered
+#define USB_CONFIG_ATTR_SELF_POWERED (1 << 6)   //!< Self-powered
+#define USB_CONFIG_ATTR_REMOTE_WAKEUP (1 << 5)  //!< remote wakeup supported
 
-#define  USB_CONFIG_ATTR_MUST_SET         (1 << 7) //!< Must always be set
-#define  USB_CONFIG_ATTR_BUS_POWERED      (0 << 6) //!< Bus-powered
-#define  USB_CONFIG_ATTR_SELF_POWERED     (1 << 6) //!< Self-powered
-#define  USB_CONFIG_ATTR_REMOTE_WAKEUP    (1 << 5) //!< remote wakeup supported
-
-#define  USB_CONFIG_MAX_POWER(ma)         (((ma) + 1) / 2) //!< Max power in mA
+#define USB_CONFIG_MAX_POWER(ma) (((ma) + 1) / 2)  //!< Max power in mA
 
 /**
  * \brief Standard USB association descriptor structure
  */
 typedef struct {
-    uint8_t bLength;              //!< Size of this descriptor in bytes
-    uint8_t bDescriptorType;      //!< Interface descriptor type
-    uint8_t bFirstInterface;      //!< Number of interface
-    uint8_t bInterfaceCount;      //!< value to select alternate setting
-    uint8_t bFunctionClass;       //!< Class code assigned by the USB
-    uint8_t bFunctionSubClass;    //!< Sub-class code assigned by the USB
-    uint8_t bFunctionProtocol;    //!< Protocol code assigned by the USB
-    uint8_t iFunction;            //!< Index of string descriptor
+    uint8_t bLength;            //!< Size of this descriptor in bytes
+    uint8_t bDescriptorType;    //!< Interface descriptor type
+    uint8_t bFirstInterface;    //!< Number of interface
+    uint8_t bInterfaceCount;    //!< value to select alternate setting
+    uint8_t bFunctionClass;     //!< Class code assigned by the USB
+    uint8_t bFunctionSubClass;  //!< Sub-class code assigned by the USB
+    uint8_t bFunctionProtocol;  //!< Protocol code assigned by the USB
+    uint8_t iFunction;          //!< Index of string descriptor
 } usb_iad_desc_t;
 
 /**
@@ -473,11 +464,10 @@ typedef struct {
     uint8_t bDescriptorType;
     uint8_t bEndpointAddress;
     uint8_t bmAttributes;
-    le16_t wMaxPacketSize;
+    le16_t  wMaxPacketSize;
     uint8_t bInterval;
 } usb_ep_desc_t;
 
-
 /**
  * \brief A standard USB string descriptor structure
  */
@@ -488,7 +478,7 @@ typedef struct {
 
 typedef struct {
     usb_str_desc_t desc;
-    le16_t string[1];
+    le16_t         string[1];
 } usb_str_lgid_desc_t;
 
 COMPILER_PACK_RESET()
diff --git a/tmk_core/protocol/arm_atsam/usb/usb_protocol_cdc.h b/tmk_core/protocol/arm_atsam/usb/usb_protocol_cdc.h
index 479f25d4e..aa639a6e5 100644
--- a/tmk_core/protocol/arm_atsam/usb/usb_protocol_cdc.h
+++ b/tmk_core/protocol/arm_atsam/usb/usb_protocol_cdc.h
@@ -50,144 +50,141 @@
 
 #ifdef CDC
 
-#define  CDC_CLASS_DEVICE     0x02  //!< USB Communication Device Class
-#define  CDC_CLASS_COMM       0x02  //!< CDC Communication Class Interface
-#define  CDC_CLASS_DATA       0x0A  //!< CDC Data Class Interface
-
-#define  CDC_SUBCLASS_DLCM    0x01  //!< Direct Line Control Model
-#define  CDC_SUBCLASS_ACM     0x02  //!< Abstract Control Model
-#define  CDC_SUBCLASS_TCM     0x03  //!< Telephone Control Model
-#define  CDC_SUBCLASS_MCCM    0x04  //!< Multi-Channel Control Model
-#define  CDC_SUBCLASS_CCM     0x05  //!< CAPI Control Model
-#define  CDC_SUBCLASS_ETH     0x06  //!< Ethernet Networking Control Model
-#define  CDC_SUBCLASS_ATM     0x07  //!< ATM Networking Control Model
-
-#define  CDC_PROTOCOL_V25TER  0x01  //!< Common AT commands
-
-#define  CDC_PROTOCOL_I430    0x30  //!< ISDN BRI
-#define  CDC_PROTOCOL_HDLC    0x31  //!< HDLC
-#define  CDC_PROTOCOL_TRANS   0x32  //!< Transparent
-#define  CDC_PROTOCOL_Q921M   0x50  //!< Q.921 management protocol
-#define  CDC_PROTOCOL_Q921    0x51  //!< Q.931 [sic] Data link protocol
-#define  CDC_PROTOCOL_Q921TM  0x52  //!< Q.921 TEI-multiplexor
-#define  CDC_PROTOCOL_V42BIS  0x90  //!< Data compression procedures
-#define  CDC_PROTOCOL_Q931    0x91  //!< Euro-ISDN protocol control
-#define  CDC_PROTOCOL_V120    0x92  //!< V.24 rate adaption to ISDN
-#define  CDC_PROTOCOL_CAPI20  0x93  //!< CAPI Commands
-#define  CDC_PROTOCOL_HOST    0xFD  //!< Host based driver
-
-#define  CDC_PROTOCOL_PUFD    0xFE
-
-#define  CDC_CS_INTERFACE     0x24  //!< Interface Functional Descriptor
-#define  CDC_CS_ENDPOINT      0x25  //!< Endpoint Functional Descriptor
-
-#define  CDC_SCS_HEADER       0x00  //!< Header Functional Descriptor
-#define  CDC_SCS_CALL_MGMT    0x01  //!< Call Management
-#define  CDC_SCS_ACM          0x02  //!< Abstract Control Management
-#define  CDC_SCS_UNION        0x06  //!< Union Functional Descriptor
-
-#define  USB_REQ_CDC_SEND_ENCAPSULATED_COMMAND                   0x00
-#define  USB_REQ_CDC_GET_ENCAPSULATED_RESPONSE                   0x01
-#define  USB_REQ_CDC_SET_COMM_FEATURE                            0x02
-#define  USB_REQ_CDC_GET_COMM_FEATURE                            0x03
-#define  USB_REQ_CDC_CLEAR_COMM_FEATURE                          0x04
-#define  USB_REQ_CDC_SET_AUX_LINE_STATE                          0x10
-#define  USB_REQ_CDC_SET_HOOK_STATE                              0x11
-#define  USB_REQ_CDC_PULSE_SETUP                                 0x12
-#define  USB_REQ_CDC_SEND_PULSE                                  0x13
-#define  USB_REQ_CDC_SET_PULSE_TIME                              0x14
-#define  USB_REQ_CDC_RING_AUX_JACK                               0x15
-#define  USB_REQ_CDC_SET_LINE_CODING                             0x20
-#define  USB_REQ_CDC_GET_LINE_CODING                             0x21
-#define  USB_REQ_CDC_SET_CONTROL_LINE_STATE                      0x22
-#define  USB_REQ_CDC_SEND_BREAK                                  0x23
-#define  USB_REQ_CDC_SET_RINGER_PARMS                            0x30
-#define  USB_REQ_CDC_GET_RINGER_PARMS                            0x31
-#define  USB_REQ_CDC_SET_OPERATION_PARMS                         0x32
-#define  USB_REQ_CDC_GET_OPERATION_PARMS                         0x33
-#define  USB_REQ_CDC_SET_LINE_PARMS                              0x34
-#define  USB_REQ_CDC_GET_LINE_PARMS                              0x35
-#define  USB_REQ_CDC_DIAL_DIGITS                                 0x36
-#define  USB_REQ_CDC_SET_UNIT_PARAMETER                          0x37
-#define  USB_REQ_CDC_GET_UNIT_PARAMETER                          0x38
-#define  USB_REQ_CDC_CLEAR_UNIT_PARAMETER                        0x39
-#define  USB_REQ_CDC_GET_PROFILE                                 0x3A
-#define  USB_REQ_CDC_SET_ETHERNET_MULTICAST_FILTERS              0x40
-#define  USB_REQ_CDC_SET_ETHERNET_POWER_MANAGEMENT_PATTERNFILTER 0x41
-#define  USB_REQ_CDC_GET_ETHERNET_POWER_MANAGEMENT_PATTERNFILTER 0x42
-#define  USB_REQ_CDC_SET_ETHERNET_PACKET_FILTER                  0x43
-#define  USB_REQ_CDC_GET_ETHERNET_STATISTIC                      0x44
-#define  USB_REQ_CDC_SET_ATM_DATA_FORMAT                         0x50
-#define  USB_REQ_CDC_GET_ATM_DEVICE_STATISTICS                   0x51
-#define  USB_REQ_CDC_SET_ATM_DEFAULT_VC                          0x52
-#define  USB_REQ_CDC_GET_ATM_VC_STATISTICS                       0x53
+#    define CDC_CLASS_DEVICE 0x02  //!< USB Communication Device Class
+#    define CDC_CLASS_COMM 0x02    //!< CDC Communication Class Interface
+#    define CDC_CLASS_DATA 0x0A    //!< CDC Data Class Interface
+
+#    define CDC_SUBCLASS_DLCM 0x01  //!< Direct Line Control Model
+#    define CDC_SUBCLASS_ACM 0x02   //!< Abstract Control Model
+#    define CDC_SUBCLASS_TCM 0x03   //!< Telephone Control Model
+#    define CDC_SUBCLASS_MCCM 0x04  //!< Multi-Channel Control Model
+#    define CDC_SUBCLASS_CCM 0x05   //!< CAPI Control Model
+#    define CDC_SUBCLASS_ETH 0x06   //!< Ethernet Networking Control Model
+#    define CDC_SUBCLASS_ATM 0x07   //!< ATM Networking Control Model
+
+#    define CDC_PROTOCOL_V25TER 0x01  //!< Common AT commands
+
+#    define CDC_PROTOCOL_I430 0x30    //!< ISDN BRI
+#    define CDC_PROTOCOL_HDLC 0x31    //!< HDLC
+#    define CDC_PROTOCOL_TRANS 0x32   //!< Transparent
+#    define CDC_PROTOCOL_Q921M 0x50   //!< Q.921 management protocol
+#    define CDC_PROTOCOL_Q921 0x51    //!< Q.931 [sic] Data link protocol
+#    define CDC_PROTOCOL_Q921TM 0x52  //!< Q.921 TEI-multiplexor
+#    define CDC_PROTOCOL_V42BIS 0x90  //!< Data compression procedures
+#    define CDC_PROTOCOL_Q931 0x91    //!< Euro-ISDN protocol control
+#    define CDC_PROTOCOL_V120 0x92    //!< V.24 rate adaption to ISDN
+#    define CDC_PROTOCOL_CAPI20 0x93  //!< CAPI Commands
+#    define CDC_PROTOCOL_HOST 0xFD    //!< Host based driver
+
+#    define CDC_PROTOCOL_PUFD 0xFE
+
+#    define CDC_CS_INTERFACE 0x24  //!< Interface Functional Descriptor
+#    define CDC_CS_ENDPOINT 0x25   //!< Endpoint Functional Descriptor
+
+#    define CDC_SCS_HEADER 0x00     //!< Header Functional Descriptor
+#    define CDC_SCS_CALL_MGMT 0x01  //!< Call Management
+#    define CDC_SCS_ACM 0x02        //!< Abstract Control Management
+#    define CDC_SCS_UNION 0x06      //!< Union Functional Descriptor
+
+#    define USB_REQ_CDC_SEND_ENCAPSULATED_COMMAND 0x00
+#    define USB_REQ_CDC_GET_ENCAPSULATED_RESPONSE 0x01
+#    define USB_REQ_CDC_SET_COMM_FEATURE 0x02
+#    define USB_REQ_CDC_GET_COMM_FEATURE 0x03
+#    define USB_REQ_CDC_CLEAR_COMM_FEATURE 0x04
+#    define USB_REQ_CDC_SET_AUX_LINE_STATE 0x10
+#    define USB_REQ_CDC_SET_HOOK_STATE 0x11
+#    define USB_REQ_CDC_PULSE_SETUP 0x12
+#    define USB_REQ_CDC_SEND_PULSE 0x13
+#    define USB_REQ_CDC_SET_PULSE_TIME 0x14
+#    define USB_REQ_CDC_RING_AUX_JACK 0x15
+#    define USB_REQ_CDC_SET_LINE_CODING 0x20
+#    define USB_REQ_CDC_GET_LINE_CODING 0x21
+#    define USB_REQ_CDC_SET_CONTROL_LINE_STATE 0x22
+#    define USB_REQ_CDC_SEND_BREAK 0x23
+#    define USB_REQ_CDC_SET_RINGER_PARMS 0x30
+#    define USB_REQ_CDC_GET_RINGER_PARMS 0x31
+#    define USB_REQ_CDC_SET_OPERATION_PARMS 0x32
+#    define USB_REQ_CDC_GET_OPERATION_PARMS 0x33
+#    define USB_REQ_CDC_SET_LINE_PARMS 0x34
+#    define USB_REQ_CDC_GET_LINE_PARMS 0x35
+#    define USB_REQ_CDC_DIAL_DIGITS 0x36
+#    define USB_REQ_CDC_SET_UNIT_PARAMETER 0x37
+#    define USB_REQ_CDC_GET_UNIT_PARAMETER 0x38
+#    define USB_REQ_CDC_CLEAR_UNIT_PARAMETER 0x39
+#    define USB_REQ_CDC_GET_PROFILE 0x3A
+#    define USB_REQ_CDC_SET_ETHERNET_MULTICAST_FILTERS 0x40
+#    define USB_REQ_CDC_SET_ETHERNET_POWER_MANAGEMENT_PATTERNFILTER 0x41
+#    define USB_REQ_CDC_GET_ETHERNET_POWER_MANAGEMENT_PATTERNFILTER 0x42
+#    define USB_REQ_CDC_SET_ETHERNET_PACKET_FILTER 0x43
+#    define USB_REQ_CDC_GET_ETHERNET_STATISTIC 0x44
+#    define USB_REQ_CDC_SET_ATM_DATA_FORMAT 0x50
+#    define USB_REQ_CDC_GET_ATM_DEVICE_STATISTICS 0x51
+#    define USB_REQ_CDC_SET_ATM_DEFAULT_VC 0x52
+#    define USB_REQ_CDC_GET_ATM_VC_STATISTICS 0x53
 // Added bNotification codes according cdc spec 1.1 chapter 6.3
-#define  USB_REQ_CDC_NOTIFY_RING_DETECT                          0x09
-#define  USB_REQ_CDC_NOTIFY_SERIAL_STATE                         0x20
-#define  USB_REQ_CDC_NOTIFY_CALL_STATE_CHANGE                    0x28
-#define  USB_REQ_CDC_NOTIFY_LINE_STATE_CHANGE                    0x29
-
-
-#define  CDC_CALL_MGMT_SUPPORTED             (1 << 0)
-#define  CDC_CALL_MGMT_OVER_DCI              (1 << 1)
-#define  CDC_ACM_SUPPORT_FEATURE_REQUESTS    (1 << 0)
-#define  CDC_ACM_SUPPORT_LINE_REQUESTS       (1 << 1)
-#define  CDC_ACM_SUPPORT_SENDBREAK_REQUESTS  (1 << 2)
-#define  CDC_ACM_SUPPORT_NOTIFY_REQUESTS     (1 << 3)
-
-#pragma pack(push,1)
+#    define USB_REQ_CDC_NOTIFY_RING_DETECT 0x09
+#    define USB_REQ_CDC_NOTIFY_SERIAL_STATE 0x20
+#    define USB_REQ_CDC_NOTIFY_CALL_STATE_CHANGE 0x28
+#    define USB_REQ_CDC_NOTIFY_LINE_STATE_CHANGE 0x29
+
+#    define CDC_CALL_MGMT_SUPPORTED (1 << 0)
+#    define CDC_CALL_MGMT_OVER_DCI (1 << 1)
+#    define CDC_ACM_SUPPORT_FEATURE_REQUESTS (1 << 0)
+#    define CDC_ACM_SUPPORT_LINE_REQUESTS (1 << 1)
+#    define CDC_ACM_SUPPORT_SENDBREAK_REQUESTS (1 << 2)
+#    define CDC_ACM_SUPPORT_NOTIFY_REQUESTS (1 << 3)
+
+#    pragma pack(push, 1)
 typedef struct {
-    le32_t dwDTERate;
+    le32_t  dwDTERate;
     uint8_t bCharFormat;
     uint8_t bParityType;
     uint8_t bDataBits;
 } usb_cdc_line_coding_t;
-#pragma pack(pop)
+#    pragma pack(pop)
 
 enum cdc_char_format {
-    CDC_STOP_BITS_1 = 0,    //!< 1 stop bit
+    CDC_STOP_BITS_1   = 0,  //!< 1 stop bit
     CDC_STOP_BITS_1_5 = 1,  //!< 1.5 stop bits
-    CDC_STOP_BITS_2 = 2,    //!< 2 stop bits
+    CDC_STOP_BITS_2   = 2,  //!< 2 stop bits
 };
 
 enum cdc_parity {
-    CDC_PAR_NONE = 0,   //!< No parity
-    CDC_PAR_ODD = 1,    //!< Odd parity
-    CDC_PAR_EVEN = 2,   //!< Even parity
-    CDC_PAR_MARK = 3,   //!< Parity forced to 0 (space)
+    CDC_PAR_NONE  = 0,  //!< No parity
+    CDC_PAR_ODD   = 1,  //!< Odd parity
+    CDC_PAR_EVEN  = 2,  //!< Even parity
+    CDC_PAR_MARK  = 3,  //!< Parity forced to 0 (space)
     CDC_PAR_SPACE = 4,  //!< Parity forced to 1 (mark)
 };
 
-
 typedef struct {
     uint16_t value;
 } usb_cdc_control_signal_t;
 
-#define  CDC_CTRL_SIGNAL_ACTIVATE_CARRIER    (1 << 1)
-#define  CDC_CTRL_SIGNAL_DTE_PRESENT         (1 << 0)
-
+#    define CDC_CTRL_SIGNAL_ACTIVATE_CARRIER (1 << 1)
+#    define CDC_CTRL_SIGNAL_DTE_PRESENT (1 << 0)
 
 typedef struct {
     uint8_t bmRequestType;
     uint8_t bNotification;
-    le16_t wValue;
-    le16_t wIndex;
-    le16_t wLength;
+    le16_t  wValue;
+    le16_t  wIndex;
+    le16_t  wLength;
 } usb_cdc_notify_msg_t;
 
 typedef struct {
     usb_cdc_notify_msg_t header;
-    le16_t value;
+    le16_t               value;
 } usb_cdc_notify_serial_state_t;
 
-#define  CDC_SERIAL_STATE_DCD       CPU_TO_LE16((1<<0))
-#define  CDC_SERIAL_STATE_DSR       CPU_TO_LE16((1<<1))
-#define  CDC_SERIAL_STATE_BREAK     CPU_TO_LE16((1<<2))
-#define  CDC_SERIAL_STATE_RING      CPU_TO_LE16((1<<3))
-#define  CDC_SERIAL_STATE_FRAMING   CPU_TO_LE16((1<<4))
-#define  CDC_SERIAL_STATE_PARITY    CPU_TO_LE16((1<<5))
-#define  CDC_SERIAL_STATE_OVERRUN   CPU_TO_LE16((1<<6))
+#    define CDC_SERIAL_STATE_DCD CPU_TO_LE16((1 << 0))
+#    define CDC_SERIAL_STATE_DSR CPU_TO_LE16((1 << 1))
+#    define CDC_SERIAL_STATE_BREAK CPU_TO_LE16((1 << 2))
+#    define CDC_SERIAL_STATE_RING CPU_TO_LE16((1 << 3))
+#    define CDC_SERIAL_STATE_FRAMING CPU_TO_LE16((1 << 4))
+#    define CDC_SERIAL_STATE_PARITY CPU_TO_LE16((1 << 5))
+#    define CDC_SERIAL_STATE_OVERRUN CPU_TO_LE16((1 << 6))
 
 #endif
 
-#endif // _USB_PROTOCOL_CDC_H_
+#endif  // _USB_PROTOCOL_CDC_H_
diff --git a/tmk_core/protocol/arm_atsam/usb/usb_protocol_hid.h b/tmk_core/protocol/arm_atsam/usb/usb_protocol_hid.h
index c482e9c06..2f8a39bdd 100644
--- a/tmk_core/protocol/arm_atsam/usb/usb_protocol_hid.h
+++ b/tmk_core/protocol/arm_atsam/usb/usb_protocol_hid.h
@@ -58,64 +58,62 @@
 
 //! \name Possible Class value
 //@{
-#define  HID_CLASS                            0x03
+#define HID_CLASS 0x03
 //@}
 
 //! \name Possible SubClass value
 //@{
 //! Interface subclass NO support BOOT protocol
-#define  HID_SUB_CLASS_NOBOOT                 0x00
+#define HID_SUB_CLASS_NOBOOT 0x00
 //! Interface subclass support BOOT protocol
-#define  HID_SUB_CLASS_BOOT                   0x01
+#define HID_SUB_CLASS_BOOT 0x01
 //@}
 
 //! \name Possible protocol value
 //@{
 //! Protocol generic standard
-#define  HID_PROTOCOL_GENERIC                 0x00
+#define HID_PROTOCOL_GENERIC 0x00
 //! Protocol keyboard standard
-#define  HID_PROTOCOL_KEYBOARD                0x01
+#define HID_PROTOCOL_KEYBOARD 0x01
 //! Protocol mouse standard
-#define  HID_PROTOCOL_MOUSE                   0x02
+#define HID_PROTOCOL_MOUSE 0x02
 //@}
 
-
 //! \brief Hid USB requests (bRequest)
 enum usb_reqid_hid {
-    USB_REQ_HID_GET_REPORT = 0x01,
-    USB_REQ_HID_GET_IDLE = 0x02,
+    USB_REQ_HID_GET_REPORT   = 0x01,
+    USB_REQ_HID_GET_IDLE     = 0x02,
     USB_REQ_HID_GET_PROTOCOL = 0x03,
-    USB_REQ_HID_SET_REPORT = 0x09,
-    USB_REQ_HID_SET_IDLE = 0x0A,
+    USB_REQ_HID_SET_REPORT   = 0x09,
+    USB_REQ_HID_SET_IDLE     = 0x0A,
     USB_REQ_HID_SET_PROTOCOL = 0x0B,
 };
 
 //! \brief HID USB descriptor types
 enum usb_descriptor_type_hid {
-    USB_DT_HID = 0x21,
-    USB_DT_HID_REPORT = 0x22,
+    USB_DT_HID          = 0x21,
+    USB_DT_HID_REPORT   = 0x22,
     USB_DT_HID_PHYSICAL = 0x23,
 };
 
 //! \brief HID Type for report descriptor
 enum usb_hid_item_report_type {
-    USB_HID_ITEM_REPORT_TYPE_MAIN = 0,
+    USB_HID_ITEM_REPORT_TYPE_MAIN   = 0,
     USB_HID_ITEM_REPORT_TYPE_GLOBAL = 1,
-    USB_HID_ITEM_REPORT_TYPE_LOCAL = 2,
-    USB_HID_ITEM_REPORT_TYPE_LONG = 3,
+    USB_HID_ITEM_REPORT_TYPE_LOCAL  = 2,
+    USB_HID_ITEM_REPORT_TYPE_LONG   = 3,
 };
 
 //! \brief HID report type
 enum usb_hid_report_type {
-    USB_HID_REPORT_TYPE_INPUT = 1,
-    USB_HID_REPORT_TYPE_OUTPUT = 2,
+    USB_HID_REPORT_TYPE_INPUT   = 1,
+    USB_HID_REPORT_TYPE_OUTPUT  = 2,
     USB_HID_REPORT_TYPE_FEATURE = 3,
 };
 
-
 //! \brief HID protocol
 enum usb_hid_protocol {
-    USB_HID_PROCOTOL_BOOT = 0,
+    USB_HID_PROCOTOL_BOOT   = 0,
     USB_HID_PROCOTOL_REPORT = 1,
 };
 
@@ -123,197 +121,196 @@ COMPILER_PACK_SET(1)
 
 //! \brief HID Descriptor
 typedef struct {
-    uint8_t bLength;          //!< Size of this descriptor in bytes
-    uint8_t bDescriptorType;  //!< HID descriptor type
-    le16_t bcdHID;            //!< Binary Coded Decimal Spec. release
-    uint8_t bCountryCode;     //!< Hardware target country
-    uint8_t bNumDescriptors;  //!< Number of HID class descriptors to follow
-    uint8_t bRDescriptorType; //!< Report descriptor type
-    le16_t wDescriptorLength; //!< Total length of Report descriptor
+    uint8_t bLength;            //!< Size of this descriptor in bytes
+    uint8_t bDescriptorType;    //!< HID descriptor type
+    le16_t  bcdHID;             //!< Binary Coded Decimal Spec. release
+    uint8_t bCountryCode;       //!< Hardware target country
+    uint8_t bNumDescriptors;    //!< Number of HID class descriptors to follow
+    uint8_t bRDescriptorType;   //!< Report descriptor type
+    le16_t  wDescriptorLength;  //!< Total length of Report descriptor
 } usb_hid_descriptor_t;
 
 COMPILER_PACK_RESET()
 
-   //! \name HID Report type
-   //! Used by SETUP_HID_GET_REPORT & SETUP_HID_SET_REPORT
-   //! @{
-#define  REPORT_TYPE_INPUT                    0x01
-#define  REPORT_TYPE_OUTPUT                   0x02
-#define  REPORT_TYPE_FEATURE                  0x03
-   //! @}
+//! \name HID Report type
+//! Used by SETUP_HID_GET_REPORT & SETUP_HID_SET_REPORT
+//! @{
+#define REPORT_TYPE_INPUT 0x01
+#define REPORT_TYPE_OUTPUT 0x02
+#define REPORT_TYPE_FEATURE 0x03
+//! @}
 
-   //! \name Constants of field DESCRIPTOR_HID
-   //! @{
+//! \name Constants of field DESCRIPTOR_HID
+//! @{
 //! Numeric expression identifying the HID Class
 //! Specification release (here V1.11)
-#define  USB_HID_BDC_V1_11                    0x0111
+#define USB_HID_BDC_V1_11 0x0111
 //! Numeric expression specifying the number of class descriptors
 //! Note: Always at least one i.e. Report descriptor.
-#define  USB_HID_NUM_DESC                     0x01
+#define USB_HID_NUM_DESC 0x01
 
-      //! \name Country code
-      //! @{
-#define  USB_HID_NO_COUNTRY_CODE            0   // Not Supported
-#define  USB_HID_COUNTRY_ARABIC             1   // Arabic
-#define  USB_HID_COUNTRY_BELGIAN            2   // Belgian
-#define  USB_HID_COUNTRY_CANADIAN_BILINGUAL 3   // Canadian-Bilingual
-#define  USB_HID_COUNTRY_CANADIAN_FRENCH    4   // Canadian-French
-#define  USB_HID_COUNTRY_CZECH_REPUBLIC     5   // Czech Republic
-#define  USB_HID_COUNTRY_DANISH             6   // Danish
-#define  USB_HID_COUNTRY_FINNISH            7   // Finnish
-#define  USB_HID_COUNTRY_FRENCH             8   // French
-#define  USB_HID_COUNTRY_GERMAN             9   // German
-#define  USB_HID_COUNTRY_GREEK              10  // Greek
-#define  USB_HID_COUNTRY_HEBREW             11  // Hebrew
-#define  USB_HID_COUNTRY_HUNGARY            12  // Hungary
-#define  USB_HID_COUNTRY_INTERNATIONAL_ISO  13  // International (ISO)
-#define  USB_HID_COUNTRY_ITALIAN            14  // Italian
-#define  USB_HID_COUNTRY_JAPAN_KATAKANA     15  // Japan (Katakana)
-#define  USB_HID_COUNTRY_KOREAN             16  // Korean
-#define  USB_HID_COUNTRY_LATIN_AMERICAN     17  // Latin American
-#define  USB_HID_COUNTRY_NETHERLANDS_DUTCH  18  // Netherlands/Dutch
-#define  USB_HID_COUNTRY_NORWEGIAN          19  // Norwegian
-#define  USB_HID_COUNTRY_PERSIAN_FARSI      20  // Persian (Farsi)
-#define  USB_HID_COUNTRY_POLAND             21  // Poland
-#define  USB_HID_COUNTRY_PORTUGUESE         22  // Portuguese
-#define  USB_HID_COUNTRY_RUSSIA             23  // Russia
-#define  USB_HID_COUNTRY_SLOVAKIA           24  // Slovakia
-#define  USB_HID_COUNTRY_SPANISH            25  // Spanish
-#define  USB_HID_COUNTRY_SWEDISH            26  // Swedish
-#define  USB_HID_COUNTRY_SWISS_FRENCH       27  // Swiss/French
-#define  USB_HID_COUNTRY_SWISS_GERMAN       28  // Swiss/German
-#define  USB_HID_COUNTRY_SWITZERLAND        29  // Switzerland
-#define  USB_HID_COUNTRY_TAIWAN             30  // Taiwan
-#define  USB_HID_COUNTRY_TURKISH_Q          31  // Turkish-Q
-#define  USB_HID_COUNTRY_UK                 32  // UK
-#define  USB_HID_COUNTRY_US                 33  // US
-#define  USB_HID_COUNTRY_YUGOSLAVIA         34  // Yugoslavia
-#define  USB_HID_COUNTRY_TURKISH_F          35  // Turkish-F
-      //! @}
-   //! @}
+//! \name Country code
+//! @{
+#define USB_HID_NO_COUNTRY_CODE 0             // Not Supported
+#define USB_HID_COUNTRY_ARABIC 1              // Arabic
+#define USB_HID_COUNTRY_BELGIAN 2             // Belgian
+#define USB_HID_COUNTRY_CANADIAN_BILINGUAL 3  // Canadian-Bilingual
+#define USB_HID_COUNTRY_CANADIAN_FRENCH 4     // Canadian-French
+#define USB_HID_COUNTRY_CZECH_REPUBLIC 5      // Czech Republic
+#define USB_HID_COUNTRY_DANISH 6              // Danish
+#define USB_HID_COUNTRY_FINNISH 7             // Finnish
+#define USB_HID_COUNTRY_FRENCH 8              // French
+#define USB_HID_COUNTRY_GERMAN 9              // German
+#define USB_HID_COUNTRY_GREEK 10              // Greek
+#define USB_HID_COUNTRY_HEBREW 11             // Hebrew
+#define USB_HID_COUNTRY_HUNGARY 12            // Hungary
+#define USB_HID_COUNTRY_INTERNATIONAL_ISO 13  // International (ISO)
+#define USB_HID_COUNTRY_ITALIAN 14            // Italian
+#define USB_HID_COUNTRY_JAPAN_KATAKANA 15     // Japan (Katakana)
+#define USB_HID_COUNTRY_KOREAN 16             // Korean
+#define USB_HID_COUNTRY_LATIN_AMERICAN 17     // Latin American
+#define USB_HID_COUNTRY_NETHERLANDS_DUTCH 18  // Netherlands/Dutch
+#define USB_HID_COUNTRY_NORWEGIAN 19          // Norwegian
+#define USB_HID_COUNTRY_PERSIAN_FARSI 20      // Persian (Farsi)
+#define USB_HID_COUNTRY_POLAND 21             // Poland
+#define USB_HID_COUNTRY_PORTUGUESE 22         // Portuguese
+#define USB_HID_COUNTRY_RUSSIA 23             // Russia
+#define USB_HID_COUNTRY_SLOVAKIA 24           // Slovakia
+#define USB_HID_COUNTRY_SPANISH 25            // Spanish
+#define USB_HID_COUNTRY_SWEDISH 26            // Swedish
+#define USB_HID_COUNTRY_SWISS_FRENCH 27       // Swiss/French
+#define USB_HID_COUNTRY_SWISS_GERMAN 28       // Swiss/German
+#define USB_HID_COUNTRY_SWITZERLAND 29        // Switzerland
+#define USB_HID_COUNTRY_TAIWAN 30             // Taiwan
+#define USB_HID_COUNTRY_TURKISH_Q 31          // Turkish-Q
+#define USB_HID_COUNTRY_UK 32                 // UK
+#define USB_HID_COUNTRY_US 33                 // US
+#define USB_HID_COUNTRY_YUGOSLAVIA 34         // Yugoslavia
+#define USB_HID_COUNTRY_TURKISH_F 35          // Turkish-F
+                                              //! @}
+                                              //! @}
 //! @}
 
-
 //! \name HID KEYS values
 //! @{
-#define  HID_A                0x04
-#define  HID_B                0x05
-#define  HID_C                0x06
-#define  HID_D                0x07
-#define  HID_E                0x08
-#define  HID_F                0x09
-#define  HID_G                0x0A
-#define  HID_H                0x0B
-#define  HID_I                0x0C
-#define  HID_J                0x0D
-#define  HID_K                0x0E
-#define  HID_L                0x0F
-#define  HID_M                0x10
-#define  HID_N                0x11
-#define  HID_O                0x12
-#define  HID_P                0x13
-#define  HID_Q                0x14
-#define  HID_R                0x15
-#define  HID_S                0x16
-#define  HID_T                0x17
-#define  HID_U                0x18
-#define  HID_V                0x19
-#define  HID_W                0x1A
-#define  HID_X                0x1B
-#define  HID_Y                0x1C
-#define  HID_Z                0x1D
-#define  HID_1                30
-#define  HID_2                31
-#define  HID_3                32
-#define  HID_4                33
-#define  HID_5                34
-#define  HID_6                35
-#define  HID_7                36
-#define  HID_8                37
-#define  HID_9                38
-#define  HID_0                39
-#define  HID_ENTER            40
-#define  HID_ESCAPE           41
-#define  HID_BACKSPACE        42
-#define  HID_TAB              43
-#define  HID_SPACEBAR         44
-#define  HID_UNDERSCORE       45
-#define  HID_PLUS             46
-#define  HID_OPEN_BRACKET     47 // {
-#define  HID_CLOSE_BRACKET    48 // }
-#define  HID_BACKSLASH        49
-#define  HID_ASH              50 // # ~
-#define  HID_COLON            51 // ; :
-#define  HID_QUOTE            52 // ' "
-#define  HID_TILDE            53
-#define  HID_COMMA            54
-#define  HID_DOT              55
-#define  HID_SLASH            56
-#define  HID_CAPS_LOCK        57
-#define  HID_F1               58
-#define  HID_F2               59
-#define  HID_F3               60
-#define  HID_F4               61
-#define  HID_F5               62
-#define  HID_F6               63
-#define  HID_F7               64
-#define  HID_F8               65
-#define  HID_F9               66
-#define  HID_F10              67
-#define  HID_F11              68
-#define  HID_F12              69
-#define  HID_PRINTSCREEN      70
-#define  HID_SCROLL_LOCK      71
-#define  HID_PAUSE            72
-#define  HID_INSERT           73
-#define  HID_HOME             74
-#define  HID_PAGEUP           75
-#define  HID_DELETE           76
-#define  HID_END              77
-#define  HID_PAGEDOWN         78
-#define  HID_RIGHT            79
-#define  HID_LEFT             80
-#define  HID_DOWN             81
-#define  HID_UP               82
-#define  HID_KEYPAD_NUM_LOCK  83
-#define  HID_KEYPAD_DIVIDE    84
-#define  HID_KEYPAD_AT        85
-#define  HID_KEYPAD_MULTIPLY  85
-#define  HID_KEYPAD_MINUS     86
-#define  HID_KEYPAD_PLUS      87
-#define  HID_KEYPAD_ENTER     88
-#define  HID_KEYPAD_1         89
-#define  HID_KEYPAD_2         90
-#define  HID_KEYPAD_3         91
-#define  HID_KEYPAD_4         92
-#define  HID_KEYPAD_5         93
-#define  HID_KEYPAD_6         94
-#define  HID_KEYPAD_7         95
-#define  HID_KEYPAD_8         96
-#define  HID_KEYPAD_9         97
-#define  HID_KEYPAD_0         98
+#define HID_A 0x04
+#define HID_B 0x05
+#define HID_C 0x06
+#define HID_D 0x07
+#define HID_E 0x08
+#define HID_F 0x09
+#define HID_G 0x0A
+#define HID_H 0x0B
+#define HID_I 0x0C
+#define HID_J 0x0D
+#define HID_K 0x0E
+#define HID_L 0x0F
+#define HID_M 0x10
+#define HID_N 0x11
+#define HID_O 0x12
+#define HID_P 0x13
+#define HID_Q 0x14
+#define HID_R 0x15
+#define HID_S 0x16
+#define HID_T 0x17
+#define HID_U 0x18
+#define HID_V 0x19
+#define HID_W 0x1A
+#define HID_X 0x1B
+#define HID_Y 0x1C
+#define HID_Z 0x1D
+#define HID_1 30
+#define HID_2 31
+#define HID_3 32
+#define HID_4 33
+#define HID_5 34
+#define HID_6 35
+#define HID_7 36
+#define HID_8 37
+#define HID_9 38
+#define HID_0 39
+#define HID_ENTER 40
+#define HID_ESCAPE 41
+#define HID_BACKSPACE 42
+#define HID_TAB 43
+#define HID_SPACEBAR 44
+#define HID_UNDERSCORE 45
+#define HID_PLUS 46
+#define HID_OPEN_BRACKET 47   // {
+#define HID_CLOSE_BRACKET 48  // }
+#define HID_BACKSLASH 49
+#define HID_ASH 50    // # ~
+#define HID_COLON 51  // ; :
+#define HID_QUOTE 52  // ' "
+#define HID_TILDE 53
+#define HID_COMMA 54
+#define HID_DOT 55
+#define HID_SLASH 56
+#define HID_CAPS_LOCK 57
+#define HID_F1 58
+#define HID_F2 59
+#define HID_F3 60
+#define HID_F4 61
+#define HID_F5 62
+#define HID_F6 63
+#define HID_F7 64
+#define HID_F8 65
+#define HID_F9 66
+#define HID_F10 67
+#define HID_F11 68
+#define HID_F12 69
+#define HID_PRINTSCREEN 70
+#define HID_SCROLL_LOCK 71
+#define HID_PAUSE 72
+#define HID_INSERT 73
+#define HID_HOME 74
+#define HID_PAGEUP 75
+#define HID_DELETE 76
+#define HID_END 77
+#define HID_PAGEDOWN 78
+#define HID_RIGHT 79
+#define HID_LEFT 80
+#define HID_DOWN 81
+#define HID_UP 82
+#define HID_KEYPAD_NUM_LOCK 83
+#define HID_KEYPAD_DIVIDE 84
+#define HID_KEYPAD_AT 85
+#define HID_KEYPAD_MULTIPLY 85
+#define HID_KEYPAD_MINUS 86
+#define HID_KEYPAD_PLUS 87
+#define HID_KEYPAD_ENTER 88
+#define HID_KEYPAD_1 89
+#define HID_KEYPAD_2 90
+#define HID_KEYPAD_3 91
+#define HID_KEYPAD_4 92
+#define HID_KEYPAD_5 93
+#define HID_KEYPAD_6 94
+#define HID_KEYPAD_7 95
+#define HID_KEYPAD_8 96
+#define HID_KEYPAD_9 97
+#define HID_KEYPAD_0 98
 
-   //! \name HID modifier values
-   //! @{
-#define  HID_MODIFIER_NONE          0x00
-#define  HID_MODIFIER_LEFT_CTRL     0x01
-#define  HID_MODIFIER_LEFT_SHIFT    0x02
-#define  HID_MODIFIER_LEFT_ALT      0x04
-#define  HID_MODIFIER_LEFT_UI       0x08
-#define  HID_MODIFIER_RIGHT_CTRL    0x10
-#define  HID_MODIFIER_RIGHT_SHIFT   0x20
-#define  HID_MODIFIER_RIGHT_ALT     0x40
-#define  HID_MODIFIER_RIGHT_UI      0x80
-   //! @}
+//! \name HID modifier values
+//! @{
+#define HID_MODIFIER_NONE 0x00
+#define HID_MODIFIER_LEFT_CTRL 0x01
+#define HID_MODIFIER_LEFT_SHIFT 0x02
+#define HID_MODIFIER_LEFT_ALT 0x04
+#define HID_MODIFIER_LEFT_UI 0x08
+#define HID_MODIFIER_RIGHT_CTRL 0x10
+#define HID_MODIFIER_RIGHT_SHIFT 0x20
+#define HID_MODIFIER_RIGHT_ALT 0x40
+#define HID_MODIFIER_RIGHT_UI 0x80
+//! @}
 //! @}
 
 //! \name HID KEYS values
 //! @{
-#define  HID_LED_NUM_LOCK           (1<<0)
-#define  HID_LED_CAPS_LOCK          (1<<1)
-#define  HID_LED_SCROLL_LOCK        (1<<2)
-#define  HID_LED_COMPOSE            (1<<3)
-#define  HID_LED_KANA               (1<<4)
+#define HID_LED_NUM_LOCK (1 << 0)
+#define HID_LED_CAPS_LOCK (1 << 1)
+#define HID_LED_SCROLL_LOCK (1 << 2)
+#define HID_LED_COMPOSE (1 << 3)
+#define HID_LED_KANA (1 << 4)
 //! @}
 
-#endif // _USB_PROTOCOL_HID_H_
+#endif  // _USB_PROTOCOL_HID_H_
diff --git a/tmk_core/protocol/arm_atsam/usb/usb_util.c b/tmk_core/protocol/arm_atsam/usb/usb_util.c
index 58b349362..a682c00b5 100644
--- a/tmk_core/protocol/arm_atsam/usb/usb_util.c
+++ b/tmk_core/protocol/arm_atsam/usb/usb_util.c
@@ -2,58 +2,42 @@
 #include "string.h"
 #include "usb_util.h"
 
-char digit(int d, int radix)
-{
-    if (d < 10)
-    {
+char digit(int d, int radix) {
+    if (d < 10) {
         return d + '0';
-    }
-    else
-    {
+    } else {
         return d - 10 + 'A';
     }
 }
 
-int UTIL_ltoa_radix(int64_t value, char *dest, int radix)
-{
-    int64_t original = value;       //save original value
-    char buf[25] = "";
-    int c = sizeof(buf)-1;
-    int last = c;
-    int d;
-    int size;
+int UTIL_ltoa_radix(int64_t value, char *dest, int radix) {
+    int64_t original = value;  // save original value
+    char    buf[25]  = "";
+    int     c        = sizeof(buf) - 1;
+    int     last     = c;
+    int     d;
+    int     size;
 
-    if (value < 0)                  //if it's negative, take the absolute value
+    if (value < 0)  // if it's negative, take the absolute value
         value = -value;
 
-    do                              //write least significant digit of value that's left
+    do  // write least significant digit of value that's left
     {
-        d = (value % radix);
+        d        = (value % radix);
         buf[--c] = digit(d, radix);
         value /= radix;
     } while (value);
 
-    if (original < 0)
-        buf[--c] = '-';
+    if (original < 0) buf[--c] = '-';
 
-    size = last - c + 1;            //includes null at end
+    size = last - c + 1;  // includes null at end
     memcpy(dest, &buf[c], last - c + 1);
 
-    return (size - 1);              //without null termination
+    return (size - 1);  // without null termination
 }
 
-int UTIL_ltoa(int64_t value, char *dest)
-{
-    return UTIL_ltoa_radix(value, dest, 10);
-}
+int UTIL_ltoa(int64_t value, char *dest) { return UTIL_ltoa_radix(value, dest, 10); }
 
-int UTIL_itoa(int value, char *dest)
-{
-    return UTIL_ltoa_radix((int64_t)value, dest, 10);
-}
-
-int UTIL_utoa(uint32_t value, char *dest)
-{
-    return UTIL_ltoa_radix((int64_t)value, dest, 10);
-}
+int UTIL_itoa(int value, char *dest) { return UTIL_ltoa_radix((int64_t)value, dest, 10); }
 
+int UTIL_utoa(uint32_t value, char *dest) { return UTIL_ltoa_radix((int64_t)value, dest, 10); }
diff --git a/tmk_core/protocol/arm_atsam/usb/usb_util.h b/tmk_core/protocol/arm_atsam/usb/usb_util.h
index 2134d5d27..3bad2c26f 100644
--- a/tmk_core/protocol/arm_atsam/usb/usb_util.h
+++ b/tmk_core/protocol/arm_atsam/usb/usb_util.h
@@ -6,5 +6,4 @@ int UTIL_ltoa(int64_t value, char *dest);
 int UTIL_itoa(int value, char *dest);
 int UTIL_utoa(uint32_t value, char *dest);
 
-#endif //_USB_UTIL_H_
-
+#endif  //_USB_UTIL_H_
diff --git a/tmk_core/protocol/arm_atsam/wait_api.h b/tmk_core/protocol/arm_atsam/wait_api.h
index 424fbb53b..b3918e534 100644
--- a/tmk_core/protocol/arm_atsam/wait_api.h
+++ b/tmk_core/protocol/arm_atsam/wait_api.h
@@ -5,4 +5,3 @@ void wait_ms(uint64_t msec);
 void wait_us(uint16_t usec);
 
 #endif
-