65 files changed, 17114 insertions, 1 deletions

diff --git a/tmk_core/arm_atsam.mk b/tmk_core/arm_atsam.mk
new file mode 100644
index 000000000..ef412d59d
--- /dev/null
+++ b/tmk_core/arm_atsam.mk
@@ -0,0 +1,56 @@
+# Hey Emacs, this is a -*- makefile -*-
+##############################################################################
+# Compiler settings
+#
+CC = arm-none-eabi-gcc
+OBJCOPY = arm-none-eabi-objcopy
+OBJDUMP = arm-none-eabi-objdump
+SIZE = arm-none-eabi-size
+AR = arm-none-eabi-ar rcs
+NM = arm-none-eabi-nm
+HEX = $(OBJCOPY) -O $(FORMAT) -R .eeprom -R .fuse -R .lock -R .signature
+EEP = $(OBJCOPY) -j .eeprom --set-section-flags=.eeprom="alloc,load" --change-section-lma .eeprom=0 --no-change-warnings -O $(FORMAT)
+BIN =
+
+COMMON_VPATH += $(LIB_PATH)/arm_atsam/packs/atmel/SAMD51_DFP/1.0.70/include
+COMMON_VPATH += $(LIB_PATH)/arm_atsam/packs/arm/cmsis/5.0.1/CMSIS/Include
+
+COMPILEFLAGS += -funsigned-char
+COMPILEFLAGS += -funsigned-bitfields
+COMPILEFLAGS += -ffunction-sections
+COMPILEFLAGS += -fshort-enums
+COMPILEFLAGS += -fno-inline-small-functions
+COMPILEFLAGS += -fno-strict-aliasing
+COMPILEFLAGS += -mfloat-abi=hard
+COMPILEFLAGS += -mfpu=fpv4-sp-d16
+COMPILEFLAGS += -mthumb
+
+#ALLOW_WARNINGS = yes
+
+CFLAGS += $(COMPILEFLAGS)
+
+CPPFLAGS += $(COMPILEFLAGS)
+CPPFLAGS += -fno-exceptions -std=c++11
+
+LDFLAGS +=-Wl,--gc-sections
+LDFLAGS += -Wl,-Map="%OUT%%PROJ_NAME%.map"
+LDFLAGS += -Wl,--start-group
+LDFLAGS += -Wl,--end-group
+LDFLAGS += -Wl,--gc-sections
+LDFLAGS += -T$(LIB_PATH)/arm_atsam/packs/atmel/SAMD51_DFP/1.0.70/gcc/gcc/samd51j18a_flash.ld
+
+OPT_DEFS += -DPROTOCOL_ARM_ATSAM
+
+MCUFLAGS = -mcpu=$(MCU)
+MCUFLAGS += -D__$(ARM_ATSAM)__
+
+# List any extra directories to look for libraries here.
+#     Each directory must be seperated by a space.
+#     Use forward slashes for directory separators.
+#     For a directory that has spaces, enclose it in quotes.
+EXTRALIBDIRS =
+
+# Convert hex to bin.
+bin: $(BUILD_DIR)/$(TARGET).hex
+        $(OBJCOPY) -Iihex -Obinary $(BUILD_DIR)/$(TARGET).hex $(BUILD_DIR)/$(TARGET).bin
+        $(COPY) $(BUILD_DIR)/$(TARGET).bin $(TARGET).bin;
diff --git a/tmk_core/common.mk b/tmk_core/common.mk
index 3e407f157..fd91d29dc 100644
--- a/tmk_core/common.mk
+++ b/tmk_core/common.mk
@@ -3,6 +3,8 @@ ifeq ($(PLATFORM),AVR)
         PLATFORM_COMMON_DIR = $(COMMON_DIR)/avr
 else ifeq ($(PLATFORM),CHIBIOS)
         PLATFORM_COMMON_DIR = $(COMMON_DIR)/chibios
+else ifeq ($(PLATFORM),ARM_ATSAM)
+        PLATFORM_COMMON_DIR = $(COMMON_DIR)/arm_atsam
 else
         PLATFORM_COMMON_DIR = $(COMMON_DIR)/test
 endif
@@ -35,6 +37,10 @@ ifeq ($(PLATFORM),CHIBIOS)
   endif
 endif
 
+ifeq ($(PLATFORM),ARM_ATSAM)
+        TMK_COMMON_SRC += $(PLATFORM_COMMON_DIR)/eeprom.c
+endif
+
 ifeq ($(PLATFORM),TEST)
         TMK_COMMON_SRC += $(PLATFORM_COMMON_DIR)/eeprom.c
 endif
diff --git a/tmk_core/common/arm_atsam/bootloader.c b/tmk_core/common/arm_atsam/bootloader.c
new file mode 100644
index 000000000..5155d9ff0
--- /dev/null
+++ b/tmk_core/common/arm_atsam/bootloader.c
@@ -0,0 +1,19 @@
+/* Copyright 2017 Fred Sundvik
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "bootloader.h"
+
+void bootloader_jump(void) {}
diff --git a/tmk_core/common/arm_atsam/eeprom.c b/tmk_core/common/arm_atsam/eeprom.c
new file mode 100644
index 000000000..61cc039ef
--- /dev/null
+++ b/tmk_core/common/arm_atsam/eeprom.c
@@ -0,0 +1,98 @@
+/* Copyright 2017 Fred Sundvik
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "eeprom.h"
+
+#define EEPROM_SIZE 32
+
+static uint8_t buffer[EEPROM_SIZE];
+
+uint8_t eeprom_read_byte(const uint8_t *addr) {
+        uintptr_t offset = (uintptr_t)addr;
+        return buffer[offset];
+}
+
+void eeprom_write_byte(uint8_t *addr, uint8_t value) {
+        uintptr_t offset = (uintptr_t)addr;
+        buffer[offset] = value;
+}
+
+uint16_t eeprom_read_word(const uint16_t *addr) {
+        const uint8_t *p = (const uint8_t *)addr;
+        return eeprom_read_byte(p) | (eeprom_read_byte(p+1) << 8);
+}
+
+uint32_t eeprom_read_dword(const uint32_t *addr) {
+        const uint8_t *p = (const uint8_t *)addr;
+        return eeprom_read_byte(p) | (eeprom_read_byte(p+1) << 8)
+                | (eeprom_read_byte(p+2) << 16) | (eeprom_read_byte(p+3) << 24);
+}
+
+void eeprom_read_block(void *buf, const void *addr, uint32_t len) {
+        const uint8_t *p = (const uint8_t *)addr;
+        uint8_t *dest = (uint8_t *)buf;
+        while (len--) {
+                *dest++ = eeprom_read_byte(p++);
+        }
+}
+
+void eeprom_write_word(uint16_t *addr, uint16_t value) {
+        uint8_t *p = (uint8_t *)addr;
+        eeprom_write_byte(p++, value);
+        eeprom_write_byte(p, value >> 8);
+}
+
+void eeprom_write_dword(uint32_t *addr, uint32_t value) {
+        uint8_t *p = (uint8_t *)addr;
+        eeprom_write_byte(p++, value);
+        eeprom_write_byte(p++, value >> 8);
+        eeprom_write_byte(p++, value >> 16);
+        eeprom_write_byte(p, value >> 24);
+}
+
+void eeprom_write_block(const void *buf, void *addr, uint32_t len) {
+        uint8_t *p = (uint8_t *)addr;
+        const uint8_t *src = (const uint8_t *)buf;
+        while (len--) {
+                eeprom_write_byte(p++, *src++);
+        }
+}
+
+void eeprom_update_byte(uint8_t *addr, uint8_t value) {
+        eeprom_write_byte(addr, value);
+}
+
+void eeprom_update_word(uint16_t *addr, uint16_t value) {
+        uint8_t *p = (uint8_t *)addr;
+        eeprom_write_byte(p++, value);
+        eeprom_write_byte(p, value >> 8);
+}
+
+void eeprom_update_dword(uint32_t *addr, uint32_t value) {
+        uint8_t *p = (uint8_t *)addr;
+        eeprom_write_byte(p++, value);
+        eeprom_write_byte(p++, value >> 8);
+        eeprom_write_byte(p++, value >> 16);
+        eeprom_write_byte(p, value >> 24);
+}
+
+void eeprom_update_block(const void *buf, void *addr, uint32_t len) {
+        uint8_t *p = (uint8_t *)addr;
+        const uint8_t *src = (const uint8_t *)buf;
+        while (len--) {
+                eeprom_write_byte(p++, *src++);
+        }
+}
diff --git a/tmk_core/common/arm_atsam/printf.h b/tmk_core/common/arm_atsam/printf.h
new file mode 100644
index 000000000..582c83bf5
--- /dev/null
+++ b/tmk_core/common/arm_atsam/printf.h
@@ -0,0 +1,8 @@
+#ifndef _PRINTF_H_
+#define _PRINTF_H_
+
+#define __xprintf dpf
+int dpf(const char *_Format, ...);
+
+#endif //_PRINTF_H_
+
diff --git a/tmk_core/common/arm_atsam/suspend.c b/tmk_core/common/arm_atsam/suspend.c
new file mode 100644
index 000000000..01d1930ea
--- /dev/null
+++ b/tmk_core/common/arm_atsam/suspend.c
@@ -0,0 +1,17 @@
+/* Copyright 2017 Fred Sundvik
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
diff --git a/tmk_core/common/arm_atsam/timer.c b/tmk_core/common/arm_atsam/timer.c
new file mode 100644
index 000000000..bcfe5002c
--- /dev/null
+++ b/tmk_core/common/arm_atsam/timer.c
@@ -0,0 +1,59 @@
+#include "samd51j18a.h"
+#include "timer.h"
+#include "tmk_core/protocol/arm_atsam/clks.h"
+
+void set_time(uint64_t tset)
+{
+    ms_clk = tset;
+}
+
+void timer_init(void)
+{
+    ms_clk = 0;
+}
+
+uint16_t timer_read(void)
+{
+    return (uint16_t)ms_clk;
+}
+
+uint32_t timer_read32(void)
+{
+    return (uint32_t)ms_clk;
+}
+
+uint64_t timer_read64(void)
+{
+    return ms_clk;
+}
+
+uint16_t timer_elapsed(uint16_t tlast)
+{
+    return TIMER_DIFF_16(timer_read(), tlast);
+}
+
+uint32_t timer_elapsed32(uint32_t tlast)
+{
+    return TIMER_DIFF_32(timer_read32(), tlast);
+}
+
+uint32_t timer_elapsed64(uint32_t tlast)
+{
+    uint64_t tnow = timer_read64();
+    return (tnow >= tlast ? tnow - tlast : UINT64_MAX - tlast + tnow);
+}
+
+void timer_clear(void)
+{
+    ms_clk = 0;
+}
+
+void wait_ms(uint64_t msec)
+{
+    CLK_delay_ms(msec);
+}
+
+void wait_us(uint16_t usec)
+{
+    CLK_delay_us(usec);
+}
diff --git a/tmk_core/common/print.h b/tmk_core/common/print.h
index 8836c0fc7..9cbe67bad 100644
--- a/tmk_core/common/print.h
+++ b/tmk_core/common/print.h
@@ -99,6 +99,34 @@ void print_set_sendchar(int8_t (*print_sendchar_func)(uint8_t));
 
 #  endif /* USER_PRINT / NORMAL PRINT */
 
+#elif defined(PROTOCOL_ARM_ATSAM) /* PROTOCOL_ARM_ATSAM */
+
+#  include "arm_atsam/printf.h"
+
+#  ifdef USER_PRINT /* USER_PRINT */
+
+// Remove normal print defines
+#    define print(s)
+#    define println(s)
+#    define xprintf(fmt, ...)
+
+// Create user print defines
+#    define uprintf(fmt, ...)  __xprintf(fmt, ##__VA_ARGS__)
+#    define uprint(s)          xprintf(s)
+#    define uprintln(s)        xprintf(s "\r\n")
+
+#  else /* NORMAL PRINT */
+
+// Create user & normal print defines
+#    define xprintf(fmt, ...)  __xprintf(fmt, ##__VA_ARGS__)
+#    define print(s)           xprintf(s)
+#    define println(s)         xprintf(s "\r\n")
+#    define uprint(s)          print(s)
+#    define uprintln(s)        println(s)
+#    define uprintf(fmt, ...)  xprintf(fmt, ...)
+
+#  endif /* USER_PRINT / NORMAL PRINT */
+
 #elif defined(__arm__) /* __arm__ */
 
 #  include "mbed/xprintf.h"
@@ -130,7 +158,7 @@ void print_set_sendchar(int8_t (*print_sendchar_func)(uint8_t));
 /* TODO: to select output destinations: UART/USBSerial */
 #  define print_set_sendchar(func)
 
-#endif /* __AVR__ / PROTOCOL_CHIBIOS / __arm__ */
+#endif /* __AVR__ / PROTOCOL_CHIBIOS / PROTOCOL_ARM_ATSAM / __arm__ */
 
 // User print disables the normal print messages in the body of QMK/TMK code and
 // is meant as a lightweight alternative to NOPRINT. Use it when you only want to do
diff --git a/tmk_core/common/report.h b/tmk_core/common/report.h
index 6c27eb9dc..167f38275 100644
--- a/tmk_core/common/report.h
+++ b/tmk_core/common/report.h
@@ -84,6 +84,11 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
     #define KEYBOARD_REPORT_SIZE NKRO_EPSIZE
     #define KEYBOARD_REPORT_KEYS (NKRO_EPSIZE - 2)
     #define KEYBOARD_REPORT_BITS (NKRO_EPSIZE - 1)
+  #elif defined(PROTOCOL_ARM_ATSAM)
+    #include "protocol/arm_atsam/usb/udi_device_epsize.h"
+    #define KEYBOARD_REPORT_SIZE NKRO_EPSIZE
+    #define KEYBOARD_REPORT_KEYS (NKRO_EPSIZE - 2)
+    #define KEYBOARD_REPORT_BITS (NKRO_EPSIZE - 1)
   #else
     #error "NKRO not supported with this protocol"
 #endif
diff --git a/tmk_core/protocol/arm_atsam.mk b/tmk_core/protocol/arm_atsam.mk
new file mode 100644
index 000000000..d535b64cd
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam.mk
@@ -0,0 +1,26 @@
+ARM_ATSAM_DIR = protocol/arm_atsam
+
+SRC += $(ARM_ATSAM_DIR)/adc.c
+SRC += $(ARM_ATSAM_DIR)/clks.c
+SRC += $(ARM_ATSAM_DIR)/d51_util.c
+SRC += $(ARM_ATSAM_DIR)/i2c_master.c
+SRC += $(ARM_ATSAM_DIR)/led_matrix.c
+SRC += $(ARM_ATSAM_DIR)/main_arm_atsam.c
+SRC += $(ARM_ATSAM_DIR)/spi.c
+SRC += $(ARM_ATSAM_DIR)/startup.c
+
+SRC += $(ARM_ATSAM_DIR)/usb/main_usb.c
+SRC += $(ARM_ATSAM_DIR)/usb/spfssf.c
+SRC += $(ARM_ATSAM_DIR)/usb/udc.c
+SRC += $(ARM_ATSAM_DIR)/usb/udi_cdc.c
+SRC += $(ARM_ATSAM_DIR)/usb/udi_hid.c
+SRC += $(ARM_ATSAM_DIR)/usb/udi_hid_kbd.c
+SRC += $(ARM_ATSAM_DIR)/usb/udi_hid_kbd_desc.c
+SRC += $(ARM_ATSAM_DIR)/usb/ui.c
+SRC += $(ARM_ATSAM_DIR)/usb/usb2422.c
+SRC += $(ARM_ATSAM_DIR)/usb/usb.c
+SRC += $(ARM_ATSAM_DIR)/usb/usb_device_udd.c
+SRC += $(ARM_ATSAM_DIR)/usb/usb_util.c
+
+# Search Path
+VPATH += $(TMK_DIR)/$(ARM_ATSAM_DIR)
diff --git a/tmk_core/protocol/arm_atsam/adc.c b/tmk_core/protocol/arm_atsam/adc.c
new file mode 100644
index 000000000..ab77f9240
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/adc.c
@@ -0,0 +1,99 @@
+/*
+Copyright 2018 Massdrop Inc.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "arm_atsam_protocol.h"
+
+uint16_t v_5v;
+uint16_t v_5v_avg;
+uint16_t v_con_1;
+uint16_t v_con_2;
+uint16_t v_con_1_boot;
+uint16_t v_con_2_boot;
+
+void ADC0_clock_init(void)
+{
+    DBGC(DC_ADC0_CLOCK_INIT_BEGIN);
+
+    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
+
+    DBGC(DC_ADC0_CLOCK_INIT_COMPLETE);
+}
+
+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
+    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
+    ADC0->CTRLA.bit.PRESCALER = ADC_CTRLA_PRESCALER_DIV2_Val;
+
+    //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 = (ADC0_FUSES_BIASCOMP_ADDR >> ADC0_FUSES_BIASCOMP_Pos) & ADC0_FUSES_BIASCOMP_Msk;
+    ADC0->CALIB.bit.BIASR2R = (ADC0_FUSES_BIASR2R_ADDR >> ADC0_FUSES_BIASR2R_Pos) & ADC0_FUSES_BIASR2R_Msk;
+    ADC0->CALIB.bit.BIASREFBUF = (ADC0_FUSES_BIASREFBUF_ADDR >> ADC0_FUSES_BIASREFBUF_Pos) & ADC0_FUSES_BIASREFBUF_Msk;
+
+    //Enable
+    ADC0->CTRLA.bit.ENABLE = 1;
+    while (ADC0->SYNCBUSY.bit.ENABLE) { DBGC(DC_ADC0_ENABLE_SYNCING_1); }
+
+    DBGC(DC_ADC0_INIT_COMPLETE);
+}
+
+uint16_t adc_get(uint8_t muxpos)
+{
+    ADC0->INPUTCTRL.bit.MUXPOS = muxpos;
+    while (ADC0->SYNCBUSY.bit.INPUTCTRL) {}
+
+    ADC0->SWTRIG.bit.START = 1;
+    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
new file mode 100644
index 000000000..5a90ece3f
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/adc.h
@@ -0,0 +1,37 @@
+/*
+Copyright 2018 Massdrop Inc.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+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     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;
+extern uint16_t v_con_1;
+extern uint16_t v_con_2;
+extern uint16_t v_con_1_boot;
+extern uint16_t v_con_2_boot;
+
+void ADC0_clock_init(void);
+void ADC0_init(void);
+
+#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
new file mode 100644
index 000000000..be73beccd
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/arm_atsam_protocol.h
@@ -0,0 +1,45 @@
+/*
+Copyright 2018 Massdrop Inc.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _ARM_ATSAM_PROTOCOL_H_
+#define _ARM_ATSAM_PROTOCOL_H_
+
+#include "samd51j18a.h"
+#include "md_bootloader.h"
+
+#include "d51_util.h"
+#include "clks.h"
+#include "adc.h"
+#include "i2c_master.h"
+#include "spi.h"
+
+#include "./usb/usb2422.h"
+
+#ifndef MD_BOOTLOADER
+
+#include "main_arm_atsam.h"
+#include "led_matrix.h"
+#include "issi3733_driver.h"
+#include "./usb/compiler.h"
+#include "./usb/udc.h"
+#include "./usb/spfssf.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
new file mode 100644
index 000000000..8768d0a99
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/clks.c
@@ -0,0 +1,439 @@
+/*
+Copyright 2018 Massdrop Inc.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "arm_atsam_protocol.h"
+
+#include <string.h>
+
+volatile clk_t system_clks;
+volatile uint64_t ms_clk;
+
+volatile uint8_t us_delay_done;
+
+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
+
+void CLK_oscctrl_init(void)
+{
+    Oscctrl *posctrl = OSCCTRL;
+    Gclk *pgclk = GCLK;
+
+    DBGC(DC_CLK_OSC_INIT_BEGIN);
+
+    //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;
+    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); }
+    system_clks.freq_xosc0 = FREQ_XOSC0;
+
+    //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); }
+    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); }
+    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
+    pgclk->GENCTRL[GEN_DPLL0].bit.SRC = USE_DPLL_DEF;
+    while (pgclk->SYNCBUSY.bit.GENCTRL0) { DBGC(DC_CLK_OSC_INIT_GCLK_SYNC_GENCTRL0); }
+
+    system_clks.freq_gclk[0] = system_clks.freq_dpll[0];
+
+    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)
+{
+    Gclk *pgclk = GCLK;
+
+    DBGC(DC_CLK_SET_GCLK_FREQ_BEGIN);
+
+    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); }
+    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); }
+    pgclk->GENCTRL[gclkn].bit.DIVSEL = 0;
+    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); }
+    system_clks.freq_gclk[gclkn] = system_clks.freq_dpll[0] / pgclk->GENCTRL[gclkn].bit.DIV;
+
+    DBGC(DC_CLK_SET_GCLK_FREQ_COMPLETE);
+
+    return system_clks.freq_gclk[gclkn];
+}
+
+void CLK_init_osc(void)
+{
+    uint8_t gclkn = GEN_OSC0;
+    Gclk *pgclk = GCLK;
+
+    DBGC(DC_CLK_INIT_OSC_BEGIN);
+
+    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); }
+    pgclk->GENCTRL[gclkn].bit.DIV = 1;
+    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); }
+    pgclk->GENCTRL[gclkn].bit.GENEN = 1;
+    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)
+{
+    Tc *ptc4 = TC4;
+    Tc *ptc0 = TC0;
+
+    ms_clk = 0;
+
+    DBGC(DC_CLK_RESET_TIME_BEGIN);
+
+    //stop counters
+    ptc4->COUNT16.CTRLA.bit.ENABLE = 0;
+    while (ptc4->COUNT16.SYNCBUSY.bit.ENABLE) {}
+    ptc0->COUNT32.CTRLA.bit.ENABLE = 0;
+    while (ptc0->COUNT32.SYNCBUSY.bit.ENABLE) {}
+    //zero counters
+    ptc4->COUNT16.COUNT.reg = 0;
+    while (ptc4->COUNT16.SYNCBUSY.bit.COUNT) {}
+    ptc0->COUNT32.COUNT.reg = 0;
+    while (ptc0->COUNT32.SYNCBUSY.bit.COUNT) {}
+    //start counters
+    ptc0->COUNT32.CTRLA.bit.ENABLE = 1;
+    while (ptc0->COUNT32.SYNCBUSY.bit.ENABLE) {}
+    ptc4->COUNT16.CTRLA.bit.ENABLE = 1;
+    while (ptc4->COUNT16.SYNCBUSY.bit.ENABLE) {}
+
+    DBGC(DC_CLK_RESET_TIME_COMPLETE);
+}
+
+void TC4_Handler()
+{
+    if (TC4->COUNT16.INTFLAG.bit.MC0)
+    {
+        TC4->COUNT16.INTFLAG.reg = TC_INTENCLR_MC0;
+        ms_clk++;
+    }
+}
+
+void TC5_Handler()
+{
+    if (TC5->COUNT16.INTFLAG.bit.MC0)
+    {
+        TC5->COUNT16.INTFLAG.reg = TC_INTENCLR_MC0;
+        us_delay_done = 1;
+        TC5->COUNT16.CTRLA.bit.ENABLE = 0;
+        while (TC5->COUNT16.SYNCBUSY.bit.ENABLE) {}
+    }
+}
+
+uint32_t CLK_enable_timebase(void)
+{
+    Gclk *pgclk = GCLK;
+    Mclk *pmclk = MCLK;
+    Tc *ptc4 = TC4;
+    Tc *ptc5 = TC5;
+    Tc *ptc0 = TC0;
+    Evsys *pevsys = EVSYS;
+
+    DBGC(DC_CLK_ENABLE_TIMEBASE_BEGIN);
+
+    //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;
+    pgclk->PCHCTRL[TC4_GCLK_ID].bit.CHEN = 1;
+
+    //unmask TC5 sourcegclk2 to TC5
+    pmclk->APBCMASK.bit.TC5_ = 1;
+    pgclk->PCHCTRL[TC5_GCLK_ID].bit.GEN = GEN_TC45;
+    pgclk->PCHCTRL[TC5_GCLK_ID].bit.CHEN = 1;
+
+    //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); }
+    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); }
+
+    //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); }
+    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;
+
+    //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);
+    ptc4->COUNT16.INTENSET.bit.MC0 = 1;
+
+    DBGC(DC_CLK_ENABLE_TIMEBASE_TC4_COMPLETE);
+
+    //configure TC5
+    DBGC(DC_CLK_ENABLE_TIMEBASE_TC5_BEGIN);
+    ptc5->COUNT16.CTRLA.bit.ENABLE = 0;
+    while (ptc5->COUNT16.SYNCBUSY.bit.ENABLE) { DBGC(DC_CLK_ENABLE_TIMEBASE_TC5_SYNC_DISABLE); }
+    ptc5->COUNT16.CTRLA.bit.SWRST = 1;
+    while (ptc5->COUNT16.SYNCBUSY.bit.SWRST) { DBGC(DC_CLK_ENABLE_TIMEBASE_TC5_SYNC_SWRST_1); }
+    while (ptc5->COUNT16.CTRLA.bit.SWRST) { DBGC(DC_CLK_ENABLE_TIMEBASE_TC5_SYNC_SWRST_2); }
+
+    //CTRLA defaults
+    //CTRLB as default, counting up
+    ptc5->COUNT16.CTRLBCLR.reg = 5;
+    while (ptc5->COUNT16.SYNCBUSY.bit.CTRLB) { DBGC(DC_CLK_ENABLE_TIMEBASE_TC5_SYNC_CLTRB); }
+    //ptc5->COUNT16.DBGCTRL.bit.DBGRUN = 1;
+
+    //wave mode
+    ptc5->COUNT16.WAVE.bit.WAVEGEN = 1; //MFRQ match frequency mode, toggle each CC match
+    //generate event for next stage
+    ptc5->COUNT16.EVCTRL.bit.MCEO0 = 1;
+
+    NVIC_EnableIRQ(TC5_IRQn);
+    ptc5->COUNT16.INTENSET.bit.MC0 = 1;
+
+    DBGC(DC_CLK_ENABLE_TIMEBASE_TC5_COMPLETE);
+
+    //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;
+    pgclk->PCHCTRL[TC1_GCLK_ID].bit.CHEN = 1;
+
+    //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); }
+    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
+
+    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;
+    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
+
+    DBGC(DC_CLK_ENABLE_TIMEBASE_EVSYS_COMPLETE);
+
+    CLK_reset_time();
+
+    ADC0_clock_init();
+
+    DBGC(DC_CLK_ENABLE_TIMEBASE_COMPLETE);
+
+    return 0;
+}
+
+uint32_t CLK_get_ms(void)
+{
+    return ms_clk;
+}
+
+void CLK_delay_us(uint16_t usec)
+{
+    us_delay_done = 0;
+
+    if (TC5->COUNT16.CTRLA.bit.ENABLE)
+    {
+        TC5->COUNT16.CTRLA.bit.ENABLE = 0;
+        while (TC5->COUNT16.SYNCBUSY.bit.ENABLE) {}
+    }
+
+    if (usec < 10) usec = 0;
+    else usec -= 10;
+
+    TC5->COUNT16.CC[0].reg = usec;
+    while (TC5->COUNT16.SYNCBUSY.bit.CC0) {}
+
+    TC5->COUNT16.CTRLA.bit.ENABLE = 1;
+    while (TC5->COUNT16.SYNCBUSY.bit.ENABLE) {}
+
+    while (!us_delay_done) {}
+}
+
+void CLK_delay_ms(uint64_t msec)
+{
+    msec += CLK_get_ms();
+    while (msec > CLK_get_ms()) {}
+}
+
+void clk_enable_sercom_apbmask(int sercomn)
+{
+    Mclk *pmclk = MCLK;
+    switch (sercomn)
+    {
+        case 0:
+            pmclk->APBAMASK.bit.SERCOM0_ = 1;
+            break;
+        case 1:
+            pmclk->APBAMASK.bit.SERCOM1_ = 1;
+            break;
+        case 2:
+            pmclk->APBBMASK.bit.SERCOM2_ = 1;
+            break;
+        case 3:
+            pmclk->APBBMASK.bit.SERCOM3_ = 1;
+            break;
+        default:
+            break;
+    }
+}
+
+//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;
+    Sercom *psercom = (Sercom *)sercom_apbbase[sercomn];
+    clk_enable_sercom_apbmask(sercomn);
+
+    //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) {}
+
+    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);
+
+    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)
+{
+    DBGC(DC_CLK_SET_I2C0_FREQ_BEGIN);
+
+    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;
+    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) {}
+
+    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);
+
+    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)
+{
+    DBGC(DC_CLK_SET_I2C1_FREQ_BEGIN);
+
+    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;
+    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) {}
+
+    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);
+
+    return system_clks.freq_i2c1;
+}
+
+void CLK_init(void)
+{
+    DBGC(DC_CLK_INIT_BEGIN);
+
+    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
new file mode 100644
index 000000000..96819bfdd
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/clks.h
@@ -0,0 +1,90 @@
+/*
+Copyright 2018 Massdrop Inc.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _CLKS_H_
+#define _CLKS_H_
+
+#ifndef MD_BOOTLOADER
+
+//From keyboard
+#include "config_led.h"
+#include "config.h"
+
+#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
+
+//I2C1 Set      ~Result     PWM Time (2x Drivers)
+//     1000000  1090000
+//     900000   1000000     3.82ms
+//     800000   860000
+//     700000   750000
+//     600000   630000
+//     580000   615000      6.08ms
+//     500000   522000
+
+#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
+
+//Generator clock channels
+#define GEN_DPLL0   0
+#define GEN_OSC0    1
+#define GEN_TC45    2
+
+#define SERCOM_COUNT 5
+#define GCLK_COUNT  12
+
+typedef struct clk_s {
+    uint32_t freq_dfll;
+    uint32_t freq_dpll[2];
+    uint32_t freq_sercom[SERCOM_COUNT];
+    uint32_t freq_gclk[GCLK_COUNT];
+    uint32_t freq_xosc0;
+    uint32_t freq_spi;
+    uint32_t freq_i2c0;
+    uint32_t freq_i2c1;
+    uint32_t freq_uart;
+    uint32_t freq_adc0;
+} clk_t;
+
+extern volatile clk_t system_clks;
+extern volatile uint64_t ms_clk;
+
+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);
+uint32_t CLK_get_ms(void);
+uint64_t CLK_get_us(void);
+void CLK_delay_us(uint16_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);
+
+#endif // _CLKS_H_
diff --git a/tmk_core/protocol/arm_atsam/d51_util.c b/tmk_core/protocol/arm_atsam/d51_util.c
new file mode 100644
index 000000000..91b58757c
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/d51_util.c
@@ -0,0 +1,165 @@
+#include "d51_util.h"
+
+//Display unsigned 32-bit number through m15
+//Read as follows: 1230 = || ||| |||| |  (note always ending toggle)
+void m15_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)
+    {
+        p2 = t;
+        p = 1;
+        while (p2--) p *= 10;
+        n = x / p;
+        x -= n * p;
+        while (n > 0)
+        {
+            m15_on;
+            n--;
+            m15_off;
+        }
+        //Will always end with an extra toggle
+        m15_on;
+        t--;
+        m15_off;
+    }
+}
+
+//Display unsigned 32-bit number through debug led
+//Read as follows: 1230 = [*]  [* *]  [* * *]  [**]  (note zero is fast double flash)
+#define DLED_ONTIME 600000
+#define DLED_PAUSE 1000000
+volatile uint32_t w;
+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)
+    {
+        p2 = t;
+        p = 1;
+        while (p2--) p *= 10;
+        n = x / p;
+        x -= n * p;
+        if (!n)
+        {
+            led_on;
+            for (w = DLED_ONTIME / 4; w; w--);
+            led_off;
+            for (w = DLED_ONTIME / 4; w; w--);
+            led_on;
+            for (w = DLED_ONTIME / 4; w; w--);
+            led_off;
+            for (w = DLED_ONTIME / 4; w; w--);
+            n--;
+        }
+        else
+        {
+            while (n > 0)
+            {
+                led_on;
+                for (w = DLED_ONTIME; w; w--);
+                led_off;
+                for (w = DLED_ONTIME / 2; w; w--);
+                n--;
+            }
+        }
+
+        for (w = DLED_PAUSE; w; w--);
+        t--;
+    }
+
+    if (long_pause)
+    {
+        for (w = DLED_PAUSE * 4; w; w--);
+    }
+}
+
+#ifdef DEBUG_BOOT_TRACING
+
+volatile uint32_t debug_code;
+
+void EIC_15_Handler()
+{
+    //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)
+{
+    DBGC(DC_UNSET);
+
+    //Configure Ports for EIC on PB31
+    PORT->Group[1].DIRCLR.reg = 1 << 31; //Input
+    PORT->Group[1].OUTSET.reg = 1 << 31; //High
+    PORT->Group[1].PINCFG[31].bit.INEN = 1; //Input Enable
+    PORT->Group[1].PINCFG[31].bit.PULLEN = 1; //Pull Enable
+    PORT->Group[1].PINCFG[31].bit.PMUXEN = 1; //Mux Enable
+    PORT->Group[1].PMUX[15].bit.PMUXO = 0; //Mux A
+
+    //Enable CLK_EIC_APB
+    MCLK->APBAMASK.bit.EIC_ = 1;
+
+    //Configure EIC
+    EIC->CTRLA.bit.SWRST = 1;
+    while (EIC->SYNCBUSY.bit.SWRST) {}
+    EIC->ASYNCH.reg = 1 << 15;
+    EIC->INTENSET.reg = 1 << 15;
+    EIC->CONFIG[1].bit.SENSE7 = 2;
+    EIC->CTRLA.bit.ENABLE = 1;
+    while (EIC->SYNCBUSY.bit.ENABLE) {}
+
+    //Enable EIC IRQ
+    NVIC_EnableIRQ(EIC_15_IRQn);
+}
+
+void debug_code_disable(void)
+{
+    //Disable EIC IRQ
+    NVIC_DisableIRQ(EIC_15_IRQn);
+
+    //Disable EIC
+    EIC->CTRLA.bit.ENABLE = 0;
+    while (EIC->SYNCBUSY.bit.ENABLE) {}
+
+    //Disable CLK_EIC_APB
+    MCLK->APBAMASK.bit.EIC_ = 0;
+}
+
+#else
+
+void debug_code_init(void) {}
+void debug_code_disable(void) {}
+
+#endif //DEBUG_BOOT_TRACING
diff --git a/tmk_core/protocol/arm_atsam/d51_util.h b/tmk_core/protocol/arm_atsam/d51_util.h
new file mode 100644
index 000000000..465889c7c
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/d51_util.h
@@ -0,0 +1,185 @@
+/*
+Copyright 2018 Massdrop Inc.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _D51_UTIL_H_
+#define _D51_UTIL_H_
+
+#include "samd51j18a.h"
+
+//TODO: PS: Should bring these ports out to keyboard level configuration
+
+//Debug LED PA27
+#define led_ena REG_PORT_DIRSET0 = 0x08000000 //PA27 Output
+#define led_on  REG_PORT_OUTSET0 = 0x08000000 //PA27 High
+#define led_off REG_PORT_OUTCLR0 = 0x08000000 //PA27 Low
+
+//Debug Port PB30
+#define m15_ena REG_PORT_DIRSET1 = 0x40000000 //PB30 Output
+#define m15_on  REG_PORT_OUTSET1 = 0x40000000 //PB30 High
+#define m15_off REG_PORT_OUTCLR1 = 0x40000000 //PB30 Low
+
+#define m15_loop(M15X) {uint8_t M15L=M15X; while(M15L--){m15_on;CLK_delay_us(1);m15_off;}}
+
+void m15_print(uint32_t x);
+void dled_print(uint32_t x, uint8_t long_pause);
+
+void debug_code_init(void);
+void debug_code_disable(void);
+
+#ifdef DEBUG_BOOT_TRACING
+
+#define DBGC(n) debug_code = n
+
+extern volatile uint32_t debug_code;
+
+enum debug_code_list {
+    DC_UNSET = 0,
+    DC_CLK_INIT_BEGIN,
+    DC_CLK_INIT_COMPLETE,
+    DC_CLK_SET_I2C1_FREQ_BEGIN,
+    DC_CLK_SET_I2C1_FREQ_COMPLETE,
+    DC_CLK_SET_I2C0_FREQ_BEGIN,
+    DC_CLK_SET_I2C0_FREQ_COMPLETE,
+    DC_CLK_SET_SPI_FREQ_BEGIN,
+    DC_CLK_SET_SPI_FREQ_COMPLETE,
+    DC_CLK_ENABLE_TIMEBASE_BEGIN,
+    DC_CLK_ENABLE_TIMEBASE_SYNC_ENABLE,
+    DC_CLK_ENABLE_TIMEBASE_SYNC_SWRST_1,
+    DC_CLK_ENABLE_TIMEBASE_SYNC_SWRST_2,
+    DC_CLK_ENABLE_TIMEBASE_TC4_BEGIN,
+    DC_CLK_ENABLE_TIMEBASE_TC4_SYNC_DISABLE,
+    DC_CLK_ENABLE_TIMEBASE_TC4_SYNC_SWRST_1,
+    DC_CLK_ENABLE_TIMEBASE_TC4_SYNC_SWRST_2,
+    DC_CLK_ENABLE_TIMEBASE_TC4_SYNC_CLTRB,
+    DC_CLK_ENABLE_TIMEBASE_TC4_SYNC_CC0,
+    DC_CLK_ENABLE_TIMEBASE_TC4_COMPLETE,
+    DC_CLK_ENABLE_TIMEBASE_TC5_BEGIN,
+    DC_CLK_ENABLE_TIMEBASE_TC5_SYNC_DISABLE,
+    DC_CLK_ENABLE_TIMEBASE_TC5_SYNC_SWRST_1,
+    DC_CLK_ENABLE_TIMEBASE_TC5_SYNC_SWRST_2,
+    DC_CLK_ENABLE_TIMEBASE_TC5_SYNC_CLTRB,
+    DC_CLK_ENABLE_TIMEBASE_TC5_COMPLETE,
+    DC_CLK_ENABLE_TIMEBASE_TC0_BEGIN,
+    DC_CLK_ENABLE_TIMEBASE_TC0_SYNC_DISABLE,
+    DC_CLK_ENABLE_TIMEBASE_TC0_SYNC_SWRST_1,
+    DC_CLK_ENABLE_TIMEBASE_TC0_SYNC_SWRST_2,
+    DC_CLK_ENABLE_TIMEBASE_TC0_COMPLETE,
+    DC_CLK_ENABLE_TIMEBASE_EVSYS_BEGIN,
+    DC_CLK_ENABLE_TIMEBASE_EVSYS_COMPLETE,
+    DC_CLK_ENABLE_TIMEBASE_COMPLETE,
+    DC_CLK_SET_GCLK_FREQ_BEGIN,
+    DC_CLK_SET_GCLK_FREQ_SYNC_1,
+    DC_CLK_SET_GCLK_FREQ_SYNC_2,
+    DC_CLK_SET_GCLK_FREQ_SYNC_3,
+    DC_CLK_SET_GCLK_FREQ_SYNC_4,
+    DC_CLK_SET_GCLK_FREQ_SYNC_5,
+    DC_CLK_SET_GCLK_FREQ_COMPLETE,
+    DC_CLK_INIT_OSC_BEGIN,
+    DC_CLK_INIT_OSC_SYNC_1,
+    DC_CLK_INIT_OSC_SYNC_2,
+    DC_CLK_INIT_OSC_SYNC_3,
+    DC_CLK_INIT_OSC_SYNC_4,
+    DC_CLK_INIT_OSC_SYNC_5,
+    DC_CLK_INIT_OSC_COMPLETE,
+    DC_CLK_RESET_TIME_BEGIN,
+    DC_CLK_RESET_TIME_COMPLETE,
+    DC_CLK_OSC_INIT_BEGIN,
+    DC_CLK_OSC_INIT_XOSC0_SYNC,
+    DC_CLK_OSC_INIT_DPLL_SYNC_DISABLE,
+    DC_CLK_OSC_INIT_DPLL_SYNC_RATIO,
+    DC_CLK_OSC_INIT_DPLL_SYNC_ENABLE,
+    DC_CLK_OSC_INIT_DPLL_WAIT_LOCK,
+    DC_CLK_OSC_INIT_DPLL_WAIT_CLKRDY,
+    DC_CLK_OSC_INIT_GCLK_SYNC_GENCTRL0,
+    DC_CLK_OSC_INIT_COMPLETE,
+    DC_SPI_INIT_BEGIN,
+    DC_SPI_WRITE_DRE,
+    DC_SPI_WRITE_TXC_1,
+    DC_SPI_WRITE_TXC_2,
+    DC_SPI_SYNC_ENABLING,
+    DC_SPI_INIT_COMPLETE,
+    DC_PORT_DETECT_INIT_BEGIN,
+    DC_PORT_DETECT_INIT_FAILED,
+    DC_PORT_DETECT_INIT_COMPLETE,
+    DC_USB_RESET_BEGIN,
+    DC_USB_RESET_COMPLETE,
+    DC_USB_SET_HOST_BY_VOLTAGE_BEGIN,
+    DC_USB_SET_HOST_5V_LOW_WAITING,
+    DC_USB_SET_HOST_BY_VOLTAGE_COMPLETE,
+    DC_USB_CONFIGURE_BEGIN,
+    DC_USB_CONFIGURE_GET_SERIAL,
+    DC_USB_CONFIGURE_COMPLETE,
+    DC_USB_WRITE2422_BLOCK_BEGIN,
+    DC_USB_WRITE2422_BLOCK_SYNC_SYSOP,
+    DC_USB_WRITE2422_BLOCK_COMPLETE,
+    DC_ADC0_CLOCK_INIT_BEGIN,
+    DC_ADC0_CLOCK_INIT_COMPLETE,
+    DC_ADC0_INIT_BEGIN,
+    DC_ADC0_SWRST_SYNCING_1,
+    DC_ADC0_SWRST_SYNCING_2,
+    DC_ADC0_AVGCTRL_SYNCING_1,
+    DC_ADC0_AVGCTRL_SYNCING_2,
+    DC_ADC0_SAMPCTRL_SYNCING_1,
+    DC_ADC0_ENABLE_SYNCING_1,
+    DC_ADC0_INIT_COMPLETE,
+    DC_I2C0_INIT_BEGIN,
+    DC_I2C0_INIT_SYNC_ENABLING,
+    DC_I2C0_INIT_SYNC_SYSOP,
+    DC_I2C0_INIT_WAIT_IDLE,
+    DC_I2C0_INIT_COMPLETE,
+    DC_I2C1_INIT_BEGIN,
+    DC_I2C1_INIT_SYNC_ENABLING,
+    DC_I2C1_INIT_SYNC_SYSOP,
+    DC_I2C1_INIT_WAIT_IDLE,
+    DC_I2C1_INIT_COMPLETE,
+    DC_I2C3733_INIT_CONTROL_BEGIN,
+    DC_I2C3733_INIT_CONTROL_COMPLETE,
+    DC_I2C3733_INIT_DRIVERS_BEGIN,
+    DC_I2C3733_INIT_DRIVERS_COMPLETE,
+    DC_I2C_DMAC_LED_INIT_BEGIN,
+    DC_I2C_DMAC_LED_INIT_COMPLETE,
+    DC_I2C3733_CONTROL_SET_BEGIN,
+    DC_I2C3733_CONTROL_SET_COMPLETE,
+    DC_LED_MATRIX_INIT_BEGIN,
+    DC_LED_MATRIX_INIT_COMPLETE,
+    DC_USB2422_INIT_BEGIN,
+    DC_USB2422_INIT_WAIT_5V_LOW,
+    DC_USB2422_INIT_OSC_SYNC_DISABLING,
+    DC_USB2422_INIT_OSC_SYNC_DFLLCTRLB_1,
+    DC_USB2422_INIT_OSC_SYNC_DFLLCTRLB_2,
+    DC_USB2422_INIT_OSC_SYNC_DFLLCTRLB_3,
+    DC_USB2422_INIT_OSC_SYNC_DFLLCTRLB_4,
+    DC_USB2422_INIT_OSC_SYNC_DFLLMUL,
+    DC_USB2422_INIT_OSC_SYNC_ENABLING,
+    DC_USB2422_INIT_USB_SYNC_SWRST,
+    DC_USB2422_INIT_USB_WAIT_SWRST,
+    DC_USB2422_INIT_USB_SYNC_ENABLING,
+    DC_USB2422_INIT_COMPLETE,
+    DC_MAIN_UDC_START_BEGIN,
+    DC_MAIN_UDC_START_COMPLETE,
+    DC_MAIN_CDC_INIT_BEGIN,
+    DC_MAIN_CDC_INIT_COMPLETE,
+    /* Never change the order of error codes! Only add codes to end! */
+};
+
+#else
+
+#define DBGC(n) {}
+
+#endif //DEBUG_BOOT_TRACING
+
+#endif //_D51_UTIL_H_
diff --git a/tmk_core/protocol/arm_atsam/i2c_master.c b/tmk_core/protocol/arm_atsam/i2c_master.c
new file mode 100644
index 000000000..bbe909e9b
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/i2c_master.c
@@ -0,0 +1,585 @@
+/*
+Copyright 2018 Massdrop Inc.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "arm_atsam_protocol.h"
+
+#ifndef MD_BOOTLOADER
+
+#include <string.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
+
+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
+
+volatile uint8_t i2c_led_q_running;
+
+#endif //MD_BOOTLOADER
+
+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;
+    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
+
+    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.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
+
+    DBGC(DC_I2C0_INIT_COMPLETE);
+}
+
+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) {}
+
+    return 1;
+}
+
+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)
+    {
+        SERCOM0->I2CM.DATA.bit.DATA = *data;
+        while (SERCOM0->I2CM.INTFLAG.bit.MB == 0) {}
+        while (SERCOM0->I2CM.STATUS.bit.RXNACK) {}
+
+        data++;
+        length--;
+    }
+
+    i2c0_stop();
+
+    return 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);
+    }
+}
+
+#ifndef MD_BOOTLOADER
+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].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
+
+    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)
+
+    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.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)
+{
+    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) {}
+
+    return 1;
+}
+
+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)
+    {
+        SERCOM1->I2CM.DATA.bit.DATA = *data;
+        while (SERCOM1->I2CM.INTFLAG.bit.MB == 0) {}
+        while (SERCOM1->I2CM.STATUS.bit.RXNACK) {}
+
+        data++;
+        length--;
+    }
+
+    i2c1_stop();
+
+    return 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);
+    }
+}
+
+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 };
+    i2c1_transmit(issidrv[drvid].addr, i2cdata, sizeof(i2cdata), 0);
+}
+
+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;
+
+    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
+        i2c_led_send_CRWL(drvid);
+        i2c_led_select_page(drvid, 0);
+#if I2C_LED_USE_DMA != 1
+    }
+#endif
+
+    *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};
+    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 };
+
+    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
+        i2c_led_send_CRWL(drvid);
+        i2c_led_select_page(drvid, 0);
+#if I2C_LED_USE_DMA != 1
+    }
+#endif
+
+    *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)
+{
+    DBGC(DC_I2C3733_INIT_CONTROL_BEGIN);
+
+    srdata.bit.SDB_N = 1;
+    SPI_WriteSRData();
+
+    CLK_delay_ms(1);
+
+    srdata.bit.IRST = 0;
+    SPI_WriteSRData();
+
+    CLK_delay_ms(1);
+
+    DBGC(DC_I2C3733_INIT_CONTROL_COMPLETE);
+
+    return 1;
+}
+
+uint8_t I2C3733_Init_Drivers(void)
+{
+    DBGC(DC_I2C3733_INIT_DRIVERS_BEGIN);
+
+    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
+    i2c_led_send_CRWL(0);
+    i2c_led_select_page(0, 3);
+    i2c_led_send_mode_op_gcr(0, ISSI3733_CR_SYNC_MASTER, ISSI3733_CR_SSD_NORMAL);
+
+    //Set up slave device
+    i2c_led_send_CRWL(1);
+    i2c_led_select_page(1, 3);
+    i2c_led_send_mode_op_gcr(1, ISSI3733_CR_SYNC_SLAVE, ISSI3733_CR_SSD_NORMAL);
+
+    i2c_led_send_CRWL(0);
+    i2c_led_select_page(0, 3);
+    i2c_led_send_pur_pdr(0, ISSI3733_SWYR_PUR_8000, ISSI3733_CSXR_PDR_8000);
+
+    i2c_led_send_CRWL(1);
+    i2c_led_select_page(1, 3);
+    i2c_led_send_pur_pdr(1, ISSI3733_SWYR_PUR_8000, ISSI3733_CSXR_PDR_8000);
+
+    DBGC(DC_I2C3733_INIT_DRIVERS_COMPLETE);
+
+    return 1;
+}
+
+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
+
+    NVIC_EnableIRQ(DMAC_0_IRQn);
+    dmac->Channel[0].CHINTENSET.bit.TCMPL = 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
+
+    DBGC(DC_I2C_DMAC_LED_INIT_COMPLETE);
+}
+
+//state = 1 enable
+//state = 0 disable
+void I2C3733_Control_Set(uint8_t state)
+{
+    DBGC(DC_I2C3733_CONTROL_SET_BEGIN);
+
+    srdata.bit.SDB_N = (state == 1 ? 1 : 0);
+    SPI_WriteSRData();
+
+    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_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.DESCADDR.reg = 0;
+}
+
+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
+}
+
+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;
+    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;
+    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
+    memcpy(dma_sendbuf, issidrv[drvid].pwm, ISSI3733_PG1_BYTES);
+    *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
+    memcpy(dma_sendbuf, issidrv[drvid].onoff, ISSI3733_PG0_BYTES);
+    *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)
+{
+    memset(i2c_led_q, 0, I2C_Q_SIZE);
+    i2c_led_q_s = 0;
+    i2c_led_q_e = 0;
+    i2c_led_q_running = 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_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
+}
+
+void i2c_led_q_add(uint8_t cmd)
+{
+    //WARNING: Always request room before adding commands!
+
+    //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
+}
+
+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())
+    {
+        i2c_led_q_full++;
+
+        if (i2c_led_q_full >= 100) //Give the queue a chance to clear up
+        {
+            led_on;
+            I2C_DMAC_LED_Init();
+            i2c_led_q_init();
+            return 1;
+        }
+
+        return 0;
+    }
+
+    i2c_led_q_full = 0;
+
+    return 1;
+}
+
+uint8_t i2c_led_q_run(void)
+{
+    if (i2c_led_q_isempty())
+    {
+        i2c_led_q_running = 0;
+        return 0;
+    }
+
+    if (i2c_led_q_running) return 1;
+
+    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)
+        {
+            i2c_led_q_s_advance();
+            uint8_t drvid = i2c_led_q[i2c_led_q_s];
+#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)
+        {
+            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
+            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)
+        {
+            i2c_led_q_s_advance();
+            uint8_t drvid = i2c_led_q[i2c_led_q_s];
+#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)
+        {
+            i2c_led_q_s_advance();
+            uint8_t drvid = i2c_led_q[i2c_led_q_s];
+#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)
+        {
+            i2c_led_q_s_advance();
+            uint8_t drvid = i2c_led_q[i2c_led_q_s];
+#if I2C_LED_USE_DMA == 1
+            i2c_led_send_onoff_dma(drvid);
+#else
+            i2c_led_send_onoff(drvid);
+#endif
+        }
+
+        i2c_led_q_s_advance(); //Advance last run command or if the command byte was not serviced
+
+#if I2C_LED_USE_DMA != 1
+    }
+
+    i2c_led_q_running = 0;
+#endif
+
+    return 1;
+}
+#endif //MD_BOOTLOADER
diff --git a/tmk_core/protocol/arm_atsam/i2c_master.h b/tmk_core/protocol/arm_atsam/i2c_master.h
new file mode 100644
index 000000000..99481366a
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/i2c_master.h
@@ -0,0 +1,108 @@
+/*
+Copyright 2018 Massdrop Inc.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _I2C_MASTER_H_
+#define _I2C_MASTER_H_
+
+#ifndef MD_BOOTLOADER
+
+#include "samd51j18a.h"
+#include "issi3733_driver.h"
+#include "config.h"
+
+__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);
+
+#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_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);
+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);
+uint8_t i2c1_transmit(uint8_t address, uint8_t *data, uint16_t length, uint16_t timeout);
+void i2c1_stop(void);
+
+#endif //MD_BOOTLOADER
+
+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_
+
diff --git a/tmk_core/protocol/arm_atsam/issi3733_driver.h b/tmk_core/protocol/arm_atsam/issi3733_driver.h
new file mode 100644
index 000000000..a537029f0
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/issi3733_driver.h
@@ -0,0 +1,201 @@
+/*
+Copyright 2018 Massdrop Inc.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _ISSI3733_DRIVER_H_
+#define _ISSI3733_DRIVER_H_
+
+//ISII3733 Registers
+
+#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_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_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
+#define ISSI3733_PG_SR ISSI3733_PG0
+#define ISSI3733_PG_PWM ISSI3733_PG1
+#define ISSI3733_PG_ABM ISSI3733_PG2
+#define ISSI3733_PG_FN ISSI3733_PG3
+
+#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: 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
+
+//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
+
+//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_ABCR3_LTA_LOOP_ENDLESS 0x00
+#define ISSI3733_ABCR3_LTA_LOOP_1 0x01
+#define ISSI3733_ABCR3_LTA_LOOP_2 0x02
+#define ISSI3733_ABCR3_LTA_LOOP_3 0x03
+#define ISSI3733_ABCR3_LTA_LOOP_4 0x04
+#define ISSI3733_ABCR3_LTA_LOOP_5 0x05
+#define ISSI3733_ABCR3_LTA_LOOP_6 0x06
+#define ISSI3733_ABCR3_LTA_LOOP_7 0x07
+#define ISSI3733_ABCR3_LTA_LOOP_8 0x08
+#define ISSI3733_ABCR3_LTA_LOOP_9 0x09
+#define ISSI3733_ABCR3_LTA_LOOP_10 0x0A
+#define ISSI3733_ABCR3_LTA_LOOP_11 0x0B
+#define ISSI3733_ABCR3_LTA_LOOP_12 0x0C
+#define ISSI3733_ABCR3_LTA_LOOP_13 0x0D
+#define ISSI3733_ABCR3_LTA_LOOP_14 0x0E
+#define ISSI3733_ABCR3_LTA_LOOP_15 0x0F
+
+//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
+
+//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
+
+//PG3: Time Update Register
+#define ISSI3733_TUR 0x0E
+#define ISSI3733_TUR_UPDATE 0x00        //Write to update 02h~0Dh time registers after configuring
+
+//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_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_
diff --git a/tmk_core/protocol/arm_atsam/led_matrix.c b/tmk_core/protocol/arm_atsam/led_matrix.c
new file mode 100644
index 000000000..7ee1dad22
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/led_matrix.c
@@ -0,0 +1,509 @@
+/*
+Copyright 2018 Massdrop Inc.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "arm_atsam_protocol.h"
+#include "tmk_core/common/led.h"
+#include <string.h>
+
+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)
+    {
+        DMAC->Channel[0].CHINTFLAG.reg = DMAC_CHINTENCLR_TCMPL;
+
+        i2c1_stop();
+
+        i2c_led_q_running = 0;
+
+        i2c_led_q_run();
+
+        return;
+    }
+
+    if (DMAC->Channel[0].CHINTFLAG.bit.TERR)
+    {
+        DMAC->Channel[0].CHINTFLAG.reg = DMAC_CHINTENCLR_TERR;
+    }
+}
+
+issi3733_driver_t issidrv[ISSI3733_DRIVER_COUNT];
+
+issi3733_led_t led_map[ISSI3733_LED_COUNT+1] = ISSI3733_LED_MAP;
+issi3733_led_t *lede = led_map + ISSI3733_LED_COUNT; //End pointer of mapping
+
+uint8_t gcr_desired;
+uint8_t gcr_breathe;
+uint8_t gcr_use;
+uint8_t gcr_actual;
+uint8_t gcr_actual_last;
+
+#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;
+
+    if (led_animation_breathing)
+        gcr_use = gcr_breathe;
+    else
+        gcr_use = gcr_desired;
+
+    //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
+        return;
+    }
+    else if (v_5v_cat_hit > 1)
+    {
+        v_5v_cat_hit--;
+        return;
+    }
+    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 (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;
+        gcr_min_counter = 0;
+    }
+    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
+            {
+                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
+                    {
+                        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");
+                    }
+                }
+            }
+        }
+        else
+        {
+            //Power successfully cut back from LED drivers
+            gcr_actual -= LED_GCR_STEP_AUTO;
+            gcr_min_counter = 0;
+
+            //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
+                //    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
+            }
+        }
+    }
+}
+
+led_disp_t disp;
+
+void issi3733_prepare_arrays(void)
+{
+    memset(issidrv,0,sizeof(issi3733_driver_t) * ISSI3733_DRIVER_COUNT);
+
+    int i;
+    uint8_t addrs[ISSI3733_DRIVER_COUNT] = ISSI3773_DRIVER_ADDRESSES;
+
+    for (i=0;i<ISSI3733_DRIVER_COUNT;i++)
+    {
+        issidrv[i].addr = addrs[i];
+    }
+
+    issi3733_led_t *cur = led_map;
+
+    while (cur < lede)
+    {
+        //BYTE: 1 + (SW-1)*16 + (CS-1)
+        cur->rgb.g = issidrv[cur->adr.drv-1].pwm + 1 + ((cur->adr.swg-1)*16 + (cur->adr.cs-1));
+        cur->rgb.r = issidrv[cur->adr.drv-1].pwm + 1 + ((cur->adr.swr-1)*16 + (cur->adr.cs-1));
+        cur->rgb.b = issidrv[cur->adr.drv-1].pwm + 1 + ((cur->adr.swb-1)*16 + (cur->adr.cs-1));
+
+        //BYTE: 1 + (SW-1)*2 + (CS-1)/8
+        //BIT: (CS-1)%8
+        *(issidrv[cur->adr.drv-1].onoff + 1 + (cur->adr.swg-1)*2+(cur->adr.cs-1)/8) |= (1<<((cur->adr.cs-1)%8));
+        *(issidrv[cur->adr.drv-1].onoff + 1 + (cur->adr.swr-1)*2+(cur->adr.cs-1)/8) |= (1<<((cur->adr.cs-1)%8));
+        *(issidrv[cur->adr.drv-1].onoff + 1 + (cur->adr.swb-1)*2+(cur->adr.cs-1)/8) |= (1<<((cur->adr.cs-1)%8));
+
+        cur++;
+    }
+}
+
+void disp_calc_extents(void)
+{
+    issi3733_led_t *cur = led_map;
+
+    disp.left = 1e10;
+    disp.right = -1e10;
+    disp.top = -1e10;
+    disp.bottom = 1e10;
+
+    while (cur < lede)
+    {
+        if (cur->x < disp.left) disp.left = cur->x;
+        if (cur->x > disp.right) disp.right = cur->x;
+        if (cur->y < disp.bottom) disp.bottom = cur->y;
+        if (cur->y > disp.top) disp.top = cur->y;
+
+        cur++;
+    }
+
+    disp.width = disp.right - disp.left;
+    disp.height = disp.top - disp.bottom;
+}
+
+void disp_pixel_setup(void)
+{
+    issi3733_led_t *cur = led_map;
+
+    while (cur < lede)
+    {
+        cur->px = (cur->x - disp.left) / disp.width * 100;
+        cur->py = (cur->y - disp.top) / disp.height * 100;
+        *cur->rgb.r = 0;
+        *cur->rgb.g = 0;
+        *cur->rgb.b = 0;
+
+        cur++;
+    }
+}
+
+void led_matrix_prepare(void)
+{
+    disp_calc_extents();
+    disp_pixel_setup();
+}
+
+uint8_t led_enabled;
+float led_animation_speed;
+uint8_t led_animation_direction;
+uint8_t led_animation_breathing;
+uint8_t led_animation_breathe_cur;
+uint8_t breathe_step;
+uint8_t breathe_dir;
+uint64_t led_next_run;
+
+uint8_t led_animation_id;
+uint8_t led_lighting_mode;
+
+issi3733_led_t *led_cur;
+uint8_t led_per_run = 15;
+float breathe_mult;
+
+void led_matrix_run(led_setup_t *f)
+{
+    float ro;
+    float go;
+    float bo;
+    float px;
+    uint8_t led_this_run = 0;
+
+    if (led_cur == 0) //Denotes start of new processing cycle in the case of chunked processing
+    {
+        led_cur = led_map;
+
+        disp.frame += 1;
+
+        breathe_mult = 1;
+
+        if (led_animation_breathing)
+        {
+            led_animation_breathe_cur += breathe_step * breathe_dir;
+
+            if (led_animation_breathe_cur >= BREATHE_MAX_STEP)
+                breathe_dir = -1;
+            else if (led_animation_breathe_cur <= BREATHE_MIN_STEP)
+                breathe_dir = 1;
+
+            //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;
+        }
+    }
+
+    uint8_t fcur = 0;
+    uint8_t fmax = 0;
+
+    //Frames setup
+    while (f[fcur].end != 1)
+    {
+        fcur++; //Count frames
+    }
+
+    fmax = fcur; //Store total frames count
+
+    while (led_cur < lede && led_this_run < led_per_run)
+    {
+        ro = 0;
+        go = 0;
+        bo = 0;
+
+        if (led_lighting_mode == LED_MODE_KEYS_ONLY && led_cur->scan == 255)
+        {
+            //Do not act on this LED
+        }
+        else if (led_lighting_mode == LED_MODE_NON_KEYS_ONLY && led_cur->scan != 255)
+        {
+            //Do not act on this LED
+        }
+        else if (led_lighting_mode == LED_MODE_INDICATORS_ONLY)
+        {
+            //Do not act on this LED (Only show indicators)
+        }
+        else
+        {
+            //Act on LED
+            for (fcur = 0; fcur < fmax; fcur++)
+            {
+                px = led_cur->px;
+                float pxmod;
+                pxmod = (float)(disp.frame % (uint32_t)(1000.0f / led_animation_speed)) / 10.0f * led_animation_speed;
+
+                //Add in any moving effects
+                if ((!led_animation_direction && f[fcur].ef & EF_SCR_R) || (led_animation_direction && (f[fcur].ef & EF_SCR_L)))
+                {
+                    pxmod *= 100.0f;
+                    pxmod = (uint32_t)pxmod % 10000;
+                    pxmod /= 100.0f;
+
+                    px -= pxmod;
+
+                    if (px > 100) px -= 100;
+                    else if (px < 0) px += 100;
+                }
+                else if ((!led_animation_direction && f[fcur].ef & EF_SCR_L) || (led_animation_direction && (f[fcur].ef & EF_SCR_R)))
+                {
+                    pxmod *= 100.0f;
+                    pxmod = (uint32_t)pxmod % 10000;
+                    pxmod /= 100.0f;
+                    px += pxmod;
+
+                    if (px > 100) px -= 100;
+                    else if (px < 0) px += 100;
+                }
+
+                //Check if LED's px is in current frame
+                if (px < f[fcur].hs) continue;
+                if (px > f[fcur].he) continue;
+                //note: < 0 or > 100 continue
+
+                //Calculate the px within the start-stop percentage for color blending
+                px = (px - f[fcur].hs) / (f[fcur].he - f[fcur].hs);
+
+                //Add in any color effects
+                if (f[fcur].ef & EF_OVER)
+                {
+                    ro = (px * (f[fcur].re - f[fcur].rs)) + f[fcur].rs;// + 0.5;
+                    go = (px * (f[fcur].ge - f[fcur].gs)) + f[fcur].gs;// + 0.5;
+                    bo = (px * (f[fcur].be - f[fcur].bs)) + f[fcur].bs;// + 0.5;
+                }
+                else if (f[fcur].ef & EF_SUBTRACT)
+                {
+                    ro -= (px * (f[fcur].re - f[fcur].rs)) + f[fcur].rs;// + 0.5;
+                    go -= (px * (f[fcur].ge - f[fcur].gs)) + f[fcur].gs;// + 0.5;
+                    bo -= (px * (f[fcur].be - f[fcur].bs)) + f[fcur].bs;// + 0.5;
+                }
+                else
+                {
+                    ro += (px * (f[fcur].re - f[fcur].rs)) + f[fcur].rs;// + 0.5;
+                    go += (px * (f[fcur].ge - f[fcur].gs)) + f[fcur].gs;// + 0.5;
+                    bo += (px * (f[fcur].be - f[fcur].bs)) + f[fcur].bs;// + 0.5;
+                }
+            }
+        }
+
+        //Clamp values 0-255
+        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;
+        }
+
+        *led_cur->rgb.r = (uint8_t)ro;
+        *led_cur->rgb.g = (uint8_t)go;
+        *led_cur->rgb.b = (uint8_t)bo;
+
+#ifdef USB_LED_INDICATOR_ENABLE
+        if (keyboard_leds())
+        {
+            uint8_t kbled = keyboard_leds();
+            if (
+                #if USB_LED_NUM_LOCK_SCANCODE != 255
+                (led_cur->scan == USB_LED_NUM_LOCK_SCANCODE && kbled & (1<<USB_LED_NUM_LOCK)) ||
+                #endif //NUM LOCK
+                #if USB_LED_CAPS_LOCK_SCANCODE != 255
+                (led_cur->scan == USB_LED_CAPS_LOCK_SCANCODE && kbled & (1<<USB_LED_CAPS_LOCK)) ||
+                #endif //CAPS LOCK
+                #if USB_LED_SCROLL_LOCK_SCANCODE != 255
+                (led_cur->scan == USB_LED_SCROLL_LOCK_SCANCODE && kbled & (1<<USB_LED_SCROLL_LOCK)) ||
+                #endif //SCROLL LOCK
+                #if USB_LED_COMPOSE_SCANCODE != 255
+                (led_cur->scan == USB_LED_COMPOSE_SCANCODE && kbled & (1<<USB_LED_COMPOSE)) ||
+                #endif //COMPOSE
+                #if USB_LED_KANA_SCANCODE != 255
+                (led_cur->scan == USB_LED_KANA_SCANCODE && kbled & (1<<USB_LED_KANA)) ||
+                #endif //KANA
+                (0))
+            {
+                if (*led_cur->rgb.r > 127) *led_cur->rgb.r = 0;
+                else *led_cur->rgb.r = 255;
+                if (*led_cur->rgb.g > 127) *led_cur->rgb.g = 0;
+                else *led_cur->rgb.g = 255;
+                if (*led_cur->rgb.b > 127) *led_cur->rgb.b = 0;
+                else *led_cur->rgb.b = 255;
+            }
+        }
+#endif //USB_LED_INDICATOR_ENABLE
+
+        led_cur++;
+        led_this_run++;
+    }
+}
+
+uint8_t led_matrix_init(void)
+{
+    DBGC(DC_LED_MATRIX_INIT_BEGIN);
+
+    issi3733_prepare_arrays();
+
+    led_matrix_prepare();
+
+    disp.frame = 0;
+    led_next_run = 0;
+
+    led_enabled = 1;
+    led_animation_id = 0;
+    led_lighting_mode = LED_MODE_NORMAL;
+    led_animation_speed = 4.0f;
+    led_animation_direction = 0;
+    led_animation_breathing = 0;
+    led_animation_breathe_cur = BREATHE_MIN_STEP;
+    breathe_step = 1;
+    breathe_dir = 1;
+
+    gcr_min_counter = 0;
+    v_5v_cat_hit = 0;
+
+    //Run led matrix code once for initial LED coloring
+    led_cur = 0;
+    led_matrix_run((led_setup_t*)led_setups[led_animation_id]);
+
+    DBGC(DC_LED_MATRIX_INIT_COMPLETE);
+
+    return 0;
+}
+
+#define LED_UPDATE_RATE 10  //ms
+
+//led data processing can take time, so process data in chunks to free up the processor
+//this is done through led_cur and lede
+void led_matrix_task(void)
+{
+    if (led_enabled)
+    {
+        //If an update may run and frame processing has completed
+        if (CLK_get_ms() >= led_next_run && led_cur == lede)
+        {
+            uint8_t drvid;
+
+            led_next_run = CLK_get_ms() + LED_UPDATE_RATE;  //Set next frame update time
+
+            //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
+
+            i2c_led_q_run();
+
+            led_cur = 0; //Signal next frame calculations may begin
+        }
+    }
+
+    //Process more data if not finished
+    if (led_cur != lede)
+    {
+        //m15_off; //debug profiling
+        led_matrix_run((led_setup_t*)led_setups[led_animation_id]);
+        //m15_on; //debug profiling
+    }
+}
+
diff --git a/tmk_core/protocol/arm_atsam/led_matrix.h b/tmk_core/protocol/arm_atsam/led_matrix.h
new file mode 100644
index 000000000..01b078b71
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/led_matrix.h
@@ -0,0 +1,142 @@
+/*
+Copyright 2018 Massdrop Inc.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _LED_MATRIX_H_
+#define _LED_MATRIX_H_
+
+//From keyboard
+#include "config_led.h"
+
+//CS1-CS16 Current Source "Col"
+#define ISSI3733_CS_COUNT 16
+
+//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_PG_ONOFF_BYTES ISSI3733_PG0_BYTES
+#define ISSI3733_PG_OR_BYTES ISSI3733_PG0_BYTES
+#define ISSI3733_PG_SR_BYTES ISSI3733_PG0_BYTES
+#define ISSI3733_PG_PWM_BYTES ISSI3733_PG1_BYTES
+#define ISSI3733_PG_ABM_BYTES ISSI3733_PG2_BYTES
+#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
+} 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
+} 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
+} 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)
+} issi3733_led_t;
+
+typedef struct led_disp_s {
+    uint64_t frame;
+    float left;
+    float right;
+    float top;
+    float bottom;
+    float width;
+    float height;
+} led_disp_t;
+
+uint8_t led_matrix_init(void);
+
+#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 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
+} led_setup_t;
+
+extern issi3733_driver_t issidrv[ISSI3733_DRIVER_COUNT];
+
+extern uint8_t gcr_desired;
+extern uint8_t gcr_breathe;
+extern uint8_t gcr_actual;
+extern uint8_t gcr_actual_last;
+
+extern uint8_t led_animation_id;
+extern uint8_t led_enabled;
+extern float led_animation_speed;
+extern uint8_t led_lighting_mode;
+extern uint8_t led_animation_direction;
+extern uint8_t led_animation_breathing;
+extern uint8_t led_animation_breathe_cur;
+extern uint8_t breathe_dir;
+extern const uint8_t led_setups_count;
+
+extern void *led_setups[];
+
+extern issi3733_led_t *led_cur;
+extern issi3733_led_t *lede;
+
+void led_matrix_run(led_setup_t *f);
+void led_matrix_task(void);
+
+void gcr_compute(void);
+
+#endif //_LED_MATRIX_H_
diff --git a/tmk_core/protocol/arm_atsam/main_arm_atsam.c b/tmk_core/protocol/arm_atsam/main_arm_atsam.c
new file mode 100644
index 000000000..e9514730e
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/main_arm_atsam.c
@@ -0,0 +1,279 @@
+/*
+Copyright 2018 Massdrop Inc.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "samd51j18a.h"
+#include "tmk_core/common/keyboard.h"
+
+#include "report.h"
+#include "host.h"
+#include "host_driver.h"
+#include "keycode_config.h"
+#include <string.h>
+#include "quantum.h"
+
+//From protocol directory
+#include "arm_atsam_protocol.h"
+
+//From keyboard's directory
+#include "config_led.h"
+
+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
+};
+
+uint8_t led_states;
+
+uint8_t keyboard_leds(void)
+{
+#ifdef NKRO_ENABLE
+    if (keymap_config.nkro)
+        return udi_hid_nkro_report_set;
+    else
+#endif //NKRO_ENABLE
+        return udi_hid_kbd_report_set;
+}
+
+void send_keyboard(report_keyboard_t *report)
+{
+    uint32_t irqflags;
+
+#ifdef NKRO_ENABLE
+    if (!keymap_config.nkro)
+    {
+#endif //NKRO_ENABLE
+        dprint("s-kbd\r\n");
+
+        irqflags = __get_PRIMASK();
+        __disable_irq();
+        __DMB();
+
+        memcpy(udi_hid_kbd_report, report->raw, UDI_HID_KBD_REPORT_SIZE);
+        udi_hid_kbd_b_report_valid = 1;
+        udi_hid_kbd_send_report();
+
+        __DMB();
+        __set_PRIMASK(irqflags);
+#ifdef NKRO_ENABLE
+    }
+    else
+    {
+        dprint("s-nkro\r\n");
+
+        irqflags = __get_PRIMASK();
+        __disable_irq();
+        __DMB();
+
+        memcpy(udi_hid_nkro_report, report->raw, UDI_HID_NKRO_REPORT_SIZE);
+        udi_hid_nkro_b_report_valid = 1;
+        udi_hid_nkro_send_report();
+
+        __DMB();
+        __set_PRIMASK(irqflags);
+    }
+#endif //NKRO_ENABLE
+}
+
+void send_mouse(report_mouse_t *report)
+{
+#ifdef MOUSEKEY_ENABLE
+    uint32_t irqflags;
+
+    dprint("s-mou\r\n");
+
+    irqflags = __get_PRIMASK();
+    __disable_irq();
+    __DMB();
+
+    memcpy(udi_hid_mou_report, report, UDI_HID_MOU_REPORT_SIZE);
+    udi_hid_mou_b_report_valid = 1;
+    udi_hid_mou_send_report();
+
+    __DMB();
+    __set_PRIMASK(irqflags);
+#endif //MOUSEKEY_ENABLE
+}
+
+void send_system(uint16_t data)
+{
+#ifdef EXTRAKEY_ENABLE
+    dprintf("s-exks %i\r\n", data);
+
+    uint32_t irqflags;
+
+    irqflags = __get_PRIMASK();
+    __disable_irq();
+    __DMB();
+
+    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_send_report();
+
+    __DMB();
+    __set_PRIMASK(irqflags);
+#endif //EXTRAKEY_ENABLE
+}
+
+void send_consumer(uint16_t data)
+{
+#ifdef EXTRAKEY_ENABLE
+    dprintf("s-exkc %i\r\n",data);
+
+    uint32_t irqflags;
+
+    irqflags = __get_PRIMASK();
+    __disable_irq();
+    __DMB();
+
+    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_send_report();
+
+    __DMB();
+    __set_PRIMASK(irqflags);
+#endif //EXTRAKEY_ENABLE
+}
+
+int main(void)
+{
+    led_ena;
+    m15_ena;
+
+    debug_code_init();
+
+    CLK_init();
+
+    ADC0_init();
+
+    SPI_Init();
+
+    i2c1_init();
+
+    matrix_init();
+
+    USB2422_init();
+
+    DBGC(DC_MAIN_UDC_START_BEGIN);
+    udc_start();
+    DBGC(DC_MAIN_UDC_START_COMPLETE);
+
+    DBGC(DC_MAIN_CDC_INIT_BEGIN);
+    CDC_init();
+    DBGC(DC_MAIN_CDC_INIT_COMPLETE);
+
+    while (USB2422_Port_Detect_Init() == 0) {}
+
+    led_off;
+    m15_off;
+
+    led_matrix_init();
+
+    while (I2C3733_Init_Control() != 1) {}
+    while (I2C3733_Init_Drivers() != 1) {}
+
+    I2C_DMAC_LED_Init();
+
+    i2c_led_q_init();
+
+    uint8_t drvid;
+    for (drvid=0;drvid<ISSI3733_DRIVER_COUNT;drvid++)
+        I2C_LED_Q_ONOFF(drvid); //Queue data
+
+    keyboard_setup();
+
+    keyboard_init();
+
+    host_set_driver(&arm_atsam_driver);
+
+#ifdef VIRTSER_ENABLE
+    uint64_t next_print = 0;
+#endif //VIRTSER_ENABLE
+    uint64_t next_usb_checkup = 0;
+    uint64_t next_5v_checkup = 0;
+
+    v_5v_avg = adc_get(ADC_5V);
+
+    debug_code_disable();
+
+    while (1)
+    {
+        if (usb_state == USB_STATE_POWERDOWN)
+        {
+            led_on;
+            if (led_enabled)
+            {
+                for (drvid=0;drvid<ISSI3733_DRIVER_COUNT;drvid++)
+                {
+                    I2C3733_Control_Set(0);
+                }
+            }
+            while (usb_state == USB_STATE_POWERDOWN) {}
+            if (led_enabled)
+            {
+                for (drvid=0;drvid<ISSI3733_DRIVER_COUNT;drvid++)
+                {
+                    I2C3733_Control_Set(1);
+                }
+            }
+            led_off;
+        }
+
+        keyboard_task();
+
+        led_matrix_task();
+
+        if (CLK_get_ms() > next_5v_checkup)
+        {
+            next_5v_checkup = CLK_get_ms() + 5;
+
+            v_5v = adc_get(ADC_5V);
+            v_5v_avg = 0.9 * v_5v_avg + 0.1 * v_5v;
+
+            gcr_compute();
+        }
+
+        if (CLK_get_ms() > next_usb_checkup)
+        {
+            next_usb_checkup = CLK_get_ms() + 10;
+
+            USB_HandleExtraDevice();
+        }
+
+#ifdef VIRTSER_ENABLE
+        if (CLK_get_ms() > next_print)
+        {
+            next_print = CLK_get_ms() + 250;
+            //dpf("5v=%i 5vu=%i dlow=%i dhi=%i gca=%i gcd=%i\r\n",v_5v,v_5v_avg,v_5v_avg-V5_LOW,v_5v_avg-V5_HIGH,gcr_actual,gcr_desired);
+        }
+#endif //VIRTSER_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
new file mode 100644
index 000000000..78205e2e1
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/main_arm_atsam.h
@@ -0,0 +1,23 @@
+/*
+Copyright 2018 Massdrop Inc.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _MAIN_ARM_ATSAM_H_
+#define _MAIN_ARM_ATSAM_H_
+
+uint8_t keyboard_leds(void);
+
+#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
new file mode 100644
index 000000000..1316876c8
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/md_bootloader.h
@@ -0,0 +1,18 @@
+#ifndef _MD_BOOTLOADER_H_
+#define _MD_BOOTLOADER_H_
+
+extern uint32_t _srom;
+extern uint32_t _lrom;
+extern uint32_t _erom;
+
+#define BOOTLOADER_SERIAL_MAX_SIZE 20   //DO NOT MODIFY!
+
+#ifdef MD_BOOTLOADER
+
+#define MCU_HZ 48000000
+#define I2C_HZ 0 //Not used
+
+#endif //MD_BOOTLOADER
+
+#endif //_MD_BOOTLOADER_H_
+
diff --git a/tmk_core/protocol/arm_atsam/spi.c b/tmk_core/protocol/arm_atsam/spi.c
new file mode 100644
index 000000000..6036a9220
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/spi.c
@@ -0,0 +1,90 @@
+/*
+Copyright 2018 Massdrop Inc.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "arm_atsam_protocol.h"
+
+Srdata_t srdata;
+
+void SPI_WriteSRData(void)
+{
+    uint16_t timeout;
+
+    SC2_RCLCK_LO;
+
+    timeout = 50000;
+    while (!(SCSPI->SPI.INTFLAG.bit.DRE) && --timeout) { DBGC(DC_SPI_WRITE_DRE); }
+
+    SCSPI->SPI.DATA.bit.DATA = srdata.reg & 0xFF; //Shift in bits 7-0
+    timeout = 50000;
+    while (!(SCSPI->SPI.INTFLAG.bit.TXC) && --timeout) { DBGC(DC_SPI_WRITE_TXC_1); }
+
+    SCSPI->SPI.DATA.bit.DATA = (srdata.reg >> 8) & 0xFF; //Shift in bits 15-8
+    timeout = 50000;
+    while (!(SCSPI->SPI.INTFLAG.bit.TXC) && --timeout) { DBGC(DC_SPI_WRITE_TXC_2); }
+
+    SC2_RCLCK_HI;
+}
+
+void SPI_Init(void)
+{
+    uint32_t timeout;
+
+    DBGC(DC_SPI_INIT_BEGIN);
+
+    CLK_set_spi_freq(CHAN_SERCOM_SPI, FREQ_SPI_DEFAULT);
+
+    PORT->Group[0].PMUX[6].bit.PMUXE = 2;
+    PORT->Group[0].PMUX[6].bit.PMUXO = 2;
+    PORT->Group[0].PINCFG[12].bit.PMUXEN = 1;
+    PORT->Group[0].PINCFG[13].bit.PMUXEN = 1;
+
+    //Configure Shift Registers
+    SC2_DIRSET;
+    SC2_RCLCK_HI;
+    SC2_OE_DIS;
+
+    SCSPI->SPI.CTRLA.bit.DORD = 1;
+    SCSPI->SPI.CTRLA.bit.CPOL = 1;
+    SCSPI->SPI.CTRLA.bit.CPHA = 1;
+    SCSPI->SPI.CTRLA.bit.DIPO = 3;
+    SCSPI->SPI.CTRLA.bit.MODE = 3; //master
+
+    SCSPI->SPI.CTRLA.bit.ENABLE = 1;
+    timeout = 50000;
+    while (SCSPI->SPI.SYNCBUSY.bit.ENABLE && timeout--) { DBGC(DC_SPI_SYNC_ENABLING); }
+
+    srdata.reg = 0;
+    srdata.bit.HUB_CONNECT = 0;
+    srdata.bit.HUB_RESET_N = 0;
+    srdata.bit.S_UP = 0;
+    srdata.bit.E_UP_N = 1;
+    srdata.bit.S_DN1 = 1;
+    srdata.bit.E_DN1_N = 1;
+    srdata.bit.E_VBUS_1 = 0;
+    srdata.bit.E_VBUS_2 = 0;
+    srdata.bit.SRC_1 = 1;
+    srdata.bit.SRC_2 = 1;
+    srdata.bit.IRST = 1;
+    srdata.bit.SDB_N = 0;
+    SPI_WriteSRData();
+
+    //Enable register output
+    SC2_OE_ENA;
+
+    DBGC(DC_SPI_INIT_COMPLETE);
+}
+
diff --git a/tmk_core/protocol/arm_atsam/spi.h b/tmk_core/protocol/arm_atsam/spi.h
new file mode 100644
index 000000000..3412dfc36
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/spi.h
@@ -0,0 +1,63 @@
+/*
+Copyright 2018 Massdrop Inc.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _SPI_H_
+#define _SPI_H_
+
+//TODO: PS: Should bring ports to keyboard configuration
+
+#define SCSPI           SERCOM2
+
+#define P14_DIR         0x00004000                             /* PIN14 DIR Bit */
+#define P14_OUT         0x00004000                             /* PIN14 OUT Bit */
+#define P15_DIR         0x00008000                             /* PIN15 DIR Bit */
+#define P15_OUT         0x00008000                             /* PIN15 OUT Bit */
+
+#define SC2_RCLCK_LO    REG_PORT_OUTCLR1 = P14_OUT             /* PB14 Low, SC2_RCLCK Low                            */
+#define SC2_RCLCK_HI    REG_PORT_OUTSET1 = P14_OUT             /* PB14 High, SC2_RCLCK High                          */
+#define SC2_OE_ENA      REG_PORT_OUTCLR1 = P15_OUT             /* PB15 Low, SC2_OE_N Low (Shift register enabled)    */
+#define SC2_OE_DIS      REG_PORT_OUTSET1 = P15_OUT             /* PB15 High, SC2_OE_N High (Shift register disabled) */
+#define SC2_DIRSET      REG_PORT_DIRSET1 = P14_DIR | P15_DIR;  /* PB14 PB15 OUT                                      */
+
+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                        */
+} Srdata_t;
+
+extern Srdata_t srdata;
+
+void SPI_WriteSRData(void);
+void SPI_Init(void);
+
+#endif //_SPI_H_
diff --git a/tmk_core/protocol/arm_atsam/startup.c b/tmk_core/protocol/arm_atsam/startup.c
new file mode 100644
index 000000000..a62d02f1c
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/startup.c
@@ -0,0 +1,548 @@
+/**
+ * \file
+ *
+ * \brief gcc starttup file for SAMD51
+ *
+ * Copyright (c) 2017 Microchip Technology Inc.
+ *
+ * \asf_license_start
+ *
+ * \page License
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * 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.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * \asf_license_stop
+ *
+ */
+
+#include "samd51.h"
+
+/* Initialize segments */
+extern uint32_t _sfixed;
+extern uint32_t _efixed;
+extern uint32_t _etext;
+extern uint32_t _srelocate;
+extern uint32_t _erelocate;
+extern uint32_t _szero;
+extern uint32_t _ezero;
+extern uint32_t _sstack;
+extern uint32_t _estack;
+
+/** \cond DOXYGEN_SHOULD_SKIP_THIS */
+int main(void);
+/** \endcond */
+
+void __libc_init_array(void);
+
+/* Default empty handler */
+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")));
+
+/* 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 */
+#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 */
+#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 */
+#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 */
+#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 */
+#endif
+#ifdef ID_CAN0
+void CAN0_Handler            ( void ) __attribute__ ((weak, alias("Dummy_Handler")));
+#endif
+#ifdef ID_CAN1
+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 */
+#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 */
+#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 */
+#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")));
+#ifdef ID_TC4
+void TC4_Handler             ( void ) __attribute__ ((weak, alias("Dummy_Handler")));
+#endif
+#ifdef ID_TC5
+void TC5_Handler             ( void ) __attribute__ ((weak, alias("Dummy_Handler")));
+#endif
+#ifdef ID_TC6
+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 */
+#ifdef ID_I2S
+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")));
+#ifdef ID_ICM
+void ICM_Handler             ( void ) __attribute__ ((weak, alias("Dummy_Handler")));
+#endif
+#ifdef ID_PUKCC
+void PUKCC_Handler           ( void ) __attribute__ ((weak, alias("Dummy_Handler")));
+#endif
+void QSPI_Handler            ( void ) __attribute__ ((weak, alias("Dummy_Handler")));
+#ifdef ID_SDHC0
+void SDHC0_Handler           ( void ) __attribute__ ((weak, alias("Dummy_Handler")));
+#endif
+#ifdef ID_SDHC1
+void SDHC1_Handler           ( void ) __attribute__ ((weak, alias("Dummy_Handler")));
+#endif
+
+/* Exception Table */
+__attribute__ ((section(".vectors")))
+const DeviceVectors exception_table = {
+
+        /* 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,
+
+        /* 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 */
+#else
+        .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 */
+#else
+        .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 */
+#else
+        .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 */
+#else
+        .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 */
+#else
+        .pvReserved78           = (void*) (0UL),                  /* 78 Reserved */
+#endif
+#ifdef ID_CAN1
+        .pfnCAN1_Handler        = (void*) CAN1_Handler,           /* 79 Control Area Network 1 */
+#else
+        .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 */
+#else
+        .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 */
+#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 */
+#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 */
+#else
+        .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 */
+#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 */
+#ifdef ID_TC4
+        .pfnTC4_Handler         = (void*) TC4_Handler,            /* 111 Basic Timer Counter 4 */
+#else
+        .pvReserved111          = (void*) (0UL),                  /* 111 Reserved */
+#endif
+#ifdef ID_TC5
+        .pfnTC5_Handler         = (void*) TC5_Handler,            /* 112 Basic Timer Counter 5 */
+#else
+        .pvReserved112          = (void*) (0UL),                  /* 112 Reserved */
+#endif
+#ifdef ID_TC6
+        .pfnTC6_Handler         = (void*) TC6_Handler,            /* 113 Basic Timer Counter 6 */
+#else
+        .pvReserved113          = (void*) (0UL),                  /* 113 Reserved */
+#endif
+#ifdef ID_TC7
+        .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 */
+#ifdef ID_I2S
+        .pfnI2S_Handler         = (void*) I2S_Handler,            /* 128 Inter-IC Sound Interface */
+#else
+        .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 */
+#ifdef ID_ICM
+        .pfnICM_Handler         = (void*) ICM_Handler,            /* 132 Integrity Check Monitor */
+#else
+        .pvReserved132          = (void*) (0UL),                  /* 132 Reserved */
+#endif
+#ifdef ID_PUKCC
+        .pfnPUKCC_Handler       = (void*) PUKCC_Handler,          /* 133 PUblic-Key Cryptography Controller */
+#else
+        .pvReserved133          = (void*) (0UL),                  /* 133 Reserved */
+#endif
+        .pfnQSPI_Handler        = (void*) QSPI_Handler,           /* 134 Quad SPI interface */
+#ifdef ID_SDHC0
+        .pfnSDHC0_Handler       = (void*) SDHC0_Handler,          /* 135 SD/MMC Host Controller 0 */
+#else
+        .pvReserved135          = (void*) (0UL),                  /* 135 Reserved */
+#endif
+#ifdef ID_SDHC1
+        .pfnSDHC1_Handler       = (void*) SDHC1_Handler           /* 136 SD/MMC Host Controller 1 */
+#else
+        .pvReserved136          = (void*) (0UL)                   /* 136 Reserved */
+#endif
+};
+
+/**
+ * \brief This is the code that gets called on processor reset.
+ * To initialize the device, and call the main() routine.
+ */
+void Reset_Handler(void)
+{
+        uint32_t *pSrc, *pDest;
+
+        /* Initialize the relocate segment */
+        pSrc = &_etext;
+        pDest = &_srelocate;
+
+        if (pSrc != pDest) {
+                for (; pDest < &_erelocate;) {
+                        *pDest++ = *pSrc++;
+                }
+        }
+
+        /* 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);
+
+#if __FPU_USED
+        /* Enable FPU */
+        SCB->CPACR |=  (0xFu << 20);
+        __DSB();
+        __ISB();
+#endif
+
+        /* Initialize the C library */
+        __libc_init_array();
+
+        /* Branch to main function */
+        main();
+
+        /* Infinite loop */
+        while (1);
+}
+
+/**
+ * \brief Default interrupt handler for unused IRQs.
+ */
+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
new file mode 100644
index 000000000..d33843986
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/usb/compiler.h
@@ -0,0 +1,1177 @@
+/**
+ * \file
+ *
+ * \brief Commonly used includes, types and macros.
+ *
+ * Copyright (C) 2012-2016 Atmel Corporation. All rights reserved.
+ *
+ * \asf_license_start
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. The name of Atmel may not be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * 4. This software may only be redistributed and used in connection with an
+ *    Atmel microcontroller product.
+ *
+ * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
+ * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * \asf_license_stop
+ *
+ */
+/*
+ * Support and FAQ: visit <a href="http://www.atmel.com/design-support/">Atmel Support</a>
+ */
+
+#ifndef UTILS_COMPILER_H_INCLUDED
+#define UTILS_COMPILER_H_INCLUDED
+
+/**
+ * \defgroup group_sam0_utils Compiler abstraction layer and code utilities
+ *
+ * Compiler abstraction layer and code utilities for Cortex-M0+ based Atmel SAM devices.
+ * This module provides various abstraction layers and utilities to make code compatible between different compilers.
+ *
+ * @{
+ */
+
+#if (defined __ICCARM__)
+#  include <intrinsics.h>
+#endif
+
+#include <stddef.h>
+//#include <parts.h>
+//#include <status_codes.h>
+//#include <preprocessor.h>
+//#include <io.h>
+
+#ifndef __ASSEMBLY__
+
+#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)
+
+/**
+ * \def barrier
+ * \brief Memory barrier
+ */
+#ifdef __GNUC__
+#  define barrier()        asm volatile("" ::: "memory")
+#else
+#  define barrier()        asm ("")
+#endif
+
+/**
+ * \brief Emit the compiler pragma \a arg.
+ *
+ * \param[in] arg  The pragma directive as it would appear after \e \#pragma
+ *             (i.e. not stringified).
+ */
+#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))
+
+/**
+ * \def COMPILER_PACK_RESET()
+ * \brief Set default alignment for subsequent struct and union definitions.
+ */
+#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
+
+/**
+ * \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
+
+/**
+ * \def __always_inline
+ * \brief The function should always be inlined.
+ *
+ * This annotation instructs the compiler to ignore its inlining
+ * heuristics and inline the function no matter how big it thinks it
+ * becomes.
+ */
+#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
+
+/**
+ * \def __no_inline
+ * \brief The function should never be inlined
+ *
+ * This annotation instructs the compiler to ignore its inlining
+ * 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
+
+
+/** \brief This macro is used to test fatal errors.
+ *
+ * The macro tests if the expression is false. If it is, a fatal error is
+ * detected and the application hangs up. If \c TEST_SUITE_DEFINE_ASSERT_MACRO
+ * is defined, a unit test version of the macro is used, to allow execution
+ * of further tests after a false expression.
+ *
+ * \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
+
+/* 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
+
+/* 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
+
+//#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;
+/** @} */
+
+/** \name Aliasing Aggregate Types
+ * @{ */
+
+/** 16-bit union. */
+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];
+} 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];
+} 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;
+} 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;
+} 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;
+} 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;
+} 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;
+} 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;
+} 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;
+} 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;
+} StructCVPtr;
+
+/** @} */
+
+#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
+/** @} */
+
+#ifndef __ASSEMBLY__
+
+/** \name Optimization Control
+ * @{ */
+
+/**
+ * \def likely(exp)
+ * \brief The expression \a exp is likely to be true
+ */
+#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
+
+/**
+ * \def is_constant(exp)
+ * \brief Determine if an expression evaluates to a constant value.
+ *
+ * \param[in] exp Any expression
+ *
+ * \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
+
+/** @} */
+
+/** \name Bit-Field Handling
+ * @{ */
+
+/** \brief Reads the bits of a value specified by a given bit-mask.
+ *
+ * \param[in] value Value to read bits from.
+ * \param[in] mask  Bit-mask indicating bits to read.
+ *
+ * \return Read bits.
+ */
+#define Rd_bits( value, mask)        ((value) & (mask))
+
+/** \brief Writes the bits of a C lvalue specified by a given bit-mask.
+ *
+ * \param[in] lvalue  C lvalue to write bits to.
+ * \param[in] mask    Bit-mask indicating bits to write.
+ * \param[in] bits    Bits to write.
+ *
+ * \return Resulting value with written bits.
+ */
+#define Wr_bits(lvalue, mask, bits)  ((lvalue) = ((lvalue) & ~(mask)) |\
+                                                 ((bits  ) &  (mask)))
+
+/** \brief Tests the bits of a value specified by a given bit-mask.
+ *
+ * \param[in] value Value of which to test bits.
+ * \param[in] mask  Bit-mask indicating bits to test.
+ *
+ * \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)
+
+/** \brief Clears the bits of a C lvalue specified by a given bit-mask.
+ *
+ * \param[in] lvalue  C lvalue of which to clear bits.
+ * \param[in] mask    Bit-mask indicating bits to clear.
+ *
+ * \return Resulting value with cleared bits.
+ */
+#define Clr_bits(lvalue, mask)  ((lvalue) &= ~(mask))
+
+/** \brief Sets the bits of a C lvalue specified by a given bit-mask.
+ *
+ * \param[in] lvalue  C lvalue of which to set bits.
+ * \param[in] mask    Bit-mask indicating bits to set.
+ *
+ * \return Resulting value with set bits.
+ */
+#define Set_bits(lvalue, mask)  ((lvalue) |=  (mask))
+
+/** \brief Toggles the bits of a C lvalue specified by a given bit-mask.
+ *
+ * \param[in] lvalue  C lvalue of which to toggle bits.
+ * \param[in] mask    Bit-mask indicating bits to toggle.
+ *
+ * \return Resulting value with toggled bits.
+ */
+#define Tgl_bits(lvalue, mask)  ((lvalue) ^=  (mask))
+
+/** \brief Reads the bit-field of a value specified by a given bit-mask.
+ *
+ * \param[in] value Value to read a bit-field from.
+ * \param[in] mask  Bit-mask indicating the bit-field to read.
+ *
+ * \return Read bit-field.
+ */
+#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.
+ *
+ * \param[in] lvalue    C lvalue to write a bit-field to.
+ * \param[in] mask      Bit-mask indicating the bit-field to write.
+ * \param[in] bitfield  Bit-field to write.
+ *
+ * \return Resulting value with written bit-field.
+ */
+#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
+ * applied to constant expressions (values known at compile time), so they are
+ * more optimized than the use of the corresponding assembly instructions and
+ * they can be used as constant expressions e.g. to initialize objects having
+ * static storage duration, and like the corresponding assembly instructions
+ * when applied to non-constant expressions (values unknown at compile time), so
+ * they are more optimized than an assembly periphrasis. Hence, clz and ctz
+ * ensure a possible and optimized behavior for both constant and non-constant
+ * expressions.
+ *
+ * @{ */
+
+/** \brief Counts the leading zero bits of the given value considered as a 32-bit integer.
+ *
+ * \param[in] u Value of which to count the leading zero bits.
+ *
+ * \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
+
+/** \brief Counts the trailing zero bits of the given value considered as a 32-bit integer.
+ *
+ * \param[in] u Value of which to count the trailing zero bits.
+ *
+ * \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
+
+/** @} */
+
+
+/** \name Bit Reversing
+ * @{ */
+
+/** \brief Reverses the bits of \a u8.
+ *
+ * \param[in] u8  U8 of which to reverse the bits.
+ *
+ * \return Value resulting from \a u8 with reversed bits.
+ */
+#define bit_reverse8(u8)    ((U8)(bit_reverse32((U8)(u8)) >> 24))
+
+/** \brief Reverses the bits of \a u16.
+ *
+ * \param[in] u16 U16 of which to reverse the bits.
+ *
+ * \return Value resulting from \a u16 with reversed bits.
+ */
+#define bit_reverse16(u16)  ((uint16_t)(bit_reverse32((uint16_t)(u16)) >> 16))
+
+/** \brief Reverses the bits of \a u32.
+ *
+ * \param[in] u32 U32 of which to reverse the bits.
+ *
+ * \return Value resulting from \a u32 with reversed bits.
+ */
+#define bit_reverse32(u32)   __RBIT(u32)
+
+/** \brief Reverses the bits of \a u64.
+ *
+ * \param[in] u64 U64 of which to reverse the bits.
+ *
+ * \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)))
+
+/** @} */
+
+
+/** \name Alignment
+ * @{ */
+
+/** \brief Tests alignment of the number \a val with the \a n boundary.
+ *
+ * \param[in] val Input value.
+ * \param[in] n   Boundary.
+ *
+ * \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     )   )
+
+/** \brief Gets alignment of the number \a val with respect to the \a n boundary.
+ *
+ * \param[in] val Input value.
+ * \param[in] n   Boundary.
+ *
+ * \return Alignment of the number \a val with respect to the \a n boundary.
+ */
+#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.
+ *
+ * \param[in] lval  Input/output lvalue.
+ * \param[in] n     Boundary.
+ * \param[in] alg   Alignment.
+ *
+ * \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)   )
+
+/** \brief Aligns the number \a val with the upper \a n boundary.
+ *
+ * \param[in] val Input value.
+ * \param[in] n   Boundary.
+ *
+ * \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))
+
+/** \brief Aligns the number \a val with the lower \a n boundary.
+ *
+ * \param[in] val Input value.
+ * \param[in] n   Boundary.
+ *
+ * \return Value resulting from the number \a val aligned with the lower \a n boundary.
+ */
+#define Align_down(val, n) ( (val)              & ~((n) - 1))
+
+/** @} */
+
+
+/** \name Mathematics
+ *
+ * The same considerations as for clz and ctz apply here but GCC does not
+ * provide built-in functions to access the assembly instructions abs, min and
+ * max and it does not produce them by itself in most cases, so two sets of
+ * macros are defined here:
+ *   - Abs, Min and Max to apply to constant expressions (values known at
+ *     compile time);
+ *   - abs, min and max to apply to non-constant expressions (values unknown at
+ *     compile time), abs is found in stdlib.h.
+ *
+ * @{ */
+
+/** \brief Takes the absolute value of \a a.
+ *
+ * \param[in] a Input value.
+ *
+ * \return Absolute value of \a a.
+ *
+ * \note More optimized if only used with values known at compile time.
+ */
+#define Abs(a)              (((a) <  0 ) ? -(a) : (a))
+
+#ifndef __cplusplus
+/** \brief Takes the minimal value of \a a and \a b.
+ *
+ * \param[in] a Input value.
+ * \param[in] b Input value.
+ *
+ * \return Minimal value of \a a and \a b.
+ *
+ * \note More optimized if only used with values known at compile time.
+ */
+#define Min(a, b)           (((a) < (b)) ?  (a) : (b))
+
+/** \brief Takes the maximal value of \a a and \a b.
+ *
+ * \param[in] a Input value.
+ * \param[in] b Input value.
+ *
+ * \return Maximal value of \a a and \a b.
+ *
+ * \note More optimized if only used with values known at compile time.
+ */
+#define Max(a, b)           (((a) > (b)) ?  (a) : (b))
+
+/** \brief Takes the minimal value of \a a and \a b.
+ *
+ * \param[in] a Input value.
+ * \param[in] b Input value.
+ *
+ * \return Minimal value of \a a and \a b.
+ *
+ * \note More optimized if only used with values unknown at compile time.
+ */
+#define min(a, b)   Min(a, b)
+
+/** \brief Takes the maximal value of \a a and \a b.
+ *
+ * \param[in] a Input value.
+ * \param[in] b Input value.
+ *
+ * \return Maximal value of \a a and \a b.
+ *
+ * \note More optimized if only used with values unknown at compile time.
+ */
+#define max(a, b)   Max(a, b)
+#endif
+
+/** @} */
+
+
+/** \brief Calls the routine at address \a addr.
+ *
+ * It generates a long call opcode.
+ *
+ * For example, `Long_call(0x80000000)' generates a software reset on a UC3 if
+ * it is invoked from the CPU supervisor mode.
+ *
+ * \param[in] addr  Address of the routine to call.
+ *
+ * \note It may be used as a long jump opcode in some special cases.
+ */
+#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)
+/** @} */
+
+
+/** \name Endianism Conversion
+ *
+ * The same considerations as for clz and ctz apply here but GCC's
+ * __builtin_bswap_32 and __builtin_bswap_64 do not behave like macros when
+ * applied to constant expressions, so two sets of macros are defined here:
+ *   - Swap16, Swap32 and Swap64 to apply to constant expressions (values known
+ *     at compile time);
+ *   - swap16, swap32 and swap64 to apply to non-constant expressions (values
+ *     unknown at compile time).
+ *
+ * @{ */
+
+/** \brief Toggles the endianism of \a u16 (by swapping its bytes).
+ *
+ * \param[in] u16 U16 of which to toggle the endianism.
+ *
+ * \return Value resulting from \a u16 with toggled endianism.
+ *
+ * \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)))
+
+/** \brief Toggles the endianism of \a u32 (by swapping its bytes).
+ *
+ * \param[in] u32 U32 of which to toggle the endianism.
+ *
+ * \return Value resulting from \a u32 with toggled endianism.
+ *
+ * \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)))
+
+/** \brief Toggles the endianism of \a u64 (by swapping its bytes).
+ *
+ * \param[in] u64 U64 of which to toggle the endianism.
+ *
+ * \return Value resulting from \a u64 with toggled endianism.
+ *
+ * \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)))
+
+/** \brief Toggles the endianism of \a u16 (by swapping its bytes).
+ *
+ * \param[in] u16 U16 of which to toggle the endianism.
+ *
+ * \return Value resulting from \a u16 with toggled endianism.
+ *
+ * \note More optimized if only used with values unknown at compile time.
+ */
+#define swap16(u16) Swap16(u16)
+
+/** \brief Toggles the endianism of \a u32 (by swapping its bytes).
+ *
+ * \param[in] u32 U32 of which to toggle the endianism.
+ *
+ * \return Value resulting from \a u32 with toggled endianism.
+ *
+ * \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
+
+/** \brief Toggles the endianism of \a u64 (by swapping its bytes).
+ *
+ * \param[in] u64 U64 of which to toggle the endianism.
+ *
+ * \return Value resulting from \a u64 with toggled endianism.
+ *
+ * \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
+
+/** @} */
+
+
+/** \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 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. */
+
+/** @} */
+
+/**
+ * \brief Calculate \f$ \left\lceil \frac{a}{b} \right\rceil \f$ using
+ * integer arithmetic.
+ *
+ * \param[in] a An integer
+ * \param[in] b Another integer
+ *
+ * \return (\a a / \a b) rounded up to the nearest integer.
+ */
+#define div_ceil(a, b)      (((a) + (b) - 1) / (b))
+
+#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__
+
+/** @} */
+
+#endif
+
+#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 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
+
+/* 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
+
+/* 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))
+
+/*Defines the Flash Storage for the request and response of MAC*/
+#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)
+
+/* 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)
+
+/* 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)
+
+/* 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 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
+ *
+ * @param[in] value 64-Bit value
+ * @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)
+{
+    uint8_t index = 0;
+
+    while (index < 8)
+    {
+        data[index++] = value & 0xFF;
+        value = value >> 8;
+    }
+}
+
+/**
+ * @brief Converts a 16-Bit value into  a 2 Byte array
+ *
+ * @param[in] value 16-Bit value
+ * @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)
+{
+    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)
+{
+    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)
+{
+    data[0] = value & 0xFF;
+    data[1] = (value >> 8) & 0xFF;
+}
+
+/*
+ * @brief Converts a 2 Byte array into a 16-Bit value
+ *
+ * @param data Specifies the pointer to the 2 Byte array
+ *
+ * @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));
+}
+
+/* Converts a 4 Byte array into a 32-Bit value */
+static inline uint32_t convert_byte_array_to_32_bit(uint8_t *data)
+{
+    union
+    {
+        uint32_t u32;
+        uint8_t u8[4];
+    } long_addr;
+
+    uint8_t index;
+
+    for (index = 0; index < 4; index++)
+    {
+        long_addr.u8[index] = *data++;
+    }
+
+    return long_addr.u32;
+}
+
+/**
+ * @brief Converts a 8 Byte array into a 64-Bit value
+ *
+ * @param data Specifies the pointer to the 8 Byte array
+ *
+ * @return 64-Bit value
+ * @ingroup apiPalApi
+ */
+static inline uint64_t convert_byte_array_to_64_bit(uint8_t *data)
+{
+    union
+    {
+        uint64_t u64;
+        uint8_t u8[8];
+    } long_addr;
+
+    uint8_t index;
+
+    for (index = 0; index < 8; index++)
+    {
+        long_addr.u8[index] = *data++;
+    }
+
+    return long_addr.u64;
+}
+
+/** @} */
+
+#endif /* UTILS_COMPILER_H_INCLUDED */
diff --git a/tmk_core/protocol/arm_atsam/usb/conf_usb.h b/tmk_core/protocol/arm_atsam/usb/conf_usb.h
new file mode 100644
index 000000000..8f0f47268
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/usb/conf_usb.h
@@ -0,0 +1,163 @@
+/**
+ * \file
+ *
+ * \brief USB configuration file
+ *
+ * Copyright (c) 2009-2015 Atmel Corporation. All rights reserved.
+ *
+ * \asf_license_start
+ *
+ * \page License
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. The name of Atmel may not be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * 4. This software may only be redistributed and used in connection with an
+ *    Atmel microcontroller product.
+ *
+ * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
+ * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * \asf_license_stop
+ *
+ */
+/*
+ * Support and FAQ: visit <a href="http://www.atmel.com/design-support/">Atmel Support</a>
+ */
+
+#ifndef _CONF_USB_H_
+#define _CONF_USB_H_
+
+#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
+
+//! 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)
+//                                      (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
+
+//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
+ * @{
+ */
+//! To define a Low speed device
+//#define  USB_DEVICE_LOW_SPEED
+
+//! To authorize the High speed
+#if (UC3A3||UC3A4)
+//#define  USB_DEVICE_HS_SUPPORT
+#elif (SAM3XA||SAM3U)
+//#define  USB_DEVICE_HS_SUPPORT
+#endif
+//@}
+
+/**
+ * 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()
+//! Mandatory when USB_DEVICE_ATTR authorizes remote wakeup feature
+#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()
+//@}
+
+//@}
+
+
+/**
+ * USB Interface Configuration
+ * @{
+ */
+/**
+ * Configuration of HID Keyboard interface
+ * @{
+ */
+//! 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_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_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()
+#endif
+
+#ifdef MOU
+#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()
+#endif
+
+
+//@}
+//@}
+
+
+/**
+ * USB Device Driver Configuration
+ * @{
+ */
+//@}
+
+//! The includes of classes and other headers must be done at the end of this file to avoid compile error
+#include "udi_hid_kbd_conf.h"
+#include "usb_main.h"
+#include "ui.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
new file mode 100644
index 000000000..e943cbcdc
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/usb/main_usb.c
@@ -0,0 +1,118 @@
+/*
+Copyright 2018 Massdrop Inc.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "samd51j18a.h"
+#include "conf_usb.h"
+#include "udd.h"
+
+uint8_t keyboard_protocol = 1;
+
+void main_suspend_action(void)
+{
+    ui_powerdown();
+}
+
+void main_resume_action(void)
+{
+    ui_wakeup();
+}
+
+void main_sof_action(void)
+{
+    ui_process(udd_get_frame_number());
+}
+
+void main_remotewakeup_enable(void)
+{
+    ui_wakeup_enable();
+}
+
+void main_remotewakeup_disable(void)
+{
+    ui_wakeup_disable();
+}
+
+#ifdef KBD
+volatile bool main_b_kbd_enable = false;
+bool main_kbd_enable(void)
+{
+    main_b_kbd_enable = true;
+    return true;
+}
+
+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)
+{
+    main_b_nkro_enable = true;
+    return true;
+}
+
+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)
+{
+    main_b_exk_enable = true;
+    return true;
+}
+
+void main_exk_disable(void)
+{
+    main_b_exk_enable = false;
+}
+#endif
+
+#ifdef MOU
+volatile bool main_b_mou_enable = false;
+bool main_mou_enable(void)
+{
+    main_b_mou_enable = true;
+    return true;
+}
+
+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)
+{
+    main_b_raw_enable = true;
+    return true;
+}
+
+void main_raw_disable(void)
+{
+    main_b_raw_enable = false;
+}
+#endif
+
diff --git a/tmk_core/protocol/arm_atsam/usb/spfssf.c b/tmk_core/protocol/arm_atsam/usb/spfssf.c
new file mode 100644
index 000000000..449a8bb7d
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/usb/spfssf.c
@@ -0,0 +1,268 @@
+#include "samd51j18a.h"
+#include "stdarg.h"
+#include "spfssf.h"
+#include "usb_util.h"
+
+int vspf(char *_Dest, const char *_Format, va_list va)
+{
+    //va_list va;                                                   //Variable argument list variable
+    char *d = _Dest;                                               //Pointer to dest
+
+    //va_start(va,_Format);                                         //Initialize the variable argument list
+    while (*_Format)                                                //While not end of format string
+    {
+        if (*_Format == SPF_SPEC_START)                             //If current format string character is the specifier start character
+        {
+            _Format++;                                              //Skip over the character
+            while (*_Format && *_Format <= 64) _Format++;           //Forward past any options
+            if (*_Format == SPF_SPEC_START) *d++ = *_Format;        //If the character is the specifier start character, output the character and advance dest
+            else if (*_Format == SPF_SPEC_LONG)                     //If the character is the long type
+            {
+                _Format++;                                          //Skip over the character
+                if (*_Format == SPF_SPEC_DECIMAL)                   //If the character is the decimal type
+                {
+                    int64_t buf = va_arg(va,int64_t);               //Get the next value from the va list
+                    //if (buf < 0) { *d++ = '-'; buf = -buf; }      //If the given number is negative, add a negative sign to the dest and invert number
+                    //spf_uint2str_32_3t(&d,buf,32);                //Perform the conversion
+                    d += UTIL_ltoa_radix(buf, d, 10);
+                }
+                else if (*_Format == SPF_SPEC_UNSIGNED)             //If the character is the unsigned type
+                {
+                    uint64_t num = va_arg(va,uint64_t);             //Get the next value from the va list
+                    //spf_uint2str_32_3t(&d,num,32);                //Perform the conversion
+                    d += UTIL_ltoa_radix(num, d, 10);
+                }
+                else if (*_Format == SPF_SPEC_UHINT || *_Format == SPF_SPEC_UHINT_UP)   //If the character is the unsigned type
+                {
+                    uint64_t buf = va_arg(va,uint64_t);             //Get the next value from the va list
+                    //spf_uint2hex_32(&d,(unsigned long) buf);
+                    d += UTIL_ltoa_radix(buf, d, 16);
+                }
+                else                                                //If the character was not a known type
+                {
+                    *d++ = SPF_SPEC_START;                          //Output the start specifier
+                    *d++ = SPF_SPEC_LONG;                           //Output the long type
+                    *d++ = *_Format;                                //Output the unknown type
+                }
+            }
+            else if (*_Format == SPF_SPEC_DECIMAL)                  //If the character is the decimal type
+            {
+                int buf = va_arg(va,int);                           //Get the next value from the va list
+                //if (buf < 0) { *d++ = '-'; buf = -buf; }          //If the given number is negative, add a negative sign to the dest and invert number
+                //spf_uint2str_32_3t(&d,buf,16);                    //Perform the conversion
+                d += UTIL_itoa(buf, d);
+            }
+            else if (*_Format == SPF_SPEC_INT)                      //If the character is the integer type
+            {
+                int buf = va_arg(va,int);                           //Get the next value from the va list
+                //if (buf < 0) { *d++ = '-'; buf = -buf; }          //If the given number is negative, add a negative sign to the dest and inverted number
+                //spf_uint2str_32_3t(&d,buf,16);                    //Perform the conversion
+                d += UTIL_itoa(buf, d);
+            }
+            else if (*_Format == SPF_SPEC_UINT)                     //If the character is the unsigned integer type
+            {
+                int buf = va_arg(va,int);                           //Get the next value from the va list
+                //spf_uint2str_32_3t(&d,buf,16);                    //Perform the conversion
+                d += UTIL_utoa(buf, d);
+            }
+            else if (*_Format == SPF_SPEC_STRING)                   //If the character is the string type
+            {
+                char *buf = va_arg(va,char*);                       //Get the next value from the va list
+                while (*buf) *d++ = *buf++;                         //Perform the conversion (simply output characters and adcance pointers)
+            }
+            else if (*_Format == SPF_SPEC_UHINT || *_Format == SPF_SPEC_UHINT_UP)   //If the character is the short type
+            {
+                int buf = va_arg(va,unsigned int);                  //Get the next value from the va list
+                //spf_uint2hex_32(&d,(unsigned long) buf);          //Perform the conversion
+                d += UTIL_utoa(buf, d);
+            }
+            else                                                    //If the character type is unknown
+            {
+                *d++ = SPF_SPEC_START;                              //Output the start specifier
+                *d++ = *_Format;                                    //Output the unknown type
+            }
+        }
+        else *d++ = *_Format;                                       //If the character is unknown, output it to dest and advance dest
+        _Format++;                                                  //Advance the format buffer pointer to next character
+    }
+    //va_end(va);                                                   //End the variable argument list
+
+    *d = '\0';                                                      //Cap off the destination string with a zero
+
+    return d - _Dest;                                               //Return the length of the destintion buffer
+}
+
+int spf(char *_Dest, const char *_Format, ...)
+{
+    va_list va;                                                     //Variable argument list variable
+    int result;
+
+    va_start(va,_Format);                                           //Initialize the variable argument list
+    result = vspf(_Dest, _Format, va);
+    va_end(va);
+    return result;
+}
+
+//sscanf string to number (integer types)
+int64_t ssf_ston(const char **_Src, uint32_t count, uint32_t *conv_count)
+{
+    int64_t value = 0;                                  //Return value accumulator
+    uint32_t counter=count;                             //Counter to keep track of numbers converted
+    const char* p;                                      //Pointer to first non space character
+
+    while (*(*_Src) == SSF_SKIP_SPACE) (*_Src)++;       //Forward through the whitespace to next non whitespace
+
+    p = (*_Src);                                        //Set pointer to first non space character
+    if (*p == '+' || *p == '-') (*_Src)++;              //Skip over sign if any
+    while (*(*_Src) >= ASCII_NUM_START &&
+        *(*_Src) <= ASCII_NUM_END &&
+        counter)                                        //While the source character is a digit and counter is not zero
+    {
+        value *= 10;                                    //Multiply result by 10 to make room for next 1's place number
+        value += *(*_Src)++ - ASCII_NUM_START;          //Add source number to value
+        counter--;                                      //Decrement counter
+    }
+    if (counter - count == 0) return 0;                 //If no number conversion were performed, return 0
+    if (*p == '-') value = -value;                      //If the number given was negative, make the result negative
+
+    if (conv_count) (*conv_count)++;                    //Increment the converted count
+    return value;                                       //Return the value
+}
+
+uint64_t ssf_hton(const char **_Src, uint32_t count,uint32_t *conv_count)
+{
+    int64_t value=0;                                            //Return value accumulator
+    uint32_t counter=count;                                     //Counter to keep track of numbers converted
+    //const char* p;                                            //Pointer to first non space character
+    char c;
+
+    while (*(*_Src) == SSF_SKIP_SPACE) (*_Src)++;               //Forward through the whitespace to next non whitespace
+
+    //p = (*_Src);                                              //Set pointer to first non space character
+
+    while (counter)
+    {
+        c = *(*_Src)++;
+        if (c >= 'a' && c <= 'f') c -= ('a'-'A');               //toupper
+        if (c < '0' || (c > '9' && c < 'A') || c > 'F') break;
+        value *= 16;                                            //Multiply result by 10 to make room for next 1's place number
+        c = c - '0';
+        if (c > 9) c -= 7;
+        value += c;                                             //Add source number to value
+        counter--;                                              //Decrement counter
+    }
+
+    if (counter - count == 0) return 0;                         //If no number conversion were performed, return 0
+    //if (*p == '-') value = -value;                            //If the number given was negative, make the result negative
+
+    if (conv_count) (*conv_count)++;                            //Increment the converted count
+    return value;
+}
+
+//sscanf
+int ssf(const char *_Src, const char *_Format, ...)
+{
+    va_list va;                                                                         //Variable argument list variable
+    unsigned char looking_for=0;                                                        //Static char specified in format to be found in source
+    uint32_t conv_count=0;                                                              //Count of conversions made
+
+    va_start(va,_Format);                                                               //Initialize the variable argument list
+    while (*_Format)                                                                    //While the format string has not been fully read
+    {
+        if (looking_for != 0)                                                           //If we are looking for a matching character in the source string
+        {
+            while (*_Src != looking_for && *_Src) _Src++;                               //While the character is not found in the source string and not the end of the source
+                                                                                        //  string, increment the pointer position
+            if (*_Src == looking_for) _Src++;                                           //If the character was found, step over it
+            else break;                                                                 //Else the end was reached and the scan is now invalid (Could not find static character)
+            looking_for = 0;                                                            //Clear the looking for character
+        }
+        if (*_Format == SSF_SPEC_START)                                                 //If the current format character is the specifier start character
+        {
+            _Format++;                                                                  //Step over the specifier start character
+            if (*_Format == SSF_SPEC_DECIMAL)                                           //If the decimal specifier type is found
+            {
+                int *value=va_arg(va,int*);                                             //User given destination address
+                //*value = (int)ssf_ston(&_Src,5,&conv_count);                          //Run conversion
+                *value = (int)ssf_ston(&_Src,10,&conv_count);                           //Run conversion
+            }
+            else if (*_Format == SSF_SPEC_LONG)                                         //If the long specifier type is found
+            {
+                _Format++;                                                              //Skip over the specifier type
+                if (*_Format == SSF_SPEC_DECIMAL)                                       //If the decimal specifier type is found
+                {
+                    int64_t *value=va_arg(va,int64_t*);                                 //User given destination address
+                    //*value = (int64_t)ssf_ston(&_Src,10,&conv_count);                 //Run conversion
+                    *value = (int64_t)ssf_ston(&_Src,19,&conv_count);                   //Run conversion
+                }
+                else if (*_Format == SSF_SPEC_UHINT)                                    //If the decimal specifier type is found
+                {
+                    uint64_t *value=va_arg(va,uint64_t *);                              //User given destination address
+                    //*value = (uint64_t int)ssf_hton(&_Src,12,&conv_count);            //Run conversion
+                    *value = (uint64_t)ssf_hton(&_Src,16,&conv_count);                  //Run conversion
+                }
+            }
+            else if (*_Format == SSF_SPEC_SHORTINT)                                     //If the short int specifier type is found
+            {
+                _Format++;                                                              //Skip over the specifier type
+                if (*_Format == SSF_SPEC_SHORTINT)                                      //If the short int specifier type is found
+                {
+                    _Format++;                                                          //Skip over the specifier type
+                    if (*_Format == SSF_SPEC_DECIMAL)                                   //If the decimal specifier type is found
+                    {
+                        unsigned char *value=va_arg(va,unsigned char*);                 //User given destination address
+                        //*value = (unsigned char)ssf_ston(&_Src,3,&conv_count);        //Run conversion
+                        *value = (unsigned char)ssf_ston(&_Src,5,&conv_count);          //Run conversion
+                    }
+                }
+            }
+            else if (*_Format == SSF_SPEC_STRING)                                       //If the specifier type is string
+            {
+                char *value=va_arg(va,char*);                                           //User given destination address, max chars read pointer
+                while (*_Src == SSF_SKIP_SPACE) _Src++;                                 //Forward through the whitespace to next non whitespace
+                while (*_Src != SSF_SKIP_SPACE && *_Src) *value++ = *_Src++;            //While any character but space and not end of string and not end location, copy char to dest
+                *value = 0;                                                             //Cap off the string pointer with zero
+                conv_count++;                                                           //Increment the converted count
+            }
+            else if (*_Format == SSF_SPEC_VERSION)                                      //If the specifier type is string
+            {
+                char *value=va_arg(va,char*);                                           //User given destination address, max chars read pointer
+                while (*_Src == SSF_SKIP_SPACE) _Src++;                                 //Forward through the whitespace to next non whitespace
+                while (*_Src != SSF_DELIM_COMMA && *_Src) *value++ = *_Src++;           //While any character but space and not end of string and not end location, copy char to dest
+                *value = 0;                                                             //Cap off the string pointer with zero
+                conv_count++;                                                           //Increment the converted count
+            }
+            else if (*_Format >= ASCII_NUM_START && *_Format <= ASCII_NUM_END)
+            {
+                uint32_t len = (uint32_t)ssf_ston(&_Format,3,NULL);                     //Convert the given length
+                if (*_Format == SSF_SPEC_STRING)                                        //If the specifier type is string
+                {
+                    char *value=va_arg(va,char*),*e;                                    //User given destination address, max chars read pointer
+                    while (*_Src == SSF_SKIP_SPACE) _Src++;                             //Forward through the whitespace to next non whitespace
+                    e = (char*)_Src+len;                                                //Set a maximum length pointer location
+                    while (*_Src != SSF_SKIP_SPACE && *_Src && _Src != e) *value++ = *_Src++;   //While any character but space and not end of string and not end location, copy char to dest
+                    *value = 0;                                                         //Cap off the string pointer with zero
+                    conv_count++;                                                       //Increment the converted count
+                }
+                else if (*_Format == SSF_SPEC_VERSION)                                  //If the specifier type is string
+                {
+                    char *value=va_arg(va,char*),*e;                                    //User given destination address, max chars read pointer
+                    while (*_Src == SSF_SKIP_SPACE) _Src++;                             //Forward through the whitespace to next non whitespace
+                    e = (char*)_Src+len;                                                //Set a maximum length pointer location
+                    while (*_Src != SSF_DELIM_COMMA && *_Src && _Src != e) *value++ = *_Src++;  //While any character but space and not end of string and not end location, copy char to dest
+                    *value = 0;                                                         //Cap off the string pointer with zero
+                    conv_count++;                                                       //Increment the converted count
+                }
+            }
+            else if (*_Format == SSF_SPEC_START) looking_for = *_Format;                //If another start specifier character is found, output a specifier character
+            else break;                                                                 //Scan is now invalid (Uknown type specified)
+        }
+        else if (*_Format == SSF_SKIP_SPACE) { }                                        //If a space is found, ignore it
+        else looking_for = *_Format;                                                    //If any other character is found, it is static and should be found in src as well
+        _Format++;                                                                      //Skip over current format character
+    }
+
+    va_end(va);                                                                         //End the variable argument list
+    return conv_count;                                                                  //Return the number of conversions made
+}
+
diff --git a/tmk_core/protocol/arm_atsam/usb/spfssf.h b/tmk_core/protocol/arm_atsam/usb/spfssf.h
new file mode 100644
index 000000000..337a904df
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/usb/spfssf.h
@@ -0,0 +1,57 @@
+#ifndef ____spfssf_h
+#define ____spfssf_h
+
+#include <stdarg.h>
+
+#define sprintf spf
+#define sscanf  ssf
+
+#define SIZEOF_OFFSET 1
+
+#ifndef NULL
+#define NULL 0
+#endif
+
+#define SPF_NONE    0
+
+#define SPF_SPEC_START      37      //%
+#define SPF_SPEC_DECIMAL    100     //d  16bit dec signed           (-32767 to 32767)               DONE same as i
+#define SPF_SPEC_INT        105     //i  16bit dec signed           (-32767 to 32767)               DONE same as d
+#define SPF_SPEC_UINT       117     //u  16bit dec unsigned         (0 to 65535)                    DONE
+#define SPF_SPEC_STRING     115     //s  variable length            (abcd...)                       DONE
+#define SPF_SPEC_UHINT      120     //x  16bit hex lwrc             (7fa)                           DONE
+#define SPF_SPEC_UHINT_UP   88      //x  16bit hex lwrc             (7fa)                           DONE
+#define SPF_SPEC_LONG       108     //l  start of either ld or lu                                   DONE
+#define SPF_SPEC_DECIMAL    100     //ld 32bit dec signed           (-2147483647 to 2147483647)     DONE
+#define SPF_SPEC_UNSIGNED   117     //lu 32bit dec unsigned         (0 to 4294967295)               DONE
+#define SPF_SPEC_UHINT      120     //lx 32bit hex unsigned         (0 to ffffffff)                 DONE
+
+#define SSF_SPEC_START      37      //%
+#define SSF_SPEC_SHORTINT   104     //h  8bit dec signed            (-127 to 127)                   DONE
+#define SSF_LEN_SHORTINT    3       //hhd
+#define SSF_SPEC_DECIMAL    100     //d  16bit dec signed           (-32767 to 32767)               DONE
+#define SSF_LEN_DECIMAL     5       //32767
+#define SSF_SPEC_INT        105     //i  16bit dec signed           (-32767 to 32767)               DONE
+#define SSF_LEN_INT         5       //32767
+#define SSF_SPEC_LONG       108     //l  start of either ld or lu                                   DONE
+#define SSF_SPEC_DECIMAL    100     //ld 32bit dec signed           (-2147483647 to 2147483647)     DONE
+#define SSF_SPEC_UHINT      120     //lx 32bit hex unsigned                                         DONE
+#define SSF_LEN_LDECIMAL    10      //2147483647
+#define SSF_SPEC_STRING     115     //s  variable length            (abcd...)                       DONE
+#define SSF_SKIP_SPACE      32      //space
+
+#define SSF_SPEC_VERSION    118     //v collect to comma delimiter - special
+#define SSF_DELIM_COMMA     44      //,
+
+#define ASCII_NUM_START     48      //0
+#define ASCII_NUM_END       58      //9
+
+#define T_UINT32_0_LIMIT    14
+#define T_UINT32_1_LIMIT    27
+
+int vspf(char *_Dest, const char *_Format, va_list va);
+int spf(char *_Dest, const char *_Format, ...);
+int ssf(const char *_Src, const char *_Format, ...);
+
+#endif //____spfssf_h
+
diff --git a/tmk_core/protocol/arm_atsam/usb/status_codes.h b/tmk_core/protocol/arm_atsam/usb/status_codes.h
new file mode 100644
index 000000000..f56d2faed
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/usb/status_codes.h
@@ -0,0 +1,158 @@
+/**
+ * \file
+ *
+ * \brief Status code definitions.
+ *
+ * This file defines various status codes returned by functions,
+ * indicating success or failure as well as what kind of failure.
+ *
+ * Copyright (C) 2012-2015 Atmel Corporation. All rights reserved.
+ *
+ * \asf_license_start
+ *
+ * \page License
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. The name of Atmel may not be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * 4. This software may only be redistributed and used in connection with an
+ *    Atmel microcontroller product.
+ *
+ * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
+ * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * \asf_license_stop
+ *
+ */
+/*
+ * Support and FAQ: visit <a href="http://www.atmel.com/design-support/">Atmel Support</a>
+ */
+
+#ifndef STATUS_CODES_H_INCLUDED
+#define STATUS_CODES_H_INCLUDED
+
+#include <stdint.h>
+
+/**
+ * \defgroup group_sam0_utils_status_codes Status Codes
+ *
+ * \ingroup group_sam0_utils
+ *
+ * @{
+ */
+
+/** Mask to retrieve the error category of a status code. */
+#define STATUS_CATEGORY_MASK  0xF0
+
+/** Mask to retrieve the error code within the category of a status code. */
+#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 code that may be returned by shell commands and protocol
+ * implementations.
+ *
+ * \note Any change to these status codes and the corresponding
+ * message strings is strictly forbidden. New codes can be added,
+ * however, but make sure that any message string tables are updated
+ * 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_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_PIN_MUX_INVALID        = STATUS_CATEGORY_IO     | 0x00,
+};
+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
+
+    /**
+     * \brief Operation in progress
+     *
+     * This status code is for driver-internal use when an operation
+     * is currently being performed.
+     *
+     * \note Drivers should never return this status code to any
+     * callers. It is strictly for internal use.
+     */
+    OPERATION_IN_PROGRESS   = -128,
+};
+
+typedef enum status_code_wireless status_code_t;
+
+/** @} */
+
+#endif /* STATUS_CODES_H_INCLUDED */
diff --git a/tmk_core/protocol/arm_atsam/usb/udc.c b/tmk_core/protocol/arm_atsam/usb/udc.c
new file mode 100644
index 000000000..12444d305
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/usb/udc.c
@@ -0,0 +1,1164 @@
+/**
+ * \file
+ *
+ * \brief USB Device Controller (UDC)
+ *
+ * Copyright (c) 2009-2015 Atmel Corporation. All rights reserved.
+ *
+ * \asf_license_start
+ *
+ * \page License
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. The name of Atmel may not be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * 4. This software may only be redistributed and used in connection with an
+ *    Atmel microcontroller product.
+ *
+ * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
+ * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * \asf_license_stop
+ *
+ */
+/*
+ * Support and FAQ: visit <a href="http://www.atmel.com/design-support/">Atmel Support</a>
+ */
+
+#include "conf_usb.h"
+#include "usb_protocol.h"
+#include "udd.h"
+#include "udc_desc.h"
+#include "udi_device_conf.h"
+#include "udi.h"
+#include "udc.h"
+#include "md_bootloader.h"
+
+/**
+ * \ingroup udc_group
+ * \defgroup udc_group_interne Implementation of UDC
+ *
+ * Internal implementation
+ * @{
+ */
+
+//! \name Internal variables to manage the USB device
+//! @{
+
+//! Device status state (see enum usb_device_status in usb_protocol.h)
+static le16_t udc_device_status;
+
+COMPILER_WORD_ALIGNED
+//! Device interface setting value
+static uint8_t udc_iface_setting = 0;
+
+//! Device Configuration number selected by the USB host
+COMPILER_WORD_ALIGNED
+static uint8_t udc_num_configuration = 0;
+
+//! Pointer on the selected speed device configuration
+static udc_config_speed_t UDC_DESC_STORAGE *udc_ptr_conf;
+
+//! Pointer on interface descriptor used by SETUP request.
+static usb_iface_desc_t UDC_DESC_STORAGE *udc_ptr_iface;
+
+//! @}
+
+
+//! \name Internal structure to store the USB device main strings
+//! @{
+
+/**
+ * \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)}
+};
+
+/**
+ * \brief USB device manufacture name storage
+ * String is allocated only if USB_DEVICE_MANUFACTURE_NAME is declared
+ * by usb application configuration
+ */
+#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)
+#else
+#define USB_DEVICE_MANUFACTURE_NAME_SIZE 0
+#endif
+
+/**
+ * \brief USB device product name storage
+ * String is allocated only if USB_DEVICE_PRODUCT_NAME is declared
+ * by usb application configuration
+ */
+#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)
+#else
+#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)
+#else
+#define USB_DEVICE_SERIAL_NAME_SIZE 0
+#endif
+
+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]="";
+#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
+
+    if (serial_address != 0xFFFFFFFF && serial_address < serial_ptrloc) //Check for factory programmed serial address
+    {
+        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;
+
+            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++;
+            }
+            bootloader_serial_number[serial_length] = 0;
+
+            usb_device_serial_name_size = serial_length;
+
+            return bootloader_serial_number; //Use serial programmed into bootloader rom
+        }
+    }
+#endif
+
+    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
+#else
+    return 0; //No serial supplied
+#endif
+}
+
+/**
+ * \brief USB device string descriptor
+ * 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
+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)];
+};
+COMPILER_WORD_ALIGNED
+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;
+}
+
+/**
+ * \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));
+}
+
+#if (0!=USB_DEVICE_MAX_EP)
+/**
+ * \brief Search specific descriptor in global interface descriptor
+ *
+ * \param desc       Address of interface descriptor
+ *                   or previous specific descriptor found
+ * \param desc_id    Descriptor ID to search
+ *
+ * \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)
+{
+    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);
+    // 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
+        }
+        if (desc_id == desc->bDescriptorType) {
+            return desc; // Specific descriptor found
+        }
+        // Go to next descriptor
+        desc = (UDC_DESC_STORAGE usb_conf_desc_t *) ((uint8_t *) desc +
+                desc->bLength);
+    }
+    return NULL; // No specific descriptor found
+}
+#endif
+
+/**
+ * \brief Search an interface descriptor
+ * This routine updates the internal pointer udc_ptr_iface.
+ *
+ * \param iface_num     Interface number to find in Configuration Descriptor
+ * \param setting_num   Setting number of interface to find
+ *
+ * \return 1 if found or 0 if not found
+ */
+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) {
+        return false;
+    }
+
+    if (iface_num >= udc_ptr_conf->desc->bNumInterfaces) {
+        return false;
+    }
+
+    // Start at the beginning of configuration descriptor
+    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) {
+        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
+            }
+        }
+        // Go to next descriptor
+        udc_ptr_iface = (UDC_DESC_STORAGE usb_iface_desc_t *) (
+                (uint8_t *) udc_ptr_iface +
+                udc_ptr_iface->bLength);
+    }
+    return false; // Interface not found
+}
+
+/**
+ * \brief Disables an usb device interface (UDI)
+ * This routine call the UDI corresponding to interface number
+ *
+ * \param iface_num     Interface number to disable
+ *
+ * \return 1 if it is done or 0 if interface is not found
+ */
+static bool udc_iface_disable(uint8_t iface_num)
+{
+    udi_api_t UDC_DESC_STORAGE *udi_api;
+
+    // Select first alternate setting of the interface
+    // to update udc_ptr_iface before call iface->getsetting()
+    if (!udc_update_iface_desc(iface_num, 0)) {
+        return false;
+    }
+
+    // Select the interface with the current alternate setting
+    udi_api = udc_ptr_conf->udi_apis[iface_num];
+
+#if (0!=USB_DEVICE_MAX_EP)
+    if (!udc_update_iface_desc(iface_num, udi_api->getsetting())) {
+        return false;
+    }
+
+    // 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;
+        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);
+            if (NULL == ep_desc) {
+                break;
+            }
+            // Free the endpoint used by the interface
+            udd_ep_free(ep_desc->bEndpointAddress);
+        }
+    }
+#endif
+
+    // Disable interface
+    udi_api->disable();
+    return true;
+}
+
+/**
+ * \brief Enables an usb device interface (UDI)
+ * This routine calls the UDI corresponding
+ * to the interface and setting number.
+ *
+ * \param iface_num     Interface number to enable
+ * \param setting_num   Setting number to enable
+ *
+ * \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)
+{
+    // Select the interface descriptor
+    if (!udc_update_iface_desc(iface_num, setting_num)) {
+        return false;
+    }
+
+#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;
+    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;
+        // Alloc the endpoint used by the interface
+        if (!udd_ep_alloc(ep_desc->bEndpointAddress,
+                ep_desc->bmAttributes,
+                le16_to_cpu
+                (ep_desc->wMaxPacketSize))) {
+            return false;
+        }
+    }
+#endif
+    // Enable the interface
+    return udc_ptr_conf->udi_apis[iface_num]->enable();
+}
+
+/*! \brief Start the USB Device stack
+ */
+void udc_start(void)
+{
+    udd_enable();
+}
+
+/*! \brief Stop the USB Device stack
+ */
+void udc_stop(void)
+{
+    udd_disable();
+    udc_reset();
+}
+
+/**
+ * \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)
+{
+    uint8_t iface_num;
+
+    if (udc_num_configuration) {
+        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 (CPU_TO_LE16(USB_DEV_STATUS_REMOTEWAKEUP) & udc_device_status) {
+        // Remote wakeup is enabled then disable it
+        UDC_REMOTEWAKEUP_DISABLE();
+    }
+#endif
+    udc_device_status =
+#if (USB_DEVICE_ATTR & USB_CONFIG_ATTR_SELF_POWERED)
+            CPU_TO_LE16(USB_DEV_STATUS_SELF_POWERED);
+#else
+            CPU_TO_LE16(USB_DEV_STATUS_BUS_POWERED);
+#endif
+}
+
+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++) {
+            if (udc_ptr_conf->udi_apis[iface_num]->sof_notify != NULL) {
+                udc_ptr_conf->udi_apis[iface_num]->sof_notify();
+            }
+        }
+    }
+}
+
+/**
+ * \brief Standard device request to get device status
+ *
+ * \return true if success
+ */
+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));
+    return true;
+}
+
+#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 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;
+
+    udd_set_setup_payload( (uint8_t *) & udc_ep_status,
+            sizeof(udc_ep_status));
+    return true;
+}
+#endif
+
+/**
+ * \brief Standard device request to change device status
+ *
+ * \return true if success
+ */
+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))
+        UDC_REMOTEWAKEUP_DISABLE();
+#endif
+        return true;
+    }
+    return false;
+}
+
+#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)
+{
+    if (udd_g_ctrlreq.req.wLength) {
+        return false;
+    }
+
+    if (udd_g_ctrlreq.req.wValue == USB_EP_FEATURE_HALT) {
+        return udd_ep_clear_halt(udd_g_ctrlreq.req.wIndex & 0xFF);
+    }
+    return false;
+}
+#endif
+
+/**
+ * \brief Standard device request to set a feature
+ *
+ * \return true if success
+ */
+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;
+#else
+        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) {
+            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;
+#endif
+    default:
+        break;
+    }
+    return false;
+}
+
+/**
+ * \brief Standard endpoint request to halt an endpoint
+ *
+ * \return true if success
+ */
+#if (0!=USB_DEVICE_MAX_EP)
+static bool udc_req_std_ep_set_feature(void)
+{
+    if (udd_g_ctrlreq.req.wLength) {
+        return false;
+    }
+    if (udd_g_ctrlreq.req.wValue == USB_EP_FEATURE_HALT) {
+        udd_ep_abort(udd_g_ctrlreq.req.wIndex & 0xFF);
+        return udd_ep_set_halt(udd_g_ctrlreq.req.wIndex & 0xFF);
+    }
+    return false;
+}
+#endif
+
+/**
+ * \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);
+}
+
+/**
+ * \brief Standard device request to set device address
+ *
+ * \return true if success
+ */
+static bool udc_req_std_dev_set_address(void)
+{
+    if (udd_g_ctrlreq.req.wLength) {
+        return false;
+    }
+
+    // The address must be changed at the end of setup request after the handshake
+    // then we use a callback to change address
+    udd_g_ctrlreq.callback = udc_valid_address;
+    return true;
+}
+
+/**
+ * \brief Standard device request to get device string descriptor
+ *
+ * \return true if success
+ */
+static bool udc_req_std_dev_get_str_desc(void)
+{
+    uint8_t i;
+    const uint8_t *str;
+    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;
+
+#ifdef USB_DEVICE_MANUFACTURE_NAME
+    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;
+#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()) {
+            break;
+        }
+#endif
+        return false;
+    }
+
+    if (str_length) {
+        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);
+    }
+
+    return true;
+}
+
+/**
+ * \brief Standard device request to get descriptors about USB device
+ *
+ * \return true if success
+ */
+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
+#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
+#endif
+        {
+            udd_set_setup_payload(
+                (uint8_t *) udc_config.confdev_lsfs,
+                udc_config.confdev_lsfs->bLength);
+        }
+        break;
+
+    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
+#endif
+        {
+            // 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));
+        }
+        ((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;
+            }
+            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));
+        }
+        ((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_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;
+
+    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) {
+        udd_g_ctrlreq.payload_size = udd_g_ctrlreq.req.wLength;
+    }
+    return true;
+}
+
+/**
+ * \brief Standard device request to get configuration number
+ *
+ * \return true if success
+ */
+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);
+    return true;
+}
+
+/**
+ * \brief Standard device request to enable a configuration
+ *
+ * \return true if success
+ */
+static bool udc_req_std_dev_set_configuration(void)
+{
+    uint8_t iface_num;
+
+    // Check request length
+    if (udd_g_ctrlreq.req.wLength) {
+        return false;
+    }
+    // Authorize configuration only if the address is valid
+    if (!udd_getaddress()) {
+        return false;
+    }
+    // Check the configuration number requested
+#ifdef USB_DEVICE_HS_SUPPORT
+    if (udd_is_high_speed()) {
+        // HS descriptor
+        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) {
+            return false;
+        }
+    }
+
+    // Reset current configuration
+    udc_reset();
+
+    // Enable new configuration
+    udc_num_configuration = udd_g_ctrlreq.req.wValue & 0xFF;
+    if (udc_num_configuration == 0) {
+        return true; // Default empty configuration requested
+    }
+    // Update pointer of the configuration descriptor
+#ifdef USB_DEVICE_HS_SUPPORT
+    if (udd_is_high_speed()) {
+        // HS descriptor
+        udc_ptr_conf = &udc_config.conf_hs[udc_num_configuration - 1];
+    } else
+#endif
+    {
+        // FS descriptor
+        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++) {
+        if (!udc_iface_enable(iface_num, 0)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+/**
+ * \brief Standard interface request
+ * to get the alternate setting number of an interface
+ *
+ * \return true if success
+ */
+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
+    }
+    if (!udc_num_configuration) {
+        return false; // The device is not is configured state yet
+    }
+
+    // Check the interface number included in the request
+    iface_num = udd_g_ctrlreq.req.wIndex & 0xFF;
+    if (iface_num >= udc_ptr_conf->desc->bNumInterfaces) {
+        return false;
+    }
+
+    // Select first alternate setting of the interface to update udc_ptr_iface
+    // before call iface->getsetting()
+    if (!udc_update_iface_desc(iface_num, 0)) {
+        return false;
+    }
+    // Get alternate setting from UDI
+    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);
+    return true;
+}
+
+/**
+ * \brief Standard interface request
+ * to set an alternate setting of an interface
+ *
+ * \return true if success
+ */
+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
+    }
+    if (!udc_num_configuration) {
+        return false; // The device is not is configured state yet
+    }
+
+    iface_num = udd_g_ctrlreq.req.wIndex & 0xFF;
+    setting_num = udd_g_ctrlreq.req.wValue & 0xFF;
+
+    // Disable current setting
+    if (!udc_iface_disable(iface_num)) {
+        return false;
+    }
+
+    // Enable new setting
+    return udc_iface_enable(iface_num, setting_num);
+}
+
+/**
+ * \brief Main routine to manage the standard USB SETUP request
+ *
+ * \return true if the request is supported
+ */
+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
+        }
+
+        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;
+            }
+        }
+
+        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;
+            }
+        }
+#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;
+            }
+        }
+#endif
+    } else {
+        // SET Standard Requests
+        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;
+            }
+        }
+
+        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;
+            }
+        }
+#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;
+            }
+        }
+#endif
+    }
+    return false;
+}
+
+/**
+ * \brief Send the SETUP interface request to UDI
+ *
+ * \return true if the request is supported
+ */
+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
+    }
+    // Check interface number
+    iface_num = udd_g_ctrlreq.req.wIndex & 0xFF;
+    if (iface_num >= udc_ptr_conf->desc->bNumInterfaces) {
+        return false;
+    }
+
+    //* To update udc_ptr_iface with the selected interface in request
+    // Select first alternate setting of interface to update udc_ptr_iface
+    // before calling udi_api->getsetting()
+    if (!udc_update_iface_desc(iface_num, 0)) {
+        return false;
+    }
+    // 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())) {
+        return false;
+    }
+
+    // Send the SETUP request to the UDI corresponding to the interface number
+    return udi_api->setup();
+}
+
+/**
+ * \brief Send the SETUP interface request to UDI
+ *
+ * \return true if the request is supported
+ */
+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
+    }
+    // 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++) {
+        // 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())) {
+            return false;
+        }
+
+        // Send the SETUP request to the UDI
+        if (udi_api->setup()) {
+            return true;
+        }
+    }
+    return false;
+}
+
+/**
+ * \brief Main routine to manage the USB SETUP request.
+ *
+ * This function parses a USB SETUP request and submits an appropriate
+ * response back to the host or, in the case of SETUP OUT requests
+ * with data, sets up a buffer for receiving the data payload.
+ *
+ * The main standard requests defined by the USB 2.0 standard are handled
+ * internally. The interface requests are sent to UDI, and the specific request
+ * sent to a specific application callback.
+ *
+ * \return true if the request is supported, else the request is stalled by UDD
+ */
+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.over_under_run = NULL;
+
+    if (Udd_setup_is_in()) {
+        if (udd_g_ctrlreq.req.wLength == 0) {
+            return false; // Error from USB host
+        }
+    }
+
+    // If standard request then try to decode it in UDC
+    if (Udd_setup_type() == USB_REQ_TYPE_STANDARD) {
+        if (udc_reqstd()) {
+            return true;
+        }
+    }
+
+    // If interface request then try to decode it in UDI
+    if (Udd_setup_recipient() == USB_REQ_RECIP_INTERFACE) {
+        if (udc_req_iface()) {
+            return true;
+        }
+    }
+
+    // If endpoint request then try to decode it in UDI
+    if (Udd_setup_recipient() == USB_REQ_RECIP_ENDPOINT) {
+        if (udc_req_ep()) {
+            return true;
+        }
+    }
+
+    // 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,...
+#else
+    return false;
+#endif
+}
+
+//! @}
diff --git a/tmk_core/protocol/arm_atsam/usb/udc.h b/tmk_core/protocol/arm_atsam/usb/udc.h
new file mode 100644
index 000000000..c88a442cb
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/usb/udc.h
@@ -0,0 +1,260 @@
+/**
+ * \file
+ *
+ * \brief Interface of the USB Device Controller (UDC)
+ *
+ * Copyright (c) 2009-2015 Atmel Corporation. All rights reserved.
+ *
+ * \asf_license_start
+ *
+ * \page License
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. The name of Atmel may not be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * 4. This software may only be redistributed and used in connection with an
+ *    Atmel microcontroller product.
+ *
+ * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
+ * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * \asf_license_stop
+ *
+ */
+/*
+ * Support and FAQ: visit <a href="http://www.atmel.com/design-support/">Atmel Support</a>
+ */
+
+#ifndef _UDC_H_
+#define _UDC_H_
+
+#include "conf_usb.h"
+#include "usb_protocol.h"
+#include "udc_desc.h"
+#include "udd.h"
+
+#if USB_DEVICE_VENDOR_ID == 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
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * \ingroup usb_device_group
+ * \defgroup udc_group USB Device Controller (UDC)
+ *
+ * The UDC provides a high-level abstraction of the usb device.
+ * You can use these functions to control the main device state
+ * (start/attach/wakeup).
+ *
+ * \section USB_DEVICE_CONF USB Device Custom configuration
+ * The following USB Device configuration must be included in the conf_usb.h
+ * file of the application.
+ *
+ * USB_DEVICE_VENDOR_ID (Word)<br>
+ * Vendor ID provided by USB org (ATMEL 0x03EB).
+ *
+ * USB_DEVICE_PRODUCT_ID (Word)<br>
+ * Product ID (Referenced in usb_atmel.h).
+ *
+ * USB_DEVICE_MAJOR_VERSION (Byte)<br>
+ * Major version of the device
+ *
+ * USB_DEVICE_MINOR_VERSION (Byte)<br>
+ * Minor version of the device
+ *
+ * USB_DEVICE_MANUFACTURE_NAME (string)<br>
+ * ASCII name for the manufacture
+ *
+ * USB_DEVICE_PRODUCT_NAME (string)<br>
+ * ASCII name for the product
+ *
+ * USB_DEVICE_SERIAL_NAME (string)<br>
+ * ASCII name to enable and set a serial number
+ *
+ * USB_DEVICE_POWER (Numeric)<br>
+ * (unit mA) Maximum device power
+ *
+ * USB_DEVICE_ATTR (Byte)<br>
+ * USB attributes available:
+ *  - USB_CONFIG_ATTR_SELF_POWERED
+ *  - USB_CONFIG_ATTR_REMOTE_WAKEUP
+ *  Note: if remote wake enabled then defines remotewakeup callbacks,
+ * see Table 5-2. External API from UDC - Callback
+ *
+ * USB_DEVICE_LOW_SPEED (Only defined)<br>
+ * Force the USB Device to run in low speed
+ *
+ * USB_DEVICE_HS_SUPPORT (Only defined)<br>
+ * Authorize the USB Device to run in high speed
+ *
+ * USB_DEVICE_MAX_EP (Byte)<br>
+ * Define the maximum endpoint number used by the USB Device.<br>
+ * This one is already defined in UDI default configuration.
+ * Ex:
+ * - When endpoint control 0x00, endpoint 0x01 and
+ *   endpoint 0x82 is used then USB_DEVICE_MAX_EP=2
+ * - When only endpoint control 0x00 is used then USB_DEVICE_MAX_EP=0
+ * - When endpoint 0x01 and endpoint 0x81 is used then USB_DEVICE_MAX_EP=1<br>
+ *   (configuration not possible on USBB interface)
+ * @{
+ */
+
+/**
+ * \brief Authorizes the VBUS event
+ *
+ * \return true, if the VBUS monitoring is possible.
+ *
+ * \section udc_vbus_monitoring VBus monitoring used cases
+ *
+ * The VBus monitoring is used only for USB SELF Power application.
+ *
+ * - By default the USB device is automatically attached when Vbus is high
+ * or when USB is start for devices without internal Vbus monitoring.
+ * conf_usb.h file does not contains define USB_DEVICE_ATTACH_AUTO_DISABLE.
+ * \code //#define USB_DEVICE_ATTACH_AUTO_DISABLE \endcode
+ *
+ * - Add custom VBUS monitoring. conf_usb.h file contains define
+ * USB_DEVICE_ATTACH_AUTO_DISABLE:
+ * \code #define USB_DEVICE_ATTACH_AUTO_DISABLE \endcode
+ * User C file contains:
+ * \code
+    // Authorize VBUS monitoring
+    if (!udc_include_vbus_monitoring()) {
+      // Implement custom VBUS monitoring via GPIO or other
+    }
+    Event_VBUS_present() // VBUS interrupt or GPIO interrupt or other
+    {
+      // Attach USB Device
+      udc_attach();
+    }
+\endcode
+ *
+ * - Case of battery charging. conf_usb.h file contains define
+ * USB_DEVICE_ATTACH_AUTO_DISABLE:
+ * \code #define USB_DEVICE_ATTACH_AUTO_DISABLE \endcode
+ * User C file contains:
+ * \code
+    Event VBUS present() // VBUS interrupt or GPIO interrupt or ..
+    {
+      // Authorize battery charging, but wait key press to start USB.
+    }
+    Event Key press()
+    {
+      // Stop batteries charging
+      // Start USB
+      udc_attach();
+    }
+\endcode
+ */
+static inline bool udc_include_vbus_monitoring(void)
+{
+    return udd_include_vbus_monitoring();
+}
+
+/*! \brief Start the USB Device stack
+ */
+void udc_start(void);
+
+/*! \brief Stop the USB Device stack
+ */
+void udc_stop(void);
+
+/**
+ * \brief Attach device to the bus when possible
+ *
+ * \warning If a VBus control is included in driver,
+ * then it will attach device when an acceptable Vbus
+ * level from the host is detected.
+ */
+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();
+}
+
+/*! \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.
+ */
+static inline void udc_remotewakeup(void)
+{
+    udd_send_remotewakeup();
+}
+
+/**
+ * \brief Returns a pointer on the current interface descriptor
+ *
+ * \return pointer on the current interface descriptor.
+ */
+usb_iface_desc_t UDC_DESC_STORAGE *udc_get_interface_desc(void);
+
+//@}
+
+/**
+ * \ingroup usb_group
+ * \defgroup usb_device_group USB Stack Device
+ *
+ * This module includes USB Stack Device implementation.
+ * The stack is divided in three parts:
+ * - USB Device Controller (UDC) provides USB chapter 9 compliance
+ * - USB Device Interface (UDI) provides USB Class compliance
+ * - USB Device Driver (UDD) provides USB Driver for each Atmel MCU
+
+ * Many USB Device applications can be implemented on Atmel MCU.
+ * Atmel provides many application notes for different applications:
+ * - AVR4900, provides general information about Device Stack
+ * - AVR4901, explains how to create a new class
+ * - AVR4902, explains how to create a composite device
+ * - AVR49xx, all device classes provided in ASF have an application note
+ *
+ * A basic USB knowledge is required to understand the USB Device
+ * Class application notes (HID,MS,CDC,PHDC,...).
+ * Then, to create an USB device with
+ * only one class provided by ASF, refer directly to the application note
+ * corresponding to this USB class. The USB Device application note for
+ * New Class and Composite is dedicated to advanced USB users.
+ *
+ * @{
+ */
+
+//! @}
+
+#ifdef __cplusplus
+}
+#endif
+
+#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
new file mode 100644
index 000000000..9cab03dcb
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/usb/udc_desc.h
@@ -0,0 +1,135 @@
+/**
+ * \file
+ *
+ * \brief Common API for USB Device Interface
+ *
+ * Copyright (c) 2009-2015 Atmel Corporation. All rights reserved.
+ *
+ * \asf_license_start
+ *
+ * \page License
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. The name of Atmel may not be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * 4. This software may only be redistributed and used in connection with an
+ *    Atmel microcontroller product.
+ *
+ * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
+ * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * \asf_license_stop
+ *
+ */
+/*
+ * Support and FAQ: visit <a href="http://www.atmel.com/design-support/">Atmel Support</a>
+ */
+
+#ifndef _UDC_DESC_H_
+#define _UDC_DESC_H_
+
+#include "conf_usb.h"
+#include "usb_protocol.h"
+#include "udi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * \ingroup udc_group
+ * \defgroup udc_desc_group USB Device Descriptor
+ *
+ * @{
+ */
+
+/**
+ * \brief Defines the memory's location of USB descriptors
+ *
+ * By default the Descriptor is stored in RAM
+ * (UDC_DESC_STORAGE is defined empty).
+ *
+ * If you have need to free RAM space,
+ * it is possible to put descriptor in flash in following case:
+ * - USB driver authorize flash transfer (USBB on UC3 and USB on Mega)
+ * - USB Device is not high speed (UDC no need to change USB descriptors)
+ *
+ * For UC3 application used "const".
+ *
+ * For Mega application used "code".
+ */
+#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
+#else
+#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
+ */
+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;
+} udc_config_speed_t;
+
+
+/**
+ * \brief All information about the USB Device
+ */
+typedef struct {
+    //! USB device descriptor for low or full speed
+    usb_dev_desc_t UDC_DESC_STORAGE *confdev_lsfs;
+    //! USB configuration descriptor and UDI API pointers for low or full speed
+    udc_config_speed_t UDC_DESC_STORAGE *conf_lsfs;
+#ifdef USB_DEVICE_HS_SUPPORT
+    //! USB device descriptor for high speed
+    usb_dev_desc_t UDC_DESC_STORAGE *confdev_hs;
+    //! USB device qualifier, only use in high speed mode
+    usb_dev_qual_desc_t UDC_DESC_STORAGE *qualifier;
+    //! USB configuration descriptor and UDI API pointers for high speed
+    udc_config_speed_t UDC_DESC_STORAGE *conf_hs;
+#endif
+    usb_dev_bos_desc_t UDC_DESC_STORAGE *conf_bos;
+} udc_config_t;
+
+//! Global variables of USB Device Descriptor and UDI links
+extern UDC_DESC_STORAGE udc_config_t udc_config;
+
+//@}
+
+#ifdef __cplusplus
+}
+#endif
+#endif // _UDC_DESC_H_
diff --git a/tmk_core/protocol/arm_atsam/usb/udd.h b/tmk_core/protocol/arm_atsam/usb/udd.h
new file mode 100644
index 000000000..b580e5847
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/usb/udd.h
@@ -0,0 +1,396 @@
+/**
+ * \file
+ *
+ * \brief Common API for USB Device Drivers (UDD)
+ *
+ * Copyright (c) 2009-2015 Atmel Corporation. All rights reserved.
+ *
+ * \asf_license_start
+ *
+ * \page License
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. The name of Atmel may not be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * 4. This software may only be redistributed and used in connection with an
+ *    Atmel microcontroller product.
+ *
+ * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
+ * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * \asf_license_stop
+ *
+ */
+/*
+ * Support and FAQ: visit <a href="http://www.atmel.com/design-support/">Atmel Support</a>
+ */
+
+#ifndef _UDD_H_
+#define _UDD_H_
+
+#include "usb_protocol.h"
+#include "udc_desc.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * \ingroup usb_device_group
+ * \defgroup udd_group USB Device Driver (UDD)
+ *
+ * The UDD driver provides a low-level abstraction of the device
+ * controller hardware. Most events coming from the hardware such as
+ * interrupts, which may cause the UDD to call into the UDC and UDI.
+ *
+ * @{
+ */
+
+//! \brief Endpoint identifier
+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_ABORT = 1,
+} udd_ep_status_t;
+
+/**
+ * \brief Global variable to give and record information of the setup request management
+ *
+ * This global variable allows to decode and response a setup request.
+ * It can be updated by udc_process_setup() from UDC or *setup() from UDIs.
+ */
+typedef struct {
+    //! Data received in USB SETUP packet
+    //! Note: The swap of "req.wValues" from uin16_t to le16_t is done by UDD.
+    usb_setup_req_t req;
+
+    //! Point to buffer to send or fill with data following SETUP packet
+    //! This buffer must be word align for DATA IN phase (use prefix COMPILER_WORD_ALIGNED for buffer)
+    uint8_t *payload;
+
+    //! Size of buffer to send or fill, and content the number of byte transfered
+    uint16_t payload_size;
+
+    //! Callback called after reception of ZLP from setup request
+    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);
+} 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))
+
+//! 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))
+
+//! 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)
+
+//! 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)
+
+/**
+ * \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);
+
+/**
+ * \brief End of transfer callback function type.
+ * Registered by routine udd_ep_run()
+ * Callback called by USB interrupt after data transfer or abort (reset,...).
+ *
+ * \param status     UDD_EP_TRANSFER_OK, if transfer is complete
+ * \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);
+
+/**
+ * \brief Authorizes the VBUS event
+ *
+ * \return true, if the VBUS monitoring is possible.
+ */
+bool udd_include_vbus_monitoring(void);
+
+/**
+ * \brief Enables the USB Device mode
+ */
+void udd_enable(void);
+
+/**
+ * \brief Disables the USB Device mode
+ */
+void udd_disable(void);
+
+/**
+ * \brief Attach device to the bus when possible
+ *
+ * \warning If a VBus control is included in driver,
+ * then it will attach device when an acceptable Vbus
+ * level from the host is detected.
+ */
+void udd_attach(void);
+
+/**
+ * \brief Detaches the device from the bus
+ *
+ * The driver must remove pull-up on USB line D- or D+.
+ */
+void udd_detach(void);
+
+/**
+ * \brief Test whether the USB Device Controller is running at high
+ * speed or not.
+ *
+ * \return \c true if the Device is running at high speed mode, otherwise \c false.
+ */
+bool udd_is_high_speed(void);
+
+/**
+ * \brief Changes the USB address of device
+ *
+ * \param address    New USB address
+ */
+void udd_set_address(uint8_t address);
+
+/**
+ * \brief Returns the USB address of device
+ *
+ * \return USB address
+ */
+uint8_t udd_getaddress(void);
+
+/**
+ * \brief Returns the current start of frame number
+ *
+ * \return current start of frame number.
+ */
+uint16_t udd_get_frame_number(void);
+
+/**
+ * \brief Returns the current micro start of frame number
+ *
+ * \return current micro start of frame number required in high speed mode.
+ */
+uint16_t udd_get_micro_frame_number(void);
+
+/*! \brief The USB driver sends a resume signal called Upstream Resume
+ */
+void udd_send_remotewakeup(void);
+
+/**
+ * \brief Load setup payload
+ *
+ * \param payload       Pointer on payload
+ * \param payload_size  Size of payload
+ */
+void udd_set_setup_payload( uint8_t *payload, uint16_t payload_size );
+
+
+/**
+ * \name Endpoint Management
+ *
+ * The following functions allow drivers to create and remove
+ * endpoints, as well as set, clear and query their "halted" and
+ * "wedged" states.
+ */
+//@{
+
+#if (USB_DEVICE_MAX_EP != 0)
+
+/**
+ * \brief Configures and enables an endpoint
+ *
+ * \param ep               Endpoint number including direction (USB_EP_DIR_IN/USB_EP_DIR_OUT).
+ * \param bmAttributes     Attributes of endpoint declared in the descriptor.
+ * \param MaxEndpointSize  Endpoint maximum 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);
+
+/**
+ * \brief Disables an endpoint
+ *
+ * \param ep               Endpoint number including direction (USB_EP_DIR_IN/USB_EP_DIR_OUT).
+ */
+void udd_ep_free(udd_ep_id_t ep);
+
+/**
+ * \brief Check if the endpoint \a ep is halted.
+ *
+ * \param ep The ID of the endpoint to check.
+ *
+ * \return \c 1 if \a ep is halted, otherwise \c 0.
+ */
+bool udd_ep_is_halted(udd_ep_id_t ep);
+
+/**
+ * \brief Set the halted state of the endpoint \a ep
+ *
+ * After calling this function, any transaction on \a ep will result
+ * in a STALL handshake being sent. Any pending transactions will be
+ * performed first, however.
+ *
+ * \param ep The ID of the endpoint to be halted
+ *
+ * \return \c 1 if \a ep is halted, otherwise \c 0.
+ */
+bool udd_ep_set_halt(udd_ep_id_t ep);
+
+/**
+ * \brief Clear the halted state of the endpoint \a ep
+ *
+ * After calling this function, any transaction on \a ep will
+ * be handled normally, i.e. a STALL handshake will not be sent, and
+ * the data toggle sequence will start at DATA0.
+ *
+ * \param ep The ID of the endpoint to be un-halted
+ *
+ * \return \c 1 if function was successfully done, otherwise \c 0.
+ */
+bool udd_ep_clear_halt(udd_ep_id_t ep);
+
+/**
+ * \brief Registers a callback to call when endpoint halt is cleared
+ *
+ * \param ep            The ID of the endpoint to use
+ * \param callback      NULL or function to call when endpoint halt is cleared
+ *
+ * \warning if the endpoint is not halted then the \a callback is called immediately.
+ *
+ * \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);
+
+/**
+ * \brief Allows to receive or send data on an endpoint
+ *
+ * The driver uses a specific DMA USB to transfer data
+ * from internal RAM to endpoint, if this one is available.
+ * When the transfer is finished or aborted (stall, reset, ...), the \a callback is called.
+ * The \a callback returns the transfer status and eventually the number of byte transfered.
+ * Note: The control endpoint is not authorized.
+ *
+ * \param ep            The ID of the endpoint to use
+ * \param b_shortpacket Enabled automatic short packet
+ * \param buf           Buffer on Internal RAM to send or fill.
+ *                      It must be align, then use COMPILER_WORD_ALIGNED.
+ * \param buf_size      Buffer size to send or fill
+ * \param callback      NULL or function to call at the end of transfer
+ *
+ * \warning About \a b_shortpacket, for IN endpoint it means that a short packet
+ * (or a Zero Length Packet) will be sent to the USB line to properly close the usb
+ * transfer at the end of the data transfer.
+ * For Bulk and Interrupt OUT endpoint, it will automatically stop the transfer
+ * at the end of the data transfer (received short packet).
+ *
+ * \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);
+/**
+ * \brief Aborts transfer on going on endpoint
+ *
+ * If a transfer is on going, then it is stopped and
+ * the callback registered is called to signal the end of transfer.
+ * Note: The control endpoint is not authorized.
+ *
+ * \param ep            Endpoint to abort
+ */
+void udd_ep_abort(udd_ep_id_t ep);
+
+#endif
+
+//@}
+
+
+/**
+ * \name High speed test mode management
+ *
+ * The following functions allow the device to jump to a specific test mode required in high speed mode.
+ */
+//@{
+void udd_test_mode_j(void);
+void udd_test_mode_k(void);
+void udd_test_mode_se0_nak(void);
+void udd_test_mode_packet(void);
+//@}
+
+
+/**
+ * \name UDC callbacks to provide for UDD
+ *
+ * The following callbacks are used by UDD.
+ */
+//@{
+
+/**
+ * \brief Decodes and manages a setup request
+ *
+ * The driver call it when a SETUP packet is received.
+ * The \c udd_g_ctrlreq contains the data of SETUP packet.
+ * If this callback accepts the setup request then it must
+ * return \c 1 and eventually update \c udd_g_ctrlreq to send or receive data.
+ *
+ * \return \c 1 if the request is accepted, otherwise \c 0.
+ */
+extern bool udc_process_setup(void);
+
+/**
+ * \brief Reset the UDC
+ *
+ * The UDC must reset all configuration.
+ */
+extern void udc_reset(void);
+
+/**
+ * \brief To signal that a SOF is occurred
+ *
+ * The UDC must send the signal to all UDIs enabled
+ */
+extern void udc_sof_notify(void);
+
+//@}
+
+//@}
+
+#ifdef __cplusplus
+}
+#endif
+#endif // _UDD_H_
diff --git a/tmk_core/protocol/arm_atsam/usb/udi.h b/tmk_core/protocol/arm_atsam/usb/udi.h
new file mode 100644
index 000000000..9e4d4baf7
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/usb/udi.h
@@ -0,0 +1,133 @@
+/**
+ * \file
+ *
+ * \brief Common API for USB Device Interface
+ *
+ * Copyright (c) 2009-2015 Atmel Corporation. All rights reserved.
+ *
+ * \asf_license_start
+ *
+ * \page License
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. The name of Atmel may not be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * 4. This software may only be redistributed and used in connection with an
+ *    Atmel microcontroller product.
+ *
+ * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
+ * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * \asf_license_stop
+ *
+ */
+/*
+ * Support and FAQ: visit <a href="http://www.atmel.com/design-support/">Atmel Support</a>
+ */
+
+#ifndef _UDI_H_
+#define _UDI_H_
+
+#include "conf_usb.h"
+#include "usb_protocol.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * \ingroup usb_device_group
+ * \defgroup udi_group USB Device Interface (UDI)
+ * The UDI provides a common API for all classes,
+ * and this is used by UDC for the main control of USB Device interface.
+ * @{
+ */
+
+/**
+ * \brief UDI API.
+ *
+ * The callbacks within this structure are called only by
+ * USB Device Controller (UDC)
+ *
+ * The udc_get_interface_desc() can be use by UDI to know the interface descriptor
+ * 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 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 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);
+} udi_api_t;
+
+//@}
+
+#ifdef __cplusplus
+}
+#endif
+#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
new file mode 100644
index 000000000..b4159d325
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/usb/udi_cdc.c
@@ -0,0 +1,1384 @@
+/**
+ * \file
+ *
+ * \brief USB Device Communication Device Class (CDC) interface.
+ *
+ * Copyright (c) 2009-2016 Atmel Corporation. All rights reserved.
+ *
+ * \asf_license_start
+ *
+ * \page License
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. The name of Atmel may not be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * 4. This software may only be redistributed and used in connection with an
+ *    Atmel microcontroller product.
+ *
+ * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
+ * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * \asf_license_stop
+ *
+ */
+/*
+ * Support and FAQ: visit <a href="http://www.atmel.com/design-support/">Atmel Support</a>
+ */
+
+#include "samd51j18a.h"
+#include "conf_usb.h"
+#include "usb_protocol.h"
+#include "usb_protocol_cdc.h"
+#include "udd.h"
+#include "udc.h"
+#include "udi_cdc.h"
+#include <string.h>
+#include "udi_cdc_conf.h"
+#include "udi_device_conf.h"
+#include "spfssf.h"
+#include "stdarg.h"
+#include "tmk_core/protocol/arm_atsam/clks.h"
+
+#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
+
+/**
+ * \ingroup udi_cdc_group
+ * \defgroup udi_cdc_group_udc Interface with USB Device Core (UDC)
+ *
+ * Structures and functions required by UDC.
+ *
+ * @{
+ */
+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,
+    .getsetting = udi_cdc_getsetting,
+    .sof_notify = udi_cdc_data_sof_notify,
+};
+//@}
+
+/**
+ * \ingroup udi_cdc_group
+ * \defgroup udi_cdc_group_internal Implementation of UDI CDC
+ *
+ * Class internal implementation
+ * @{
+ */
+
+/**
+ * \name Internal routines
+ */
+//@{
+
+/**
+ * \name Routines to control serial line
+ */
+//@{
+
+/**
+ * \brief Returns the port number corresponding at current setup request
+ *
+ * \return port number
+ */
+static uint8_t udi_cdc_setup_to_port(void);
+
+/**
+ * \brief Sends line coding to application
+ *
+ * Called after SETUP request when line coding data is received.
+ */
+static void udi_cdc_line_coding_received(void);
+
+/**
+ * \brief Records new state
+ *
+ * \param port       Communication port number to manage
+ * \param b_set      State is enabled if true, else disabled
+ * \param bit_mask   Field to process (see CDC_SERIAL_STATE_ defines)
+ */
+static void udi_cdc_ctrl_state_change(uint8_t port, bool b_set, le16_t bit_mask);
+
+/**
+ * \brief Check and eventually notify the USB host of new state
+ *
+ * \param port       Communication port number to manage
+ * \param ep         Port communication endpoint
+ */
+static void udi_cdc_ctrl_state_notify(uint8_t port, udd_ep_id_t ep);
+
+/**
+ * \brief Ack sent of serial state message
+ * Callback called after serial state message sent
+ *
+ * \param status     UDD_EP_TRANSFER_OK, if transfer finished
+ * \param status     UDD_EP_TRANSFER_ABORT, if transfer aborted
+ * \param n          number of data transfered
+ */
+static void udi_cdc_serial_state_msg_sent(udd_ep_status_t status, iram_size_t n, udd_ep_id_t ep);
+
+//@}
+
+/**
+ * \name Routines to process data transfer
+ */
+//@{
+
+/**
+ * \brief Enable the reception of data from the USB host
+ *
+ * The value udi_cdc_rx_trans_sel indicate the RX buffer to fill.
+ *
+ * \param port       Communication port number to manage
+ *
+ * \return \c 1 if function was successfully done, otherwise \c 0.
+ */
+static bool udi_cdc_rx_start(uint8_t port);
+
+/**
+ * \brief Update rx buffer management with a new data
+ * Callback called after data reception on USB line
+ *
+ * \param status     UDD_EP_TRANSFER_OK, if transfer finish
+ * \param status     UDD_EP_TRANSFER_ABORT, if transfer aborted
+ * \param n          number of data received
+ */
+static void udi_cdc_data_received(udd_ep_status_t status, iram_size_t n, udd_ep_id_t ep);
+
+/**
+ * \brief Ack sent of tx buffer
+ * Callback called after data transfer on USB line
+ *
+ * \param status     UDD_EP_TRANSFER_OK, if transfer finished
+ * \param status     UDD_EP_TRANSFER_ABORT, if transfer aborted
+ * \param n          number of data transfered
+ */
+static void udi_cdc_data_sent(udd_ep_status_t status, iram_size_t n, udd_ep_id_t ep);
+
+/**
+ * \brief Send buffer on line or wait a SOF event
+ *
+ * \param port       Communication port number to manage
+ */
+static void udi_cdc_tx_send(uint8_t port);
+
+//@}
+
+//@}
+
+/**
+ * \name Information about configuration of communication line
+ */
+//@{
+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];
+COMPILER_WORD_ALIGNED static usb_cdc_notify_serial_state_t uid_cdc_state_msg[UDI_CDC_PORT_NB];
+
+//! Status of CDC COMM interfaces
+static volatile uint8_t udi_cdc_nb_comm_enabled = 0;
+//@}
+
+/**
+ * \name Variables to manage RX/TX transfer requests
+ * Two buffers for each sense are used to optimize the speed.
+ */
+//@{
+
+//! Status of CDC DATA interfaces
+static volatile uint8_t udi_cdc_nb_data_enabled = 0;
+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
+static volatile uint16_t udi_cdc_rx_buf_nb[UDI_CDC_PORT_NB][2];
+//! Give the current RX buffer used (rx0 if 0, rx1 if 1)
+static volatile uint8_t udi_cdc_rx_buf_sel[UDI_CDC_PORT_NB];
+//! Read position in current RX buffer
+static volatile uint16_t udi_cdc_rx_pos[UDI_CDC_PORT_NB];
+//! Signal a transfer on-going
+static volatile bool udi_cdc_rx_trans_ongoing[UDI_CDC_PORT_NB];
+
+//! Define a transfer halted
+#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];
+//! Data available in TX buffers
+static uint16_t udi_cdc_tx_buf_nb[UDI_CDC_PORT_NB][2];
+//! Give current TX buffer used (tx0 if 0, tx1 if 1)
+static volatile uint8_t udi_cdc_tx_buf_sel[UDI_CDC_PORT_NB];
+//! Value of SOF during last TX transfer
+static uint16_t udi_cdc_tx_sof_num[UDI_CDC_PORT_NB];
+//! Signal a transfer on-going
+static volatile bool udi_cdc_tx_trans_ongoing[UDI_CDC_PORT_NB];
+//! Signal that both buffer content data to send
+static volatile bool udi_cdc_tx_both_buf_to_send[UDI_CDC_PORT_NB];
+
+//@}
+
+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;
+    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
+
+    // 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.bNotification = USB_REQ_CDC_NOTIFY_SERIAL_STATE;
+    uid_cdc_state_msg[port].header.wValue = LE16(0);
+
+    /*
+    switch (port) {
+    #define UDI_CDC_PORT_TO_IFACE_COMM(index, unused) \
+        case index: \
+            iface_comm_num = UDI_CDC_COMM_IFACE_NUMBER_##index; \
+            break;
+        MREPEAT(UDI_CDC_PORT_NB, UDI_CDC_PORT_TO_IFACE_COMM, ~)
+    #undef UDI_CDC_PORT_TO_IFACE_COMM
+        default:
+            iface_comm_num = UDI_CDC_COMM_IFACE_NUMBER_0;
+            break;
+        }
+    */
+    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.wLength = LE16(2);
+    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].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;
+    // Call application callback
+    // to initialize memories or indicate that interface is enabled
+#if 0
+    UDI_CDC_SET_CODING_EXT(port,(&udi_cdc_line_coding[port]));
+    if (!UDI_CDC_ENABLE_EXT(port)) {
+        return false;
+    }
+#endif
+    udi_cdc_nb_comm_enabled++;
+    return true;
+}
+
+bool udi_cdc_data_enable(void)
+{
+    uint8_t port;
+
+//#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
+
+    // Initialize TX management
+    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_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;
+    if (!udi_cdc_rx_start(port)) {
+        return false;
+    }
+    udi_cdc_nb_data_enabled++;
+    if (udi_cdc_nb_data_enabled == UDI_CDC_PORT_NB) {
+        udi_cdc_data_running = true;
+    }
+    return true;
+}
+
+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;
+
+    Assert(udi_cdc_nb_data_enabled != 0);
+    udi_cdc_nb_data_enabled--;
+//  port = udi_cdc_nb_data_enabled;
+//  UDI_CDC_DISABLE_EXT(port);
+    udi_cdc_data_running = false;
+}
+
+bool udi_cdc_comm_setup(void)
+{
+    uint8_t port = udi_cdc_setup_to_port();
+
+    if (Udd_setup_is_in()) {
+        // GET Interface Requests
+        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;
+            }
+        }
+    }
+    if (Udd_setup_is_out()) {
+        // SET Interface Requests
+        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;
+            }
+        }
+    }
+    return false;  // request Not supported
+}
+
+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
+}
+
+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
+    udi_cdc_tx_send(port_notify);
+    /*
+#if UDI_CDC_PORT_NB != 1 // To optimize code
+    port_notify++;
+    if (port_notify >= UDI_CDC_PORT_NB) {
+        port_notify = 0;
+    }
+#endif
+    */
+}
+
+
+//-------------------------------------------------
+//------- Internal routines to control serial line
+
+static uint8_t udi_cdc_setup_to_port(void)
+{
+    uint8_t port;
+
+    /*
+    switch (udd_g_ctrlreq.req.wIndex & 0xFF) {
+#define UDI_CDC_IFACE_COMM_TO_PORT(iface, unused) \
+    case UDI_CDC_COMM_IFACE_NUMBER_##iface: \
+        port = iface; \
+        break;
+    MREPEAT(UDI_CDC_PORT_NB, UDI_CDC_IFACE_COMM_TO_PORT, ~)
+#undef UDI_CDC_IFACE_COMM_TO_PORT
+    default:
+        port = 0;
+        break;
+    }
+    */
+    port = 0;
+
+    return port;
+}
+
+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]));
+}
+
+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
+
+
+//#if UDI_CDC_PORT_NB == 1 // To optimize code
+    port = 0;
+//#endif
+
+    // Update state
+  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);
+
+    /*
+    // Send it if possible and state changed
+    switch (port) {
+#define UDI_CDC_PORT_TO_COMM_EP(index, unused) \
+    case index: \
+        ep_comm = UDI_CDC_COMM_EP_##index; \
+        break;
+    MREPEAT(UDI_CDC_PORT_NB, UDI_CDC_PORT_TO_COMM_EP, ~)
+#undef UDI_CDC_PORT_TO_COMM_EP
+    default:
+        ep_comm = UDI_CDC_COMM_EP_0;
+        break;
+    }
+    */
+    ep_comm = UDI_CDC_COMM_EP_0;
+
+    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
+    port = 0;
+#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)) {
+        // 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);
+    }
+}
+
+
+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);
+
+    /*
+    switch (ep) {
+#define UDI_CDC_GET_PORT_FROM_COMM_EP(iface, unused) \
+    case UDI_CDC_COMM_EP_##iface: \
+        port = iface; \
+        break;
+    MREPEAT(UDI_CDC_PORT_NB, UDI_CDC_GET_PORT_FROM_COMM_EP, ~)
+#undef UDI_CDC_GET_PORT_FROM_COMM_EP
+    default:
+        port = 0;
+        break;
+    }
+    */
+    port = 0;
+
+    udi_cdc_serial_state_msg_ongoing[port] = false;
+
+    // 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);
+    // Send it if possible and state changed
+    udi_cdc_ctrl_state_notify(port, ep);
+}
+
+//-------------------------------------------------
+//------- 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;
+    udd_ep_id_t ep;
+
+//#if UDI_CDC_PORT_NB == 1 // To optimize code
+    port = 0;
+//#endif
+
+    irqflags = __get_PRIMASK();
+  __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])) {
+        // Transfer already on-going or current buffer no empty
+      __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;
+
+    // Start transfer on RX
+    udi_cdc_rx_trans_ongoing[port] = true;
+  __DMB();
+  __set_PRIMASK(irqflags);
+
+    if (udi_cdc_multi_is_rx_ready(port)) {
+//      UDI_CDC_RX_NOTIFY(port);
+    }
+
+    /*
+    // Send the buffer with enable of short packet
+    switch (port) {
+#define UDI_CDC_PORT_TO_DATA_EP_OUT(index, unused) \
+    case index: \
+        ep = UDI_CDC_DATA_EP_OUT_##index; \
+        break;
+    MREPEAT(UDI_CDC_PORT_NB, UDI_CDC_PORT_TO_DATA_EP_OUT, ~)
+#undef UDI_CDC_PORT_TO_DATA_EP_OUT
+    default:
+        ep = UDI_CDC_DATA_EP_OUT_0;
+        break;
+    }
+    */
+    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);
+}
+
+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;
+
+    /*
+    switch (ep) {
+#define UDI_CDC_DATA_EP_OUT_TO_PORT(index, unused) \
+    case UDI_CDC_DATA_EP_OUT_##index: \
+        port = index; \
+        break;
+    MREPEAT(UDI_CDC_PORT_NB, UDI_CDC_DATA_EP_OUT_TO_PORT, ~)
+#undef UDI_CDC_DATA_EP_OUT_TO_PORT
+    default:
+        port = 0;
+        break;
+    }
+    */
+    port = 0;
+
+    if (UDD_EP_TRANSFER_OK != status) {
+        // Abort reception
+        return;
+    }
+
+    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);
+        return;
+    }
+
+    udi_cdc_rx_buf_nb[port][buf_sel_trans] = n;
+    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)
+{
+    uint8_t port;
+    UNUSED(n);
+
+    /*
+    switch (ep) {
+#define UDI_CDC_DATA_EP_IN_TO_PORT(index, unused) \
+    case UDI_CDC_DATA_EP_IN_##index: \
+        port = index; \
+        break;
+    MREPEAT(UDI_CDC_PORT_NB, UDI_CDC_DATA_EP_IN_TO_PORT, ~)
+#undef UDI_CDC_DATA_EP_IN_TO_PORT
+    default:
+        port = 0;
+        break;
+    }
+    */
+    port = 0;
+
+    if (UDD_EP_TRANSFER_OK != status) {
+        // Abort transfer
+        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;
+
+    if (n != 0) {
+        UDI_CDC_TX_EMPTY_NOTIFY(port);
+    }
+
+    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 uint16_t sof_zlp_counter = 0;
+
+//#if UDI_CDC_PORT_NB == 1 // To optimize code
+    port = 0;
+//#endif
+
+    if (udi_cdc_tx_trans_ongoing[port]) {
+        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
+        }
+    }else{
+        if (udi_cdc_tx_sof_num[port] == udd_get_frame_number()) {
+            return; // Wait next SOF to send next data
+        }
+    }
+
+    irqflags = __get_PRIMASK();
+  __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);
+            return;
+        }
+    }
+    sof_zlp_counter = 0;
+
+    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{
+        // Send the other Buffer
+        // and no switch the current buffer
+        buf_sel_trans = (buf_sel_trans==0)?1:0;
+    }
+    udi_cdc_tx_trans_ongoing[port] = true;
+  __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{
+            udi_cdc_tx_sof_num[port] = udd_get_frame_number();
+        }
+    }else{
+        udi_cdc_tx_sof_num[port] = 0; // Force next transfer without wait SOF
+    }
+
+    /*
+    // Send the buffer with enable of short packet
+    switch (port) {
+#define UDI_CDC_PORT_TO_DATA_EP_IN(index, unused) \
+    case index: \
+        ep = UDI_CDC_DATA_EP_IN_##index; \
+        break;
+    MREPEAT(UDI_CDC_PORT_NB, UDI_CDC_PORT_TO_DATA_EP_IN, ~)
+#undef UDI_CDC_PORT_TO_DATA_EP_IN
+    default:
+        ep = UDI_CDC_DATA_EP_IN_0;
+        break;
+    }
+    */
+    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);
+}
+
+//---------------------------------------------
+//------- 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_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_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_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_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_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 nb_received;
+
+//#if UDI_CDC_PORT_NB == 1 // To optimize code
+    port = 0;
+//#endif
+
+    irqflags = __get_PRIMASK();
+  __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);
+    return nb_received;
+}
+
+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_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;
+    uint16_t pos;
+    uint8_t buf_sel;
+    bool again;
+
+//#if UDI_CDC_PORT_NB == 1 // To optimize code
+    port = 0;
+//#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];
+    buf_sel = udi_cdc_rx_buf_sel[port];
+    again = pos >= udi_cdc_rx_buf_nb[port][buf_sel];
+    __DMB();
+  __set_PRIMASK(irqflags);
+    while (again) {
+        if (!udi_cdc_data_running) {
+            return 0;
+        }
+        goto 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_start(port);
+
+    if (b_databit_9) {
+        // Receive MSB
+        b_databit_9 = false;
+        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);
+}
+
+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;
+
+//#if UDI_CDC_PORT_NB == 1 // To optimize code
+    port = 0;
+//#endif
+
+udi_cdc_read_buf_loop_wait:
+    // Check available data
+    irqflags = __get_PRIMASK();
+  __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];
+    __DMB();
+  __set_PRIMASK(irqflags);
+    while (again) {
+        if (!udi_cdc_data_running) {
+            return size;
+        }
+        goto udi_cdc_read_buf_loop_wait;
+    }
+
+    // Read data
+    copy_nb = udi_cdc_rx_buf_nb[port][buf_sel] - pos;
+    if (copy_nb>size) {
+        copy_nb = size;
+    }
+    memcpy(ptr_buf, &udi_cdc_rx_buf[port][buf_sel][pos], copy_nb);
+    udi_cdc_rx_pos[port] += copy_nb;
+    ptr_buf += copy_nb;
+    size -= copy_nb;
+    udi_cdc_rx_start(port);
+
+    if (size) {
+        goto 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;
+    iram_size_t nb_avail_data;
+    uint16_t pos;
+    uint8_t buf_sel;
+    uint32_t irqflags;  //irqflags_t
+
+//#if UDI_CDC_PORT_NB == 1 // To optimize code
+    port = 0;
+//#endif
+
+    //Data interface not started... exit
+    if (!udi_cdc_data_running) {
+        return 0;
+    }
+
+    //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];
+    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) {
+        size = nb_avail_data;
+    }
+    if(size>0) {
+        memcpy(ptr_buf, &udi_cdc_rx_buf[port][buf_sel][pos], size);
+    irqflags = __get_PRIMASK();
+    __disable_irq();
+    __DMB();
+        udi_cdc_rx_pos[port] += size;
+    __DMB();
+    __set_PRIMASK(irqflags);
+        ptr_buf += size;
+        udi_cdc_rx_start(port);
+    }
+    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_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 buf_sel_nb, retval;
+    uint8_t buf_sel;
+
+//#if UDI_CDC_PORT_NB == 1 // To optimize code
+    port = 0;
+//#endif
+
+    irqflags = __get_PRIMASK();
+  __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])) {
+            /* 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;
+        }
+    }
+    retval = UDI_CDC_TX_BUFFERS - buf_sel_nb;
+    __DMB();
+  __set_PRIMASK(irqflags);
+    return retval;
+}
+
+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_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;
+
+//#if UDI_CDC_PORT_NB == 1 // To optimize code
+    port = 0;
+//#endif
+
+    b_databit_9 = (9 == udi_cdc_line_coding[port].bDataBits);
+
+udi_cdc_putc_process_one_byte:
+    // Check available space
+    if (!udi_cdc_multi_is_tx_ready(port)) {
+        if (!udi_cdc_data_running) {
+            return false;
+        }
+        goto udi_cdc_putc_process_one_byte;
+    }
+
+    // Write value
+    irqflags = __get_PRIMASK();
+  __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);
+
+    if (b_databit_9) {
+        // Send MSB
+        b_databit_9 = false;
+        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);
+}
+
+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;
+
+//#if UDI_CDC_PORT_NB == 1 // To optimize code
+    port = 0;
+//#endif
+
+    if (9 == udi_cdc_line_coding[port].bDataBits) {
+        size *=2;
+    }
+
+    udi_cdc_write_buf_loop_wait:
+
+    // Check available space
+    if (!udi_cdc_multi_is_tx_ready(port)) {
+        if (!udi_cdc_data_running) {
+            return size;
+        }
+        goto udi_cdc_write_buf_loop_wait;
+    }
+
+    // Write values
+    irqflags = __get_PRIMASK();
+    __disable_irq();
+    __DMB();
+    buf_sel = udi_cdc_tx_buf_sel[port];
+    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;
+    }
+    memcpy(&udi_cdc_tx_buf[port][buf_sel][buf_nb], ptr_buf, copy_nb);
+    udi_cdc_tx_buf_nb[port][buf_sel] = buf_nb + copy_nb;
+    __DMB();
+    __set_PRIMASK(irqflags);
+
+    // Update buffer pointer
+    ptr_buf = ptr_buf + copy_nb;
+    size -= copy_nb;
+
+    if (size) {
+        goto udi_cdc_write_buf_loop_wait;
+    }
+
+    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);
+}
+
+#define MAX_PRINT 256
+#define CDC_SEND_INTERVAL 2
+uint32_t cdc_tx_send_time_next;
+
+void CDC_send(void)
+{
+    while (CLK_get_ms() < cdc_tx_send_time_next);
+    udi_cdc_tx_send(0);
+    cdc_tx_send_time_next = CLK_get_ms() + CDC_SEND_INTERVAL;
+}
+
+uint32_t CDC_print(char *printbuf)
+{
+    uint32_t count=0;
+    char *buf = printbuf;
+    char c;
+
+    if (CLK_get_ms() < 5000) return 0;
+
+    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)
+        {
+            count = 0;
+            CDC_send();
+        }
+    }
+    if (count)
+    {
+        CDC_send();
+    }
+    return 1;
+}
+
+
+char printbuf[CDC_PRINTBUF_SIZE];
+
+int dpf(const char *_Format, ...)
+{
+    va_list va; //Variable argument list variable
+    int result;
+
+    va_start(va,_Format); //Initialize the variable argument list
+    result = vspf(printbuf, _Format, va);
+    va_end(va);
+
+    CDC_print(printbuf);
+
+    return result;
+}
+
+//global "inbuf" if desired
+inbuf_t inbuf;
+
+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;
+                CDC_print(inbuf.buf);
+                break;
+            case '\r':  //enter
+                inbuf.buf[inbuf.count]=0;
+                inbuf.lastcount = inbuf.count;
+                inbuf.count = 0;
+                entered = 1;
+                break;
+            case '\b': //backspace
+                if (inbuf.count > 0) {
+                    inbuf.count -= 1;
+                    CDC_print("\b \b\0");
+                }
+                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;
+                }
+                else
+                    CDC_print("\a\0");
+            }
+            break;
+        }
+        RXChar = 0;
+    }
+    return entered;
+}
+
+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;
+    cdc_tx_send_time_next = CLK_get_ms() + CDC_SEND_INTERVAL;
+}
+
+#else //CDC line 62
+
+char printbuf[CDC_PRINTBUF_SIZE];
+
+void CDC_send(void)
+{
+    return;
+}
+
+uint32_t CDC_print(char *printbuf)
+{
+    return 0;
+}
+
+int dpf(const char *_Format, ...)
+{
+    return 0;
+}
+
+inbuf_t inbuf;
+
+uint32_t CDC_input(void)
+{
+    return 0;
+}
+
+void CDC_init(void)
+{
+    inbuf.count = 0;
+    inbuf.lastcount = 0;
+    printbuf[0]=0;
+}
+
+char printbuf[CDC_PRINTBUF_SIZE];
+
+#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
new file mode 100644
index 000000000..6b70e96d0
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/usb/udi_cdc.h
@@ -0,0 +1,381 @@
+/**
+ * \file
+ *
+ * \brief USB Device Communication Device Class (CDC) interface definitions.
+ *
+ * Copyright (c) 2009-2016 Atmel Corporation. All rights reserved.
+ *
+ * \asf_license_start
+ *
+ * \page License
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. The name of Atmel may not be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * 4. This software may only be redistributed and used in connection with an
+ *    Atmel microcontroller product.
+ *
+ * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
+ * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * \asf_license_stop
+ *
+ */
+/*
+ * Support and FAQ: visit <a href="http://www.atmel.com/design-support/">Atmel Support</a>
+ */
+
+#ifndef _UDI_CDC_H_
+#define _UDI_CDC_H_
+
+#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"
+
+// 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
+extern "C" {
+#endif
+
+/**
+ * \addtogroup udi_cdc_group_udc
+ * @{
+ */
+
+//! Global structure which contains standard UDI API for UDC
+extern UDC_DESC_STORAGE udi_api_t udi_api_cdc_comm;
+extern UDC_DESC_STORAGE udi_api_t udi_api_cdc_data;
+//@}
+
+//#define CDC_ACM_SIZE  64  see usb_protocol_cdc.h
+//#define CDC_RX_SIZE   64
+
+//! CDC communication endpoints size for all speeds
+#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 CDC_PRINT_BUF_SIZE  256
+extern char printbuf[CDC_PRINT_BUF_SIZE];
+
+//@}
+
+/**
+ * \ingroup udi_group
+ * \defgroup udi_cdc_group USB Device Interface (UDI) for Communication Class Device (CDC)
+ *
+ * Common APIs used by high level application to use this USB class.
+ *
+ * These routines are used to transfer and control data
+ * to/from USB CDC endpoint.
+ *
+ * See \ref udi_cdc_quickstart.
+ * @{
+ */
+
+/**
+ * \name Interface for application with single CDC interface support
+ */
+//@{
+
+/**
+ * \brief Notify a state change of DCD signal
+ *
+ * \param b_set      DCD is enabled if true, else disabled
+ */
+void udi_cdc_ctrl_signal_dcd(bool b_set);
+
+/**
+ * \brief Notify a state change of DSR signal
+ *
+ * \param b_set      DSR is enabled if true, else disabled
+ */
+void udi_cdc_ctrl_signal_dsr(bool b_set);
+
+/**
+ * \brief Notify a framing error
+ */
+void udi_cdc_signal_framing_error(void);
+
+/**
+ * \brief Notify a parity error
+ */
+void udi_cdc_signal_parity_error(void);
+
+/**
+ * \brief Notify a overrun
+ */
+void udi_cdc_signal_overrun(void);
+
+/**
+ * \brief Gets the number of byte received
+ *
+ * \return the number of data available
+ */
+iram_size_t udi_cdc_get_nb_received_data(void);
+
+/**
+ * \brief This function checks if a character has been received on the CDC line
+ *
+ * \return \c 1 if a byte is ready to be read.
+ */
+bool udi_cdc_is_rx_ready(void);
+
+/**
+ * \brief Waits and gets a value on CDC line
+ *
+ * \return value read on CDC line
+ */
+int udi_cdc_getc(void);
+
+/**
+ * \brief Reads a RAM buffer on CDC line
+ *
+ * \param buf       Values read
+ * \param size      Number of value read
+ *
+ * \return the number of data remaining
+ */
+iram_size_t udi_cdc_read_buf(void* buf, iram_size_t size);
+
+/**
+ * \brief Non polling reads of a up to 'size' data from CDC line
+ *
+ * \param port      Communication port number to manage
+ * \param buf       Buffer where to store read data
+ * \param size      Maximum number of data to read (size of buffer)
+ *
+ * \return the number of data effectively read
+ */
+iram_size_t udi_cdc_read_no_polling(void* buf, iram_size_t size);
+
+/**
+ * \brief Gets the number of free byte in TX buffer
+ *
+ * \return the number of free byte in TX buffer
+ */
+iram_size_t udi_cdc_get_free_tx_buffer(void);
+
+/**
+ * \brief This function checks if a new character sent is possible
+ * The type int is used to support scanf redirection from compiler LIB.
+ *
+ * \return \c 1 if a new character can be sent
+ */
+bool udi_cdc_is_tx_ready(void);
+
+/**
+ * \brief Puts a byte on CDC line
+ * The type int is used to support printf redirection from compiler LIB.
+ *
+ * \param value      Value to put
+ *
+ * \return \c 1 if function was successfully done, otherwise \c 0.
+ */
+int udi_cdc_putc(int value);
+
+/**
+ * \brief Writes a RAM buffer on CDC line
+ *
+ * \param buf       Values to write
+ * \param size      Number of value to write
+ *
+ * \return the number of data remaining
+ */
+iram_size_t udi_cdc_write_buf(const void* buf, iram_size_t size);
+//@}
+
+/**
+ * \name Interface for application with multi CDC interfaces support
+ */
+//@{
+
+/**
+ * \brief Notify a state change of DCD signal
+ *
+ * \param port       Communication port number to manage
+ * \param b_set      DCD is enabled if true, else disabled
+ */
+void udi_cdc_multi_ctrl_signal_dcd(uint8_t port, bool b_set);
+
+/**
+ * \brief Notify a state change of DSR signal
+ *
+ * \param port       Communication port number to manage
+ * \param b_set      DSR is enabled if true, else disabled
+ */
+void udi_cdc_multi_ctrl_signal_dsr(uint8_t port, bool b_set);
+
+/**
+ * \brief Notify a framing error
+ *
+ * \param port       Communication port number to manage
+ */
+void udi_cdc_multi_signal_framing_error(uint8_t port);
+
+/**
+ * \brief Notify a parity error
+ *
+ * \param port       Communication port number to manage
+ */
+void udi_cdc_multi_signal_parity_error(uint8_t port);
+
+/**
+ * \brief Notify a overrun
+ *
+ * \param port       Communication port number to manage
+ */
+void udi_cdc_multi_signal_overrun(uint8_t port);
+
+/**
+ * \brief Gets the number of byte received
+ *
+ * \param port       Communication port number to manage
+ *
+ * \return the number of data available
+ */
+iram_size_t udi_cdc_multi_get_nb_received_data(uint8_t port);
+
+/**
+ * \brief This function checks if a character has been received on the CDC line
+ *
+ * \param port       Communication port number to manage
+ *
+ * \return \c 1 if a byte is ready to be read.
+ */
+bool udi_cdc_multi_is_rx_ready(uint8_t port);
+
+/**
+ * \brief Waits and gets a value on CDC line
+ *
+ * \param port       Communication port number to manage
+ *
+ * \return value read on CDC line
+ */
+int udi_cdc_multi_getc(uint8_t port);
+
+/**
+ * \brief Reads a RAM buffer on CDC line
+ *
+ * \param port       Communication port number to manage
+ * \param buf       Values read
+ * \param size      Number of values read
+ *
+ * \return the number of data remaining
+ */
+iram_size_t udi_cdc_multi_read_buf(uint8_t port, void* buf, iram_size_t size);
+
+/**
+ * \brief Gets the number of free byte in TX buffer
+ *
+ * \param port       Communication port number to manage
+ *
+ * \return the number of free byte in TX buffer
+ */
+iram_size_t udi_cdc_multi_get_free_tx_buffer(uint8_t port);
+
+/**
+ * \brief This function checks if a new character sent is possible
+ * The type int is used to support scanf redirection from compiler LIB.
+ *
+ * \param port       Communication port number to manage
+ *
+ * \return \c 1 if a new character can be sent
+ */
+bool udi_cdc_multi_is_tx_ready(uint8_t port);
+
+/**
+ * \brief Puts a byte on CDC line
+ * The type int is used to support printf redirection from compiler LIB.
+ *
+ * \param port       Communication port number to manage
+ * \param value      Value to put
+ *
+ * \return \c 1 if function was successfully done, otherwise \c 0.
+ */
+int udi_cdc_multi_putc(uint8_t port, int value);
+
+/**
+ * \brief Writes a RAM buffer on CDC line
+ *
+ * \param port       Communication port number to manage
+ * \param buf       Values to write
+ * \param size      Number of value to write
+ *
+ * \return the number of data remaining
+ */
+iram_size_t udi_cdc_multi_write_buf(uint8_t port, const void* buf, iram_size_t size);
+//@}
+
+#define CDC_PRINTBUF_SIZE  256
+extern char printbuf[CDC_PRINTBUF_SIZE];
+
+#define CDC_INBUF_SIZE 256
+
+typedef struct {
+    uint32_t count;
+    uint32_t lastcount;
+    char buf[CDC_INBUF_SIZE];
+} inbuf_t;
+
+#else //CDC
+
+// keep these to accommodate calls if remaining
+#define CDC_PRINTBUF_SIZE  1
+extern char printbuf[CDC_PRINTBUF_SIZE];
+
+#define CDC_INBUF_SIZE 1
+
+typedef struct {
+    uint32_t count;
+    uint32_t lastcount;
+    char buf[CDC_INBUF_SIZE];
+} inbuf_t;
+
+extern inbuf_t inbuf;
+
+#endif //CDC
+
+uint32_t CDC_print(char *printbuf);
+uint32_t CDC_input(void);
+void CDC_init(void);
+
+#define __xprintf dpf
+int dpf(const char *_Format, ...);
+
+#ifdef __cplusplus
+}
+#endif
+
+#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
new file mode 100644
index 000000000..2db61fab5
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/usb/udi_cdc_conf.h
@@ -0,0 +1,72 @@
+/**
+ * \file
+ *
+ * \brief Default CDC configuration for a USB Device with a single interface
+ *
+ * Copyright (c) 2009-2015 Atmel Corporation. All rights reserved.
+ *
+ * \asf_license_start
+ *
+ * \page License
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. The name of Atmel may not be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * 4. This software may only be redistributed and used in connection with an
+ *    Atmel microcontroller product.
+ *
+ * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
+ * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * \asf_license_stop
+ *
+ */
+/*
+ * Support and FAQ: visit <a href="http://www.atmel.com/design-support/">Atmel Support</a>
+ */
+
+#ifndef _UDI_CDC_CONF_H_
+#define _UDI_CDC_CONF_H_
+
+#include "usb_protocol_cdc.h"
+#include "conf_usb.h"
+#include "udi_device_conf.h"
+
+#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_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_
diff --git a/tmk_core/protocol/arm_atsam/usb/udi_device_conf.h b/tmk_core/protocol/arm_atsam/usb/udi_device_conf.h
new file mode 100644
index 000000000..c78726234
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/usb/udi_device_conf.h
@@ -0,0 +1,715 @@
+/*
+Copyright 2018 Massdrop Inc.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _UDI_DEVICE_CONF_H_
+#define _UDI_DEVICE_CONF_H_
+
+#include "udi_device_epsize.h"
+#include "usb_protocol.h"
+#include "compiler.h"
+#include "usb_protocol_hid.h"
+
+#define DEVICE_CLASS 0
+#define DEVICE_SUBCLASS 0
+#define DEVICE_PROTOCOL 0
+
+#define KBD
+
+//#define MOUSE_ENABLE //rules.mk
+#ifdef MOUSE_ENABLE
+#define MOU
+#endif
+
+//#define EXTRAKEY_ENABLE //rules.mk
+#ifdef EXTRAKEY_ENABLE
+#define EXK
+#endif
+
+//#define RAW_ENABLE //rules.mk
+#ifdef RAW_ENABLE
+#define RAW
+#endif
+
+//#define CONSOLE_ENABLE //deferred implementation
+//#ifdef CONSOLE_ENABLE
+//#define CON
+//#endif
+
+//#define NKRO_ENABLE //rules.mk
+#ifdef NKRO_ENABLE
+#define NKRO
+#endif
+
+//#define MIDI_ENABLE //deferred implementation
+//#ifdef MIDI_ENABLE
+//#define MIDI
+//#endif
+
+//#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
+#endif
+
+/* number of interfaces */
+#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
+#else
+#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)
+#else
+#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)
+#else
+#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
+#else
+#define NEXT_INTERFACE_4            NEXT_INTERFACE_3
+#endif
+
+#ifdef CON
+#define CONSOLE_INTERFACE           NEXT_INTERFACE_4
+#define NEXT_INTERFACE_5            (CONSOLE_INTERFACE + 1)
+#else
+#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
+#else
+#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)
+#else
+#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
+#else
+#define NEXT_INTERFACE_8            NEXT_INTERFACE_7
+#endif
+
+/* nubmer of 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 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
+#else
+#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
+#else
+#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
+#else
+#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
+#else
+#define NEXT_IN_EPNUM_4             NEXT_IN_EPNUM_3
+#define NEXT_OUT_EPNUM_1            NEXT_OUT_EPNUM_0
+#endif
+
+#ifdef CON
+#define CONSOLE_IN_EPNUM            NEXT_IN_EPNUM_4
+#define NEXT_IN_EPNUM_5             (CONSOLE_IN_EPNUM + 1)
+#define CONSOLE_OUT_EPNUM           NEXT_OUT_EPNUM_1
+#define NEXT_OUT_EPNUM_2            (CONSOLE_OUT_EPNUM + 1)
+#define CONSOLE_POLLING_INTERVAL    1
+#else
+#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
+#else
+#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
+#else
+#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"
+#else
+#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))
+
+#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)"
+#endif
+
+
+// **********************************************************************
+// KBD Descriptor structure and content
+// **********************************************************************
+#ifdef KBD
+
+COMPILER_PACK_SET(1)
+
+typedef struct {
+    usb_iface_desc_t iface;
+    usb_hid_descriptor_t hid;
+    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)
+extern uint8_t udi_hid_kbd_report_set;
+
+//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
+
+// **********************************************************************
+// EXK Descriptor structure and content
+// **********************************************************************
+#ifdef EXK
+
+COMPILER_PACK_SET(1)
+
+typedef struct {
+    usb_iface_desc_t iface;
+    usb_hid_descriptor_t hid;
+    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)
+extern uint8_t udi_hid_exk_report_set;
+
+//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];
+} udi_hid_exk_report_t;
+
+extern udi_hid_exk_report_t udi_hid_exk_report;
+
+COMPILER_PACK_RESET()
+
+#endif //EXK
+
+// **********************************************************************
+// NKRO Descriptor structure and content
+// **********************************************************************
+#ifdef NKRO
+
+COMPILER_PACK_SET(1)
+
+typedef struct {
+    usb_iface_desc_t iface;
+    usb_hid_descriptor_t hid;
+    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
+extern uint8_t udi_hid_nkro_report_set;
+
+//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
+
+// **********************************************************************
+// MOU Descriptor structure and content
+// **********************************************************************
+#ifdef MOU
+
+COMPILER_PACK_SET(1)
+
+typedef struct {
+    usb_iface_desc_t iface;
+    usb_hid_descriptor_t hid;
+    usb_ep_desc_t ep;
+} udi_hid_mou_desc_t;
+
+typedef struct {
+    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
+extern uint8_t udi_hid_mou_report[UDI_HID_MOU_REPORT_SIZE];
+
+COMPILER_PACK_RESET()
+
+#endif //MOU
+
+// **********************************************************************
+// RAW Descriptor structure and content
+// **********************************************************************
+#ifdef RAW
+
+COMPILER_PACK_SET(1)
+
+typedef struct {
+    usb_iface_desc_t iface;
+    usb_hid_descriptor_t hid;
+    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
+
+extern uint8_t udi_hid_raw_report_set[UDI_HID_RAW_REPORT_SIZE];
+
+//report buffer
+extern uint8_t udi_hid_raw_report[UDI_HID_RAW_REPORT_SIZE];
+
+COMPILER_PACK_RESET()
+
+#endif //RAW
+
+// **********************************************************************
+// CDC Descriptor structure and content
+// **********************************************************************
+#ifdef CDC
+
+COMPILER_PACK_SET(1)
+
+typedef struct {
+    uint8_t bFunctionLength;
+    uint8_t bDescriptorType;
+    uint8_t bDescriptorSubtype;
+    le16_t  bcdCDC;
+} usb_cdc_hdr_desc_t;
+
+typedef struct {
+    uint8_t bFunctionLength;
+    uint8_t bDescriptorType;
+    uint8_t bDescriptorSubtype;
+    uint8_t bmCapabilities;
+    uint8_t bDataInterface;
+} usb_cdc_call_mgmt_desc_t;
+
+typedef struct {
+    uint8_t bFunctionLength;
+    uint8_t bDescriptorType;
+    uint8_t bDescriptorSubtype;
+    uint8_t bmCapabilities;
+} usb_cdc_acm_desc_t;
+
+typedef struct {
+    uint8_t bFunctionLength;
+    uint8_t bDescriptorType;
+    uint8_t bDescriptorSubtype;
+    uint8_t bMasterInterface;
+    uint8_t bSlaveInterface0;
+} 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_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;
+} 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,\
+}
+
+COMPILER_PACK_RESET()
+
+#endif //CDC
+
+// **********************************************************************
+// CONFIGURATION Descriptor structure and content
+// **********************************************************************
+COMPILER_PACK_SET(1)
+
+typedef struct {
+    usb_conf_desc_t conf;
+#ifdef KBD
+    udi_hid_kbd_desc_t hid_kbd;
+#endif
+#ifdef MOU
+    udi_hid_mou_desc_t hid_mou;
+#endif
+#ifdef EXK
+    udi_hid_exk_desc_t hid_exk;
+#endif
+#ifdef RAW
+    udi_hid_raw_desc_t hid_raw;
+#endif
+#ifdef CON
+    udi_hid_con_desc_t hid_con;
+#endif
+#ifdef NKRO
+    udi_hid_nkro_desc_t hid_nkro;
+#endif
+#ifdef MIDI
+    udi_hid_midi_desc_t hid_midi;
+#endif
+#ifdef CDC
+    udi_cdc_desc_t cdc_serial;
+#endif
+} udc_desc_t;
+
+COMPILER_PACK_RESET()
+
+#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
new file mode 100644
index 000000000..96d03c286
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/usb/udi_device_epsize.h
@@ -0,0 +1,32 @@
+/*
+Copyright 2018 Massdrop Inc.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+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_
+
diff --git a/tmk_core/protocol/arm_atsam/usb/udi_hid.c b/tmk_core/protocol/arm_atsam/usb/udi_hid.c
new file mode 100644
index 000000000..131b7a0ec
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/usb/udi_hid.c
@@ -0,0 +1,162 @@
+/**
+ * \file
+ *
+ * \brief USB Device Human Interface Device (HID) interface.
+ *
+ * Copyright (c) 2009-2015 Atmel Corporation. All rights reserved.
+ *
+ * \asf_license_start
+ *
+ * \page License
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. The name of Atmel may not be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * 4. This software may only be redistributed and used in connection with an
+ *    Atmel microcontroller product.
+ *
+ * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
+ * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * \asf_license_stop
+ *
+ */
+/*
+ * Support and FAQ: visit <a href="http://www.atmel.com/design-support/">Atmel Support</a>
+ */
+
+#include "conf_usb.h"
+#include "usb_protocol.h"
+#include "udd.h"
+#include "udc.h"
+#include "udi_hid.h"
+
+
+/**
+ * \ingroup udi_hid_group
+ * \defgroup udi_hid_group_internal Implementation of HID common library
+ * @{
+ */
+
+/**
+ * \brief Send the specific descriptors requested by SETUP request
+ *
+ * \retval true if the descriptor is supported
+ */
+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) )
+{
+    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);
+            }
+        }
+        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;
+            }
+        }
+    }
+    if (Udd_setup_is_out()) {
+        // Requests Interface SET
+        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_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;
+            }
+        }
+    }
+    return false;   // Request not supported
+}
+
+//---------------------------------------------
+//------- Internal routines
+
+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;
+
+    // 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)) {
+        // 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);
+        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)) {
+        // 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));
+        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
new file mode 100644
index 000000000..0edb09c1c
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/usb/udi_hid.h
@@ -0,0 +1,85 @@
+/**
+ * \file
+ *
+ * \brief USB Device Human Interface Device (HID) interface definitions.
+ *
+ * Copyright (c) 2009-2015 Atmel Corporation. All rights reserved.
+ *
+ * \asf_license_start
+ *
+ * \page License
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. The name of Atmel may not be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * 4. This software may only be redistributed and used in connection with an
+ *    Atmel microcontroller product.
+ *
+ * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
+ * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * \asf_license_stop
+ *
+ */
+/*
+ * Support and FAQ: visit <a href="http://www.atmel.com/design-support/">Atmel Support</a>
+ */
+
+#ifndef _UDI_HID_H_
+#define _UDI_HID_H_
+
+#include "conf_usb.h"
+#include "usb_protocol.h"
+#include "usb_protocol_hid.h"
+#include "udd.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * \ingroup udi_group
+ * \defgroup udi_hid_group USB Device Interface (UDI) for Human Interface Device (HID)
+ *
+ * Common library for all Human Interface Device (HID) implementation.
+ *
+ * @{
+ */
+
+/**
+ * \brief Decode HID setup request
+ *
+ * \param rate         Pointer on rate of current HID interface
+ * \param protocol     Pointer on protocol of current HID interface
+ * \param report_desc  Pointer on report descriptor of current HID interface
+ * \param set_report   Pointer on set_report callback of current HID interface
+ *
+ * \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) );
+
+//@}
+
+#ifdef __cplusplus
+}
+#endif
+#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
new file mode 100644
index 000000000..18f69350c
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/usb/udi_hid_kbd.c
@@ -0,0 +1,845 @@
+/**
+ * \file
+ *
+ * \brief USB Device Human Interface Device (HID) keyboard interface.
+ *
+ * Copyright (c) 2009-2015 Atmel Corporation. All rights reserved.
+ *
+ * \asf_license_start
+ *
+ * \page License
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. The name of Atmel may not be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * 4. This software may only be redistributed and used in connection with an
+ *    Atmel microcontroller product.
+ *
+ * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
+ * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * \asf_license_stop
+ *
+ */
+/*
+ * Support and FAQ: visit <a href="http://www.atmel.com/design-support/">Atmel Support</a>
+ */
+
+#include "samd51j18a.h"
+#include "conf_usb.h"
+#include "usb_protocol.h"
+#include "udd.h"
+#include "udc.h"
+#include "udi_device_conf.h"
+#include "udi_hid.h"
+#include "udi_hid_kbd.h"
+#include <string.h>
+
+//***************************************************************************
+// KBD
+//***************************************************************************
+#ifdef KBD
+
+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,
+    .getsetting = (uint8_t(*)(void))udi_hid_kbd_getsetting,
+    .sof_notify = NULL,
+};
+
+COMPILER_WORD_ALIGNED
+static uint8_t udi_hid_kbd_rate;
+
+COMPILER_WORD_ALIGNED
+static uint8_t udi_hid_kbd_protocol;
+
+COMPILER_WORD_ALIGNED
+uint8_t udi_hid_kbd_report_set;
+
+bool udi_hid_kbd_b_report_valid;
+
+COMPILER_WORD_ALIGNED
+uint8_t udi_hid_kbd_report[UDI_HID_KBD_REPORT_SIZE];
+
+static bool udi_hid_kbd_b_report_trans_ongoing;
+
+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, 0x65,     //   Usage Maximum (101)
+        0x15, 0x00,     //   Logical Minimum (0)
+        0x25, 0x65,     //   Logical Maximum (101)
+        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);
+
+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_setreport_valid(void);
+
+bool udi_hid_kbd_enable(void)
+{
+    // Initialize internal values
+    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();
+}
+
+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;
+}
+
+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_size = 1;
+        return true;
+    }
+    return false;
+}
+
+bool udi_hid_kbd_send_report(void)
+{
+    if (!main_b_kbd_enable) {
+        return false;
+    }
+
+    if (udi_hid_kbd_b_report_trans_ongoing) {
+        return false;
+    }
+
+    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);
+
+    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)
+{
+    UNUSED(status);
+    UNUSED(nb_sent);
+    UNUSED(ep);
+    udi_hid_kbd_b_report_trans_ongoing = false;
+    if (udi_hid_kbd_b_report_valid) {
+        udi_hid_kbd_send_report();
+    }
+}
+
+static void udi_hid_kbd_setreport_valid(void)
+{
+    //UDI_HID_KBD_CHANGE_LED(udi_hid_kbd_report_set);
+}
+
+#endif //KBD
+
+//********************************************************************************************
+// NKRO Keyboard
+//********************************************************************************************
+#ifdef NKRO
+
+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,
+    .getsetting = (uint8_t(*)(void))udi_hid_nkro_getsetting,
+    .sof_notify = NULL,
+};
+
+COMPILER_WORD_ALIGNED
+static uint8_t udi_hid_nkro_rate;
+
+COMPILER_WORD_ALIGNED
+static uint8_t udi_hid_nkro_protocol;
+
+COMPILER_WORD_ALIGNED
+uint8_t udi_hid_nkro_report_set;
+
+bool udi_hid_nkro_b_report_valid;
+
+COMPILER_WORD_ALIGNED
+uint8_t udi_hid_nkro_report[UDI_HID_NKRO_REPORT_SIZE];
+
+static bool udi_hid_nkro_b_report_trans_ongoing;
+
+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
+    }
+};
+
+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)
+{
+    // Initialize internal values
+    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();
+}
+
+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;
+}
+
+//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_size = 1;
+        return true;
+    }
+    return false;
+}
+
+bool udi_hid_nkro_send_report(void)
+{
+    if (!main_b_nkro_enable) {
+        return false;
+    }
+
+    if (udi_hid_nkro_b_report_trans_ongoing) {
+        return false;
+    }
+
+    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);
+
+    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)
+{
+    UNUSED(status);
+    UNUSED(nb_sent);
+    UNUSED(ep);
+    udi_hid_nkro_b_report_trans_ongoing = false;
+    if (udi_hid_nkro_b_report_valid) {
+        udi_hid_nkro_send_report();
+    }
+}
+
+static void udi_hid_nkro_setreport_valid(void)
+{
+    //UDI_HID_NKRO_CHANGE_LED(udi_hid_nkro_report_set);
+}
+
+#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);
+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,
+    .getsetting = (uint8_t(*)(void))udi_hid_exk_getsetting,
+    .sof_notify = NULL,
+};
+
+COMPILER_WORD_ALIGNED
+static uint8_t udi_hid_exk_rate;
+
+COMPILER_WORD_ALIGNED
+static uint8_t udi_hid_exk_protocol;
+
+COMPILER_WORD_ALIGNED
+uint8_t udi_hid_exk_report_set;
+
+bool udi_hid_exk_b_report_valid;
+
+COMPILER_WORD_ALIGNED
+udi_hid_exk_report_t udi_hid_exk_report;
+
+static bool udi_hid_exk_b_report_trans_ongoing;
+
+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, 0x02,         //   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, 0x03,         //   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);
+
+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_setreport_valid(void);
+
+bool udi_hid_exk_enable(void)
+{
+    // Initialize internal values
+    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();
+}
+
+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;
+}
+
+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_size = 1;
+        return true;
+    }
+    return false;
+}
+
+bool udi_hid_exk_send_report(void)
+{
+    if (!main_b_exk_enable) {
+        return false;
+    }
+
+    if (udi_hid_exk_b_report_trans_ongoing) {
+        return false;
+    }
+
+    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);
+
+    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)
+{
+    UNUSED(status);
+    UNUSED(nb_sent);
+    UNUSED(ep);
+    udi_hid_exk_b_report_trans_ongoing = false;
+    if (udi_hid_exk_b_report_valid) {
+        udi_hid_exk_send_report();
+    }
+}
+
+static void udi_hid_exk_setreport_valid(void)
+{
+
+}
+
+#endif //EXK
+
+//********************************************************************************************
+// MOU Mouse
+//********************************************************************************************
+#ifdef MOU
+
+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,
+    .getsetting = (uint8_t(*)(void))udi_hid_mou_getsetting,
+    .sof_notify = NULL,
+};
+
+COMPILER_WORD_ALIGNED
+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
+
+bool udi_hid_mou_b_report_valid;
+
+COMPILER_WORD_ALIGNED
+uint8_t udi_hid_mou_report[UDI_HID_MOU_REPORT_SIZE];
+
+static bool udi_hid_mou_b_report_trans_ongoing;
+
+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
+    }
+};
+
+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)
+{
+    // Initialize internal values
+    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();
+}
+
+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;
+}
+
+bool udi_hid_mou_send_report(void)
+{
+    if (!main_b_mou_enable) {
+        return false;
+    }
+
+    if (udi_hid_mou_b_report_trans_ongoing) {
+        return false;
+    }
+
+    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);
+
+    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)
+{
+    UNUSED(status);
+    UNUSED(nb_sent);
+    UNUSED(ep);
+    udi_hid_mou_b_report_trans_ongoing = false;
+    if (udi_hid_mou_b_report_valid) {
+        udi_hid_mou_send_report();
+    }
+}
+
+#endif //MOU
+
+//********************************************************************************************
+// RAW
+//********************************************************************************************
+#ifdef RAW
+
+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,
+    .getsetting = (uint8_t(*)(void))udi_hid_raw_getsetting,
+    .sof_notify = NULL,
+};
+
+COMPILER_WORD_ALIGNED
+static uint8_t udi_hid_raw_rate;
+
+COMPILER_WORD_ALIGNED
+static uint8_t udi_hid_raw_protocol;
+
+COMPILER_WORD_ALIGNED
+uint8_t udi_hid_raw_report_set[UDI_HID_RAW_REPORT_SIZE];
+
+static bool udi_hid_raw_b_report_valid;
+
+COMPILER_WORD_ALIGNED
+uint8_t udi_hid_raw_report[UDI_HID_RAW_REPORT_SIZE];
+
+static bool udi_hid_raw_b_report_trans_ongoing;
+
+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
+    }
+};
+
+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)
+{
+    // Initialize internal values
+    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();
+}
+
+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;
+}
+
+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_size = UDI_HID_RAW_REPORT_SIZE;
+        return true;
+    }
+    return false;
+}
+
+bool udi_hid_raw_send_report(void)
+{
+    if (!main_b_raw_enable) {
+        return false;
+    }
+
+    if (udi_hid_raw_b_report_trans_ongoing) {
+        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);
+
+    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)
+{
+    UNUSED(status);
+    UNUSED(nb_sent);
+    UNUSED(ep);
+    udi_hid_raw_b_report_trans_ongoing = false;
+    if (udi_hid_raw_b_report_valid) {
+        udi_hid_raw_send_report();
+    }
+}
+
+static void udi_hid_raw_setreport_valid(void)
+{
+
+}
+
+#endif //RAW
diff --git a/tmk_core/protocol/arm_atsam/usb/udi_hid_kbd.h b/tmk_core/protocol/arm_atsam/usb/udi_hid_kbd.h
new file mode 100644
index 000000000..9a2741534
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/usb/udi_hid_kbd.h
@@ -0,0 +1,109 @@
+/**
+ * \file
+ *
+ * \brief USB Device Human Interface Device (HID) keyboard interface.
+ *
+ * Copyright (c) 2009-2015 Atmel Corporation. All rights reserved.
+ *
+ * \asf_license_start
+ *
+ * \page License
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. The name of Atmel may not be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * 4. This software may only be redistributed and used in connection with an
+ *    Atmel microcontroller product.
+ *
+ * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
+ * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * \asf_license_stop
+ *
+ */
+/*
+ * Support and FAQ: visit <a href="http://www.atmel.com/design-support/">Atmel Support</a>
+ */
+
+#ifndef _UDC_HID_KBD_H_
+#define _UDC_HID_KBD_H_
+
+#include "udc_desc.h"
+#include "udi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+//******************************************************************************
+// Keyboard interface definitions
+//******************************************************************************
+#ifdef KBD
+extern UDC_DESC_STORAGE udi_api_t udi_api_hid_kbd;
+extern bool udi_hid_kbd_b_report_valid;
+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;
+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
+
+//********************************************************************************************
+// 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
+
+//********************************************************************************************
+// RAW Raw
+//********************************************************************************************
+#ifdef RAW
+extern UDC_DESC_STORAGE udi_api_t udi_api_hid_raw;
+bool udi_hid_raw_send_report(void);
+#endif //RAW
+
+//@}
+
+#ifdef __cplusplus
+}
+#endif
+
+#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
new file mode 100644
index 000000000..db5db17ed
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/usb/udi_hid_kbd_conf.h
@@ -0,0 +1,60 @@
+/**
+ * \file
+ *
+ * \brief Default HID keyboard configuration for a USB Device
+ * with a single interface HID keyboard
+ *
+ * Copyright (c) 2009-2015 Atmel Corporation. All rights reserved.
+ *
+ * \asf_license_start
+ *
+ * \page License
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. The name of Atmel may not be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * 4. This software may only be redistributed and used in connection with an
+ *    Atmel microcontroller product.
+ *
+ * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
+ * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * \asf_license_stop
+ *
+ */
+/*
+ * Support and FAQ: visit <a href="http://www.atmel.com/design-support/">Atmel Support</a>
+ */
+
+#ifndef _UDI_HID_KBD_CONF_H_
+#define _UDI_HID_KBD_CONF_H_
+
+/**
+ * \addtogroup udi_hid_keyboard_group_single_desc
+ * @{
+ */
+
+#include "udi_device_conf.h"
+
+#include "udi_hid_kbd.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
new file mode 100644
index 000000000..16bd4e514
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/usb/udi_hid_kbd_desc.c
@@ -0,0 +1,179 @@
+/**
+ * \file
+ *
+ * \brief Default descriptors for a USB Device
+ * with a single interface HID keyboard
+ *
+ * Copyright (c) 2009-2016 Atmel Corporation. All rights reserved.
+ *
+ * \asf_license_start
+ *
+ * \page License
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. The name of Atmel may not be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * 4. This software may only be redistributed and used in connection with an
+ *    Atmel microcontroller product.
+ *
+ * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
+ * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * \asf_license_stop
+ *
+ */
+/*
+ * Support and FAQ: visit <a href="http://www.atmel.com/design-support/">Atmel Support</a>
+ */
+
+#include "conf_usb.h"
+#include "usb_protocol.h"
+#include "udc_desc.h"
+#include "udi_device_conf.h"
+#include "udi_hid_kbd.h"
+#include "udi_cdc.h"
+
+/**
+ * \ingroup udi_hid_keyboard_group
+ * \defgroup udi_hid_keyboard_group_single_desc USB device descriptors for a single interface
+ *
+ * The following structures provide the USB device descriptors required
+ * for USB Device with a single interface HID keyboard.
+ *
+ * It is ready to use and do not require more definition.
+ * @{
+ */
+
+//! 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),
+#ifdef USB_DEVICE_MANUFACTURE_NAME
+    .iManufacturer             = 1,
+#else
+    .iManufacturer             = 0,  // No manufacture string
+#endif
+#ifdef USB_DEVICE_PRODUCT_NAME
+    .iProduct                  = 2,
+#else
+    .iProduct                  = 0,  // No product string
+#endif
+#if (defined USB_DEVICE_SERIAL_NAME || defined USB_DEVICE_GET_SERIAL_NAME_POINTER)
+    .iSerialNumber             = 3,
+#else
+    .iSerialNumber             = 0,  // No serial string
+#endif
+    .bNumConfigurations        = 1
+};
+
+#if 0
+#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 = {
+    .bLength                   = sizeof(usb_dev_qual_desc_t),
+    .bDescriptorType           = USB_DT_DEVICE_QUALIFIER,
+    .bcdUSB                    = LE16(USB_V2_0),
+    .bDeviceClass              = 0,
+    .bDeviceSubClass           = 0,
+    .bDeviceProtocol           = 0,
+    .bMaxPacketSize0           = USB_DEVICE_EP_CTRL_SIZE,
+    .bNumConfigurations        = 1
+};
+#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),
+#ifdef KBD
+    .hid_kbd                   = UDI_HID_KBD_DESC,
+#endif
+#ifdef RAW
+    .hid_raw                   = UDI_HID_RAW_DESC,
+#endif
+#ifdef MOU
+    .hid_mou                   = UDI_HID_MOU_DESC,
+#endif
+#ifdef EXK
+  .hid_exk                   = UDI_HID_EXK_DESC,
+#endif
+#ifdef NKRO
+  .hid_nkro                  = UDI_HID_NKRO_DESC,
+#endif
+#ifdef CDC
+  .cdc_serial                = CDC_DESCRIPTOR,
+#endif
+};
+
+UDC_DESC_STORAGE udi_api_t *udi_apis[USB_DEVICE_NB_INTERFACE] = {
+  #ifdef KBD
+    &udi_api_hid_kbd,
+  #endif
+  #ifdef RAW
+    &udi_api_hid_raw,
+  #endif
+  #ifdef MOU
+    &udi_api_hid_mou,
+  #endif
+  #ifdef EXK
+    &udi_api_hid_exk,
+  #endif
+  #ifdef NKRO
+    &udi_api_hid_nkro,
+  #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,
+}};
+
+//! 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,
+};
+
+//@}
+//@}
diff --git a/tmk_core/protocol/arm_atsam/usb/ui.c b/tmk_core/protocol/arm_atsam/usb/ui.c
new file mode 100644
index 000000000..031678b64
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/usb/ui.c
@@ -0,0 +1,106 @@
+/**
+ * \file
+ *
+ * \brief User Interface
+ *
+ * Copyright (c) 2014-2015 Atmel Corporation. All rights reserved.
+ *
+ * \asf_license_start
+ *
+ * \page License
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. The name of Atmel may not be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * 4. This software may only be redistributed and used in connection with an
+ *    Atmel microcontroller product.
+ *
+ * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
+ * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * \asf_license_stop
+ *
+ */
+/*
+ * Support and FAQ: visit <a href="http://www.atmel.com/design-support/">Atmel Support</a>
+ */
+
+#ifndef ARM_MATH_CM4
+ #define ARM_MATH_CM4
+#endif
+
+#undef LITTLE_ENDIAN  //redefined in samd51j18a.h
+#include "samd51j18a.h"
+#include "ui.h"
+
+volatile uint8_t usb_state;
+
+//! Sequence process running each \c SEQUENCE_PERIOD ms
+#define SEQUENCE_PERIOD 150
+
+#if 0
+/* Interrupt on "pin change" from push button to do wakeup on USB
+ * Note:
+ * This interrupt is enable when the USB host enable remote wakeup feature
+ * This interrupt wakeup the CPU if this one is in idle mode
+ */
+static void ui_wakeup_handler(void)
+{
+    /* It is a wakeup then send wakeup USB */
+    udc_remotewakeup();
+}
+#endif
+
+void ui_init(void)
+{
+    usb_state = USB_STATE_POWERUP;
+}
+
+void ui_powerdown(void)
+{
+    usb_state = USB_STATE_POWERDOWN;
+}
+
+void ui_wakeup_enable(void)
+{
+
+}
+
+void ui_wakeup_disable(void)
+{
+
+}
+
+void ui_wakeup(void)
+{
+    usb_state = USB_STATE_POWERUP;
+}
+
+void ui_process(uint16_t framenumber)
+{
+
+}
+
+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
new file mode 100644
index 000000000..3d899e669
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/usb/ui.h
@@ -0,0 +1,82 @@
+/**
+ * \file
+ *
+ * \brief Common User Interface for HID Keyboard application
+ *
+ * Copyright (c) 2009-2015 Atmel Corporation. All rights reserved.
+ *
+ * \asf_license_start
+ *
+ * \page License
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. The name of Atmel may not be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * 4. This software may only be redistributed and used in connection with an
+ *    Atmel microcontroller product.
+ *
+ * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
+ * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * \asf_license_stop
+ *
+ */
+/*
+ * Support and FAQ: visit <a href="http://www.atmel.com/design-support/">Atmel Support</a>
+ */
+
+#ifndef _UI_H_
+#define _UI_H_
+
+extern volatile uint8_t usb_state;
+
+#define USB_STATE_UNKNOWN 0
+#define USB_STATE_POWERDOWN 1
+#define USB_STATE_POWERUP 2
+
+//! \brief Initializes the user interface
+void ui_init(void);
+
+//! \brief Enters the user interface in power down mode
+void ui_powerdown(void);
+
+//! \brief Enables the asynchronous interrupts of the user interface
+void ui_wakeup_enable(void);
+
+//! \brief Disables the asynchronous interrupts of the user interface
+void ui_wakeup_disable(void);
+
+//! \brief Exits the user interface of power down mode
+void ui_wakeup(void);
+
+/*! \brief This process is called each 1ms
+ * It is called only if the USB interface is enabled.
+ *
+ * \param framenumber  Current frame number
+ */
+void ui_process(uint16_t framenumber);
+
+/*! \brief Turn on or off the keyboard LEDs
+ */
+void ui_kbd_led(uint8_t value);
+
+#endif // _UI_H_
diff --git a/tmk_core/protocol/arm_atsam/usb/usb.c b/tmk_core/protocol/arm_atsam/usb/usb.c
new file mode 100644
index 000000000..d30d76dd1
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/usb/usb.c
@@ -0,0 +1,1144 @@
+/**
+ * \file
+ *
+ * \brief SAM USB Driver.
+ *
+ * Copyright (C) 2014-2016 Atmel Corporation. All rights reserved.
+ *
+ * \asf_license_start
+ *
+ * \page License
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. The name of Atmel may not be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * 4. This software may only be redistributed and used in connection with an
+ *    Atmel microcontroller product.
+ *
+ * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
+ * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * \asf_license_stop
+ *
+ */
+/*
+ * Support and FAQ: visit <a href="http://www.atmel.com/design-support/">Atmel Support</a>
+ */
+
+#define DEVICE_MODE_ONLY true
+#define SAMD11 DEVICE_MODE_ONLY
+
+#ifndef ARM_MATH_CM4
+  #define ARM_MATH_CM4
+#endif
+
+#include "compiler.h"
+#undef LITTLE_ENDIAN  //redefined in samd51j18a.h
+#include "samd51j18a.h"
+#include <stdbool.h>
+#include <string.h>
+#include "arm_math.h"
+#include "status_codes.h"
+#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)
+
+/**
+ * \brief Mask selecting the index part of an endpoint address
+ */
+#define  USB_EP_ADDR_MASK     0x0f
+
+/**
+ * \brief Endpoint transfer direction is IN
+ */
+#define  USB_EP_DIR_IN        0x80
+
+/**
+ * \brief Endpoint transfer direction is OUT
+ */
+#define  USB_EP_DIR_OUT       0x00
+
+/**
+ * \name USB SRAM data containing pipe descriptor table
+ * The content of the USB SRAM can be :
+ * - modified by USB hardware interface to update pipe status.
+ *   Thereby, it is read by software.
+ * - modified by USB software to control pipe.
+ *   Thereby, it is read by hardware.
+ * This data section is volatile.
+ *
+ * @{
+ */
+COMPILER_PACK_SET(1)
+COMPILER_WORD_ALIGNED
+union {
+    UsbDeviceDescriptor usb_endpoint_table[USB_EPT_NUM];
+} usb_descriptor_table;
+COMPILER_PACK_RESET()
+/** @} */
+
+/**
+ * \brief Local USB module instance
+ */
+static struct usb_module *_usb_instances;
+
+/* Device LPM callback variable */
+static uint32_t device_callback_lpm_wakeup_enable;
+
+/**
+ * \brief Device endpoint callback parameter variable, used to transfer info to UDD wrapper layer
+ */
+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,
+};
+
+/**
+ * \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
+};
+
+/**
+ * \brief Registers a USB device callback
+ *
+ * Registers a callback function which is implemented by the user.
+ *
+ * \note The callback must be enabled by \ref usb_device_enable_callback,
+ * in order for the interrupt handler to call it when the conditions for the
+ * callback type is met.
+ *
+ * \param[in]     module_inst   Pointer to USB software instance struct
+ * \param[in]     callback_type Callback type given by an enum
+ * \param[in]     callback_func Pointer to callback function
+ *
+ * \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)
+{
+    /* Sanity check arguments */
+    Assert(module_inst);
+    Assert(callback_func);
+
+    /* Register callback function */
+    module_inst->device_callback[callback_type] = callback_func;
+
+    /* Set the bit corresponding to the callback_type */
+    module_inst->device_registered_callback_mask |= _usb_device_irq_bits[callback_type];
+
+    return STATUS_OK;
+}
+
+/**
+ * \brief Unregisters a USB device callback
+ *
+ * Unregisters an asynchronous callback implemented by the user. Removing it
+ * from the internal callback registration table.
+ *
+ * \param[in]     module_inst   Pointer to USB software instance struct
+ * \param[in]     callback_type Callback type given by an enum
+ *
+ * \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)
+{
+    /* Sanity check arguments */
+    Assert(module_inst);
+
+    /* Unregister callback function */
+    module_inst->device_callback[callback_type] = NULL;
+
+    /* Clear the bit corresponding to the callback_type */
+    module_inst->device_registered_callback_mask &= ~_usb_device_irq_bits[callback_type];
+
+    return STATUS_OK;
+}
+
+/**
+ * \brief Enables USB device callback generation for a given type.
+ *
+ * Enables asynchronous callbacks for a given logical type.
+ * This must be called before USB device generate callback events.
+ *
+ * \param[in]     module_inst   Pointer to USB software instance struct
+ * \param[in]     callback_type Callback type given by an enum
+ *
+ * \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)
+{
+    /* Sanity check arguments */
+    Assert(module_inst);
+    Assert(module_inst->hw);
+
+    /* clear related flag */
+    module_inst->hw->DEVICE.INTFLAG.reg = _usb_device_irq_bits[callback_type];
+
+    /* Enable callback */
+    module_inst->device_enabled_callback_mask |= _usb_device_irq_bits[callback_type];
+
+    module_inst->hw->DEVICE.INTENSET.reg = _usb_device_irq_bits[callback_type];
+
+    return STATUS_OK;
+}
+
+/**
+ * \brief Disables USB device callback generation for a given type.
+ *
+ * Disables asynchronous callbacks for a given logical type.
+ *
+ * \param[in]     module_inst   Pointer to USB software instance struct
+ * \param[in]     callback_type Callback type given by an enum
+ *
+ * \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)
+{
+    /* Sanity check arguments */
+    Assert(module_inst);
+    Assert(module_inst->hw);
+
+    /* Disable callback */
+    module_inst->device_enabled_callback_mask &= ~_usb_device_irq_bits[callback_type];
+
+    module_inst->hw->DEVICE.INTENCLR.reg = _usb_device_irq_bits[callback_type];
+
+    return STATUS_OK;
+}
+
+/**
+ * \brief Registers a USB device endpoint callback
+ *
+ * Registers a callback function which is implemented by the user.
+ *
+ * \note The callback must be enabled by \ref usb_device_endpoint_enable_callback,
+ * in order for the interrupt handler to call it when the conditions for the
+ * callback type is met.
+ *
+ * \param[in]     module_inst   Pointer to USB software instance struct
+ * \param[in]     ep_num        Endpoint to configure
+ * \param[in]     callback_type Callback type given by an enum
+ * \param[in]     callback_func Pointer to callback function
+ *
+ * \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)
+{
+    /* Sanity check arguments */
+    Assert(module_inst);
+    Assert(ep_num < USB_EPT_NUM);
+    Assert(callback_func);
+
+    /* Register callback function */
+    module_inst->device_endpoint_callback[ep_num][callback_type] = callback_func;
+
+    /* Set the bit corresponding to the callback_type */
+    module_inst->device_endpoint_registered_callback_mask[ep_num] |= _usb_endpoint_irq_bits[callback_type];
+
+    return STATUS_OK;
+}
+
+/**
+ * \brief Unregisters a USB device endpoint callback
+ *
+ * Unregisters an callback implemented by the user. Removing it
+ * from the internal callback registration table.
+ *
+ * \param[in]     module_inst   Pointer to USB software instance struct
+ * \param[in]     ep_num        Endpoint to configure
+ * \param[in]     callback_type Callback type given by an enum
+ *
+ * \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)
+{
+    /* Sanity check arguments */
+    Assert(module_inst);
+    Assert(ep_num < USB_EPT_NUM);
+
+    /* Unregister callback function */
+    module_inst->device_endpoint_callback[ep_num][callback_type] = NULL;
+
+    /* Clear the bit corresponding to the callback_type */
+    module_inst->device_endpoint_registered_callback_mask[ep_num] &= ~_usb_endpoint_irq_bits[callback_type];
+
+    return STATUS_OK;
+}
+
+/**
+ * \brief Enables USB device endpoint callback generation for a given type.
+ *
+ * Enables callbacks for a given logical type.
+ * This must be called before USB device pipe generate callback events.
+ *
+ * \param[in]     module_inst   Pointer to USB software instance struct
+ * \param[in]     ep            Endpoint to configure
+ * \param[in]     callback_type Callback type given by an enum
+ *
+ * \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)
+{
+    /* Sanity check arguments */
+    Assert(module_inst);
+    Assert(module_inst->hw);
+
+    uint8_t ep_num = ep & USB_EP_ADDR_MASK;
+    Assert(ep_num < USB_EPT_NUM);
+
+    /* 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
+            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;
+        } else {
+            module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPINTENSET.reg = USB_DEVICE_EPINTENSET_TRCPT0;
+        }
+    }
+
+    if (callback_type == USB_DEVICE_ENDPOINT_CALLBACK_TRFAIL) {
+        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;
+        } else {
+            module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPINTENSET.reg = USB_DEVICE_EPINTENSET_TRFAIL0;
+        }
+    }
+
+    if (callback_type == USB_DEVICE_ENDPOINT_CALLBACK_RXSTP) {
+        module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPINTENSET.reg = USB_DEVICE_EPINTENSET_RXSTP;
+    }
+
+    if (callback_type == USB_DEVICE_ENDPOINT_CALLBACK_STALL) {
+        if (ep & USB_EP_DIR_IN) {
+            module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPINTENSET.reg = USB_DEVICE_EPINTENSET_STALL1;
+        } else {
+            module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPINTENSET.reg = USB_DEVICE_EPINTENSET_STALL0;
+        }
+    }
+
+    return STATUS_OK;
+}
+
+/**
+ * \brief Disables USB device endpoint callback generation for a given type.
+ *
+ * Disables callbacks for a given logical type.
+ *
+ * \param[in]     module_inst   Pointer to USB software instance struct
+ * \param[in]     ep            Endpoint to configure
+ * \param[in]     callback_type Callback type given by an enum
+ *
+ * \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)
+{
+    /* Sanity check arguments */
+    Assert(module_inst);
+    Assert(module_inst->hw);
+
+    uint8_t ep_num = ep & USB_EP_ADDR_MASK;
+    Assert(ep_num < USB_EPT_NUM);
+
+    /* 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
+            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;
+        } else {
+            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
+            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;
+        } else {
+            module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPINTENCLR.reg = USB_DEVICE_EPINTENCLR_TRFAIL0;
+        }
+    }
+
+    if (callback_type == USB_DEVICE_ENDPOINT_CALLBACK_RXSTP) {
+        module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPINTENCLR.reg = USB_DEVICE_EPINTENCLR_RXSTP;
+    }
+
+    if (callback_type == USB_DEVICE_ENDPOINT_CALLBACK_STALL) {
+        if (ep & USB_EP_DIR_IN) {
+            module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPINTENCLR.reg = USB_DEVICE_EPINTENCLR_STALL1;
+        } else {
+            module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPINTENCLR.reg = USB_DEVICE_EPINTENCLR_STALL0;
+        }
+    }
+
+    return STATUS_OK;
+}
+
+/**
+ * \brief Initializes an USB device endpoint configuration structure to defaults.
+ *
+ * Initializes a given USB device endpoint configuration structure to a
+ * set of known default values. This function should be called on all new
+ * instances of these configuration structures before being modified by the
+ * user application.
+ *
+ * The default configuration is as follows:
+ * \li endpoint address is 0
+ * \li endpoint size is 8 bytes
+ * \li auto_zlp is false
+ * \li endpoint type is control
+ *
+ * \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)
+{
+    /* 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;
+}
+
+/**
+ * \brief Writes an USB device endpoint configuration to the hardware module.
+ *
+ * Writes out a given configuration of an USB device endpoint
+ * configuration to the hardware module. If the pipe is already configured,
+ * the new configuration will replace the existing one.
+ *
+ * \param[in] module_inst    Pointer to USB software instance struct
+ * \param[in] ep_config      Configuration settings for the endpoint
+ *
+ * \return Status of the device endpoint configuration operation
+ * \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)
+{
+    /* Sanity check arguments */
+    Assert(module_inst);
+    Assert(ep_config);
+
+    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);
+            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);
+                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 {
+                return STATUS_ERR_DENIED;
+            }
+            if (true == ep_config->auto_zlp) {
+                usb_descriptor_table.usb_endpoint_table[ep_num].DeviceDescBank[0].PCKSIZE.reg |= USB_DEVICE_PCKSIZE_AUTO_ZLP;
+                usb_descriptor_table.usb_endpoint_table[ep_num].DeviceDescBank[1].PCKSIZE.reg |= USB_DEVICE_PCKSIZE_AUTO_ZLP;
+            } else {
+                usb_descriptor_table.usb_endpoint_table[ep_num].DeviceDescBank[0].PCKSIZE.reg &= ~USB_DEVICE_PCKSIZE_AUTO_ZLP;
+                usb_descriptor_table.usb_endpoint_table[ep_num].DeviceDescBank[1].PCKSIZE.reg &= ~USB_DEVICE_PCKSIZE_AUTO_ZLP;
+            }
+            usb_descriptor_table.usb_endpoint_table[ep_num].DeviceDescBank[0].PCKSIZE.bit.SIZE = ep_config->ep_size;
+            usb_descriptor_table.usb_endpoint_table[ep_num].DeviceDescBank[1].PCKSIZE.bit.SIZE = ep_config->ep_size;
+            return STATUS_OK;
+
+        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){
+                    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){
+                    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 {
+                    return STATUS_ERR_DENIED;
+                }
+            }
+            break;
+
+        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){
+                    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){
+                    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 {
+                    return STATUS_ERR_DENIED;
+                }
+            }
+            break;
+
+        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){
+                    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){
+                    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 {
+                    return STATUS_ERR_DENIED;
+                }
+            }
+            break;
+
+        default:
+            break;
+    }
+
+    usb_descriptor_table.usb_endpoint_table[ep_num].DeviceDescBank[ep_bank].PCKSIZE.bit.SIZE = ep_config->ep_size;
+
+    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 {
+        usb_descriptor_table.usb_endpoint_table[ep_num].DeviceDescBank[ep_bank].PCKSIZE.reg &= ~USB_DEVICE_PCKSIZE_AUTO_ZLP;
+    }
+
+    return STATUS_OK;
+}
+
+/**
+ * \brief Check if current endpoint is configured
+ *
+ * \param module_inst   Pointer to USB software instance struct
+ * \param ep            Endpoint address (direction & number)
+ *
+ * \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)
+{
+    uint8_t ep_num = ep & USB_EP_ADDR_MASK;
+    uint8_t flag;
+
+    if (ep & USB_EP_DIR_IN) {
+        flag = (uint8_t)(module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPCFG.bit.EPTYPE1);
+    } else {
+        flag = (uint8_t)(module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPCFG.bit.EPTYPE0);
+    }
+    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)
+{
+    uint8_t ep_num;
+    ep_num = ep & USB_EP_ADDR_MASK;
+
+    // Stop transfer
+    if (ep & USB_EP_DIR_IN) {
+        module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPSTATUSCLR.reg = USB_DEVICE_EPSTATUSCLR_BK1RDY;
+        // Eventually ack a transfer occur during abort
+        module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPINTFLAG.reg = USB_DEVICE_EPINTFLAG_TRCPT1;
+    } else {
+        module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPSTATUSSET.reg = USB_DEVICE_EPSTATUSSET_BK0RDY;
+        // Eventually ack a transfer occur during abort
+        module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPINTFLAG.reg = USB_DEVICE_EPINTFLAG_TRCPT0;
+    }
+}
+
+/**
+ * \brief Check if endpoint is halted
+ *
+ * \param module_inst Pointer to USB software instance struct
+ * \param ep          Endpoint address
+ *
+ * \return \c true if the endpoint is halted
+ */
+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) {
+        return (module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPSTATUS.reg & USB_DEVICE_EPSTATUSSET_STALLRQ1);
+    } else {
+        return (module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPSTATUS.reg & USB_DEVICE_EPSTATUSSET_STALLRQ0);
+    }
+}
+
+/**
+ * \brief Halt the endpoint (send STALL)
+ *
+ * \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)
+{
+    uint8_t ep_num = ep & USB_EP_ADDR_MASK;
+
+    // Stall endpoint
+    if (ep & USB_EP_DIR_IN) {
+        module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPSTATUSSET.reg = USB_DEVICE_EPSTATUSSET_STALLRQ1;
+    } else {
+        module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPSTATUSSET.reg = USB_DEVICE_EPSTATUSSET_STALLRQ0;
+    }
+}
+
+/**
+ * \brief Clear endpoint halt state
+ *
+ * \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)
+{
+    uint8_t ep_num = ep & USB_EP_ADDR_MASK;
+
+    if (ep & USB_EP_DIR_IN) {
+        if (module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPSTATUS.reg & USB_DEVICE_EPSTATUSSET_STALLRQ1) {
+            // Remove stall request
+            module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPSTATUSCLR.reg = USB_DEVICE_EPSTATUSCLR_STALLRQ1;
+            if (module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPINTFLAG.reg & USB_DEVICE_EPINTFLAG_STALL1) {
+                module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPINTFLAG.reg = USB_DEVICE_EPINTFLAG_STALL1;
+                // The Stall has occurred, then reset data toggle
+                module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPSTATUSCLR.reg = USB_DEVICE_EPSTATUSSET_DTGLIN;
+            }
+        }
+    } else {
+        if (module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPSTATUS.reg & USB_DEVICE_EPSTATUSSET_STALLRQ0) {
+            // Remove stall request
+            module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPSTATUSCLR.reg = USB_DEVICE_EPSTATUSCLR_STALLRQ0;
+            if (module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPINTFLAG.reg & USB_DEVICE_EPINTFLAG_STALL0) {
+                module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPINTFLAG.reg = USB_DEVICE_EPINTFLAG_STALL0;
+                // The Stall has occurred, then reset data toggle
+                module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPSTATUSCLR.reg = USB_DEVICE_EPSTATUSSET_DTGLOUT;
+            }
+        }
+    }
+}
+
+/**
+ * \brief Start write buffer job on a endpoint
+ *
+ * \param module_inst Pointer to USB module instance
+ * \param ep_num      Endpoint number
+ * \param pbuf        Pointer to buffer
+ * \param buf_size    Size of buffer
+ *
+ * \return Status of procedure
+ * \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)
+{
+    /* Sanity check arguments */
+    Assert(module_inst);
+    Assert(module_inst->hw);
+    Assert(ep_num < USB_EPT_NUM);
+
+    uint8_t flag;
+    flag = (uint8_t)(module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPCFG.bit.EPTYPE1);
+    if ((enum usb_device_endpoint_type)(flag) == USB_DEVICE_ENDPOINT_TYPE_DISABLE) {
+        return STATUS_ERR_DENIED;
+    };
+
+    /* 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].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;
+
+    return STATUS_OK;
+}
+
+/**
+ * \brief Start read buffer job on a endpoint
+ *
+ * \param module_inst Pointer to USB module instance
+ * \param ep_num      Endpoint number
+ * \param pbuf        Pointer to buffer
+ * \param buf_size    Size of buffer
+ *
+ * \return Status of procedure
+ * \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)
+{
+    /* Sanity check arguments */
+    Assert(module_inst);
+    Assert(module_inst->hw);
+    Assert(ep_num < USB_EPT_NUM);
+
+    uint8_t flag;
+    flag = (uint8_t)(module_inst->hw->DEVICE.DeviceEndpoint[ep_num].EPCFG.bit.EPTYPE0);
+    if ((enum usb_device_endpoint_type)(flag) == USB_DEVICE_ENDPOINT_TYPE_DISABLE) {
+        return STATUS_ERR_DENIED;
+    };
+
+    /* 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].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;
+
+    return STATUS_OK;
+}
+
+/**
+ * \brief Start setup packet read job on a endpoint
+ *
+ * \param module_inst Pointer to USB device module instance
+ * \param pbuf        Pointer to buffer
+ *
+ * \return Status of procedure
+ * \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)
+{
+    /* 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].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;
+
+    return STATUS_OK;
+}
+
+static void _usb_device_interrupt_handler(void)
+{
+    uint16_t ep_inst;
+    uint16_t flags, flags_run;
+    ep_inst = _usb_instances->hw->DEVICE.EPINTSMRY.reg;
+
+    /* device interrupt */
+    if (0 == ep_inst) {
+        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;
+
+        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];
+            }
+            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;
+                }
+                (_usb_instances->device_callback[i])(_usb_instances, &device_callback_lpm_wakeup_enable);
+            }
+        }
+
+    } else {
+        /* 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];
+
+                // 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;
+                    } 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;
+                    }
+
+                    if (flags_run & USB_DEVICE_EPINTFLAG_STALL_Msk) {
+                        (_usb_instances->device_endpoint_callback[i][USB_DEVICE_ENDPOINT_CALLBACK_STALL])(_usb_instances,&ep_callback_para);
+                    }
+                    return;
+                }
+
+                // 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]) {
+                        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);
+                    }
+                    return;
+                }
+
+                // endpoint transfer complete interrupt
+                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);
+
+                    } 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);
+                    }
+                    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;
+                }
+
+                // endpoint transfer fail interrupt
+                if (flags & USB_DEVICE_EPINTFLAG_TRFAIL_Msk) {
+                    if (_usb_instances->hw->DEVICE.DeviceEndpoint[i].EPINTFLAG.reg & USB_DEVICE_EPINTFLAG_TRFAIL1) {
+                        _usb_instances->hw->DEVICE.DeviceEndpoint[i].EPINTFLAG.reg = USB_DEVICE_EPINTFLAG_TRFAIL1;
+                        if (usb_descriptor_table.usb_endpoint_table[i].DeviceDescBank[1].STATUS_BK.reg & USB_DEVICE_STATUS_BK_ERRORFLOW) {
+                            usb_descriptor_table.usb_endpoint_table[i].DeviceDescBank[1].STATUS_BK.reg &= ~USB_DEVICE_STATUS_BK_ERRORFLOW;
+                        }
+                        ep_callback_para.endpoint_address = USB_EP_DIR_IN | i;
+                        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) {
+                        _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;
+                        }
+                        ep_callback_para.endpoint_address = USB_EP_DIR_OUT | i;
+                        if (_usb_instances->hw->DEVICE.DeviceEndpoint[i].EPINTFLAG.reg & USB_DEVICE_EPINTFLAG_TRCPT0) {
+                            return;
+                        }
+                    }
+
+                    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;
+                }
+            }
+        }
+    }
+}
+
+/**
+ * \brief Enable the USB module peripheral
+ *
+ * \param module_inst pointer to USB module instance
+ */
+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);
+}
+
+/**
+ * \brief Disable the USB module peripheral
+ *
+ * \param module_inst pointer to USB module instance
+ */
+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.CTRLA.reg &= ~USB_CTRLA_ENABLE;
+    while (module_inst->hw->DEVICE.SYNCBUSY.reg == USB_SYNCBUSY_ENABLE);
+}
+
+/**
+ * \brief Interrupt handler for the USB module.
+ */
+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_2_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)
+{
+    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->source_generator = 0;
+    module_config->speed_mode = USB_SPEED_FULL;
+}
+
+#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_SIZE 5
+#define NVM_USB_PAD_TRIM_POS  55
+#define NVM_USB_PAD_TRIM_SIZE 3
+
+/**
+ * \brief Initializes USB module instance
+ *
+ * Enables the clock and initializes the USB module, based on the given
+ * configuration values.
+ *
+ * \param[in,out] module_inst   Pointer to the software module instance struct
+ * \param[in]     hw            Pointer to the USB hardware module
+ * \param[in]     module_config Pointer to the USB configuration options struct
+ *
+ * \return Status of the initialization procedure.
+ *
+ * \retval STATUS_OK           The module was initialized successfully
+ */
+
+#define GCLK_USB 10
+
+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 pad_transn, pad_transp, pad_trim;
+
+    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;
+    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].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].PINCFG[22].bit.PMUXEN = 1;
+
+    //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);
+    posc->DFLLCTRLB.bit.USBCRM = 1;
+    while (posc->DFLLSYNC.bit.DFLLCTRLB);
+    posc->DFLLCTRLB.bit.MODE = 1;
+    while (posc->DFLLSYNC.bit.DFLLCTRLB);
+    posc->DFLLCTRLB.bit.QLDIS = 0;
+    while (posc->DFLLSYNC.bit.DFLLCTRLB);
+    posc->DFLLCTRLB.bit.CCDIS = 1;
+    posc->DFLLMUL.bit.MUL = 0xbb80;   //4800 x 1KHz
+    while (posc->DFLLSYNC.bit.DFLLMUL);
+    posc->DFLLCTRLA.bit.ENABLE = 1;
+    while (posc->DFLLSYNC.bit.ENABLE);
+
+    /* Setup clock for module */
+    pgclk->PCHCTRL[GCLK_USB].bit.GEN = 0;
+    pgclk->PCHCTRL[GCLK_USB].bit.CHEN = 1;
+
+    /* Reset */
+    hw->DEVICE.CTRLA.bit.SWRST = 1;
+    while (hw->DEVICE.SYNCBUSY.bit.SWRST) {
+        /* Sync wait */
+    }
+
+    /* Change QOS values to have the best performance and correct USB behaviour */
+    USB->DEVICE.QOSCTRL.bit.CQOS = 2;
+    USB->DEVICE.QOSCTRL.bit.DQOS = 2;
+
+    /* Load Pad Calibration */
+
+    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;
+    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;
+    if (pad_trim == 0x07) {
+        pad_trim = 3;
+    }
+
+    hw->DEVICE.PADCAL.bit.TRIM = pad_trim;
+
+    /* Set the configuration */
+    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]);
+    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) {
+        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));
+
+    /*  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++) {
+            module_inst->device_endpoint_callback[i][j] = NULL;
+        }
+    }
+    module_inst->device_registered_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;
+    }
+
+    /* Enable interrupts for this USB module */
+    NVIC_EnableIRQ(USB_0_IRQn);
+    NVIC_EnableIRQ(USB_2_IRQn);
+    NVIC_EnableIRQ(USB_3_IRQn);
+
+    return STATUS_OK;
+}
+
diff --git a/tmk_core/protocol/arm_atsam/usb/usb.h b/tmk_core/protocol/arm_atsam/usb/usb.h
new file mode 100644
index 000000000..9a452881a
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/usb/usb.h
@@ -0,0 +1,492 @@
+/**
+ * \file
+ *
+ * \brief SAM USB Driver
+ *
+ * Copyright (C) 2014-2016 Atmel Corporation. All rights reserved.
+ *
+ * \asf_license_start
+ *
+ * \page License
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. The name of Atmel may not be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * 4. This software may only be redistributed and used in connection with an
+ *    Atmel microcontroller product.
+ *
+ * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
+ * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * \asf_license_stop
+ *
+ */
+/*
+ * Support and FAQ: visit <a href="http://www.atmel.com/design-support/">Atmel Support</a>
+ */
+#ifndef USB_H_INCLUDED
+#define USB_H_INCLUDED
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * \defgroup asfdoc_sam0_usb_group SAM Universal Serial Bus (USB)
+ *
+ * The Universal Serial Bus (USB) module complies with the USB 2.1 specification.
+ *
+ * The following peripherals are used by this module:
+ *  - USB (Universal Serial Bus)
+ *
+ * The following devices can use this module:
+ *  - Atmel | SMART SAM D51
+ *
+ * The USB module covers following mode:
+ * \if USB_DEVICE_MODE
+ *  - USB Device Mode
+ * \endif
+ * \if USB_HOST_MODE
+ *  - USB Host Mode
+ * \endif
+ *
+ * The USB module covers following speed:
+ * \if USB_HS_MODE
+ *  - USB High Speed (480Mbit/s)
+ * \endif
+ *  - USB Full Speed (12Mbit/s)
+ * \if USB_LS_MODE
+ *  - USB Low Speed (1.5Mbit/s)
+ * \endif
+ *
+ * \if USB_LPM_MODE
+ * The USB module supports Link Power Management (LPM-L1) protocol.
+ * \endif
+ *
+ * USB support needs whole set of enumeration process, to make the device
+ * recognizable and usable. The USB driver is designed to interface to the
+ * USB Stack in Atmel Software Framework (ASF).
+ *
+ * \if USB_DEVICE_MODE
+ * \section asfdoc_sam0_usb_device USB Device Mode
+ * The ASF USB Device Stack has defined the USB Device Driver (UDD) interface,
+ * to support USB device operations. The USB module device driver complies with
+ * this interface, so that the USB Device Stack can work based on the
+ * USB module.
+ *
+ * Refer to <a href="http://www.atmel.com/images/doc8360.pdf">
+ * "ASF - USB Device Stack"</a> for more details.
+ * \endif
+ *
+ * \if USB_HOST_MODE
+ * \section adfdoc_sam0_usb_host USB Host Mode
+ * The ASF USB Host Stack has defined the USB Host Driver (UHD) interface,
+ * to support USB host operations. The USB module host driver complies with
+ * this interface, so that the USB Host Stack can work based on the USB module.
+ *
+ * Refer to <a href="http://www.atmel.com/images/doc8486.pdf">
+ * "ASF - USB Host Stack"</a> for more details.
+ * \endif
+ */
+
+/** Enum for the speed status for the USB module */
+enum usb_speed {
+    USB_SPEED_LOW,
+    USB_SPEED_FULL,
+};
+
+/** Enum for the possible callback types for the USB in host module */
+enum usb_host_callback {
+    USB_HOST_CALLBACK_SOF,
+    USB_HOST_CALLBACK_RESET,
+    USB_HOST_CALLBACK_WAKEUP,
+    USB_HOST_CALLBACK_DNRSM,
+    USB_HOST_CALLBACK_UPRSM,
+    USB_HOST_CALLBACK_RAMACER,
+    USB_HOST_CALLBACK_CONNECT,
+    USB_HOST_CALLBACK_DISCONNECT,
+    USB_HOST_CALLBACK_N,
+};
+
+/** Enum for the possible callback types for the USB pipe in host module */
+enum usb_host_pipe_callback {
+    USB_HOST_PIPE_CALLBACK_TRANSFER_COMPLETE,
+    USB_HOST_PIPE_CALLBACK_ERROR,
+    USB_HOST_PIPE_CALLBACK_SETUP,
+    USB_HOST_PIPE_CALLBACK_STALL,
+    USB_HOST_PIPE_CALLBACK_N,
+};
+
+/**
+ * \brief Host pipe types.
+ */
+enum usb_host_pipe_type {
+    USB_HOST_PIPE_TYPE_DISABLE,
+    USB_HOST_PIPE_TYPE_CONTROL,
+    USB_HOST_PIPE_TYPE_ISO,
+    USB_HOST_PIPE_TYPE_BULK,
+    USB_HOST_PIPE_TYPE_INTERRUPT,
+    USB_HOST_PIPE_TYPE_EXTENDED,
+};
+
+/**
+ * \brief Host pipe token types.
+ */
+enum usb_host_pipe_token {
+    USB_HOST_PIPE_TOKEN_SETUP,
+    USB_HOST_PIPE_TOKEN_IN,
+    USB_HOST_PIPE_TOKEN_OUT,
+};
+
+/**
+ * \brief Enumeration for the possible callback types for the USB in device module
+ */
+enum usb_device_callback {
+    USB_DEVICE_CALLBACK_SOF,
+    USB_DEVICE_CALLBACK_RESET,
+    USB_DEVICE_CALLBACK_WAKEUP,
+    USB_DEVICE_CALLBACK_RAMACER,
+    USB_DEVICE_CALLBACK_SUSPEND,
+    USB_DEVICE_CALLBACK_LPMNYET,
+    USB_DEVICE_CALLBACK_LPMSUSP,
+    USB_DEVICE_CALLBACK_N,
+};
+
+/**
+ * \brief Enumeration for the possible callback types for the USB endpoint in device module
+ */
+enum usb_device_endpoint_callback {
+    USB_DEVICE_ENDPOINT_CALLBACK_TRCPT,
+    USB_DEVICE_ENDPOINT_CALLBACK_TRFAIL,
+    USB_DEVICE_ENDPOINT_CALLBACK_RXSTP,
+    USB_DEVICE_ENDPOINT_CALLBACK_STALL,
+    USB_DEVICE_EP_CALLBACK_N,
+};
+
+/**
+ * \brief Device Endpoint types.
+ */
+enum usb_device_endpoint_type {
+    USB_DEVICE_ENDPOINT_TYPE_DISABLE,
+    USB_DEVICE_ENDPOINT_TYPE_CONTROL,
+    USB_DEVICE_ENDPOINT_TYPE_ISOCHRONOUS,
+    USB_DEVICE_ENDPOINT_TYPE_BULK,
+    USB_DEVICE_ENDPOINT_TYPE_INTERRUPT,
+};
+
+/**
+ * \brief Endpoint Size
+ */
+enum usb_endpoint_size {
+    USB_ENDPOINT_8_BYTE,
+    USB_ENDPOINT_16_BYTE,
+    USB_ENDPOINT_32_BYTE,
+    USB_ENDPOINT_64_BYTE,
+    USB_ENDPOINT_128_BYTE,
+    USB_ENDPOINT_256_BYTE,
+    USB_ENDPOINT_512_BYTE,
+    USB_ENDPOINT_1023_BYTE,
+};
+
+/**
+ * \brief Link Power Management Handshake.
+ */
+enum usb_device_lpm_mode {
+    USB_DEVICE_LPM_NOT_SUPPORT,
+    USB_DEVICE_LPM_ACK,
+    USB_DEVICE_LPM_NYET,
+};
+
+/**
+ * \brief Module structure
+ */
+struct usb_module;
+
+/**
+ * \name Host Callback Functions Types
+ * @{
+ */
+typedef void (*usb_host_callback_t)(struct usb_module *module_inst);
+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);
+/** @} */
+
+/** USB configurations */
+struct usb_config {
+    /** \c true for host, \c false for device. */
+    bool select_host_mode;
+    /** When \c true the module is enabled during standby. */
+    bool run_in_standby;
+    /** Generic Clock Generator source channel. */
+    // enum gclk_generator source_generator;
+    uint8_t source_generator;
+    /** Speed mode */
+    //enum usb_speed speed_mode;
+    uint8_t speed_mode;
+};
+
+/**
+ * \brief USB software module instance structure.
+ *
+ * USB software module instance structure, used to retain software state
+ * information of an associated hardware module instance.
+ *
+ */
+struct usb_module {
+    /** Hardware module pointer of the associated USB peripheral. */
+    Usb *hw;
+
+    /** Array to store device related callback functions */
+    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;
+    /** Bit mask for device callbacks enabled */
+    uint16_t device_enabled_callback_mask;
+    /** Bit mask for device endpoint callbacks registered */
+    uint8_t device_endpoint_registered_callback_mask[USB_EPT_NUM];
+    /** Bit mask for device endpoint callbacks enabled */
+    uint8_t device_endpoint_enabled_callback_mask[USB_EPT_NUM];
+};
+
+/** USB device endpoint configurations */
+struct usb_device_endpoint_config {
+    /** device address */
+    uint8_t ep_address;
+    /** endpoint size */
+    enum usb_endpoint_size ep_size;
+    /** automatic zero length packet mode, \c true to enable */
+    bool auto_zlp;
+    /** type of endpoint with Bank */
+    enum usb_device_endpoint_type ep_type;
+};
+
+/** USB device endpoint callback status parameter structure */
+struct usb_endpoint_callback_parameter {
+    uint16_t received_bytes;
+    uint16_t sent_bytes;
+    uint16_t out_buffer_size;
+    uint8_t endpoint_address;
+};
+
+void usb_enable(struct usb_module *module_inst);
+void usb_disable(struct usb_module *module_inst);
+
+/**
+ * \brief Get the status of USB module's state machine
+ *
+ * \param module_inst Pointer to USB module instance
+ */
+static inline uint8_t usb_get_state_machine_status(struct usb_module *module_inst)
+{
+    /* Sanity check arguments */
+    Assert(module_inst);
+    Assert(module_inst->hw);
+
+    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);
+
+/**
+ * \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;
+}
+
+/**
+ * \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;
+}
+
+/**
+ * \brief Get the speed mode of USB device
+ *
+ * \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)
+{
+    if (!(module_inst->hw->DEVICE.STATUS.reg & USB_DEVICE_STATUS_SPEED_Msk)) {
+        return USB_SPEED_FULL;
+    } else {
+        return USB_SPEED_LOW;
+    }
+}
+
+/**
+ * \brief Get the address of USB device
+ *
+ * \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));
+}
+
+/**
+ * \brief Set the speed mode of USB device
+ *
+ * \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;
+}
+
+/**
+ * \brief Get the frame number of USB device
+ *
+ * \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));
+}
+
+/**
+ * \brief Get the micro-frame number of USB device
+ *
+ * \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));
+}
+
+/**
+ * \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;
+}
+
+/**
+ * \brief USB device set the LPM mode
+ *
+ * \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;
+}
+
+/**
+ * \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);
+/** @} */
+
+/**
+ * \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);
+/** @} */
+
+/**
+ * \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);
+/** @} */
+
+/**
+ * \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);
+/** @} */
+
+/**
+ * \name USB Device Endpoint Operations
+ * @{
+ */
+
+bool usb_device_endpoint_is_halted(struct usb_module *module_inst, uint8_t ep);
+void usb_device_endpoint_set_halt(struct usb_module *module_inst, uint8_t ep);
+void usb_device_endpoint_clear_halt(struct usb_module *module_inst, uint8_t ep);
+
+/** @} */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* USB_H_INCLUDED */
diff --git a/tmk_core/protocol/arm_atsam/usb/usb2422.c b/tmk_core/protocol/arm_atsam/usb/usb2422.c
new file mode 100644
index 000000000..7c78e41d4
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/usb/usb2422.c
@@ -0,0 +1,412 @@
+/*
+Copyright 2018 Massdrop Inc.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "arm_atsam_protocol.h"
+#include <string.h>
+
+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
+#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
+#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
+//      space as needed and adjust BOOTLOADER_SERIAL_MAX_SIZE to match amount given
+#endif //MD_BOOTLOADER
+
+uint8_t usb_host_port;
+
+#ifndef MD_BOOTLOADER
+
+uint8_t usb_extra_state;
+uint8_t usb_extra_manual;
+uint8_t usb_gcr_auto;
+
+#endif //MD_BOOTLOADER
+
+uint16_t adc_extra;
+
+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)
+    {
+        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); }
+        CLK_delay_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;
+    Srdata_t *pspi = &srdata;
+
+    DBGC(DC_USB2422_INIT_BEGIN);
+
+    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;
+    pgclk->PCHCTRL[10].bit.CHEN = 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+
+    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].PINCFG[22].bit.PMUXEN = 1;
+
+    //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); }
+    posc->DFLLCTRLB.bit.USBCRM = 1;
+    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); }
+    posc->DFLLCTRLB.bit.QLDIS = 0;
+    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->DFLLCTRLA.bit.ENABLE = 1;
+    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
+    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.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
+
+    pspi->bit.HUB_CONNECT = 1; //connect signal
+    pspi->bit.HUB_RESET_N = 1; //reset high
+    SPI_WriteSRData();
+
+    CLK_delay_us(100);
+
+#ifndef MD_BOOTLOADER
+
+    usb_extra_manual = 0;
+    usb_gcr_auto = 1;
+
+#endif //MD_BOOTLOADER
+
+    DBGC(DC_USB2422_INIT_COMPLETE);
+}
+
+void USB_reset(void)
+{
+    Srdata_t *pspi = &srdata;
+
+    DBGC(DC_USB_RESET_BEGIN);
+
+    //pulse reset for at least 1 usec
+    pspi->bit.HUB_RESET_N = 0; //reset low
+    SPI_WriteSRData();
+    CLK_delay_us(1);
+    pspi->bit.HUB_RESET_N = 1; //reset high to run
+    SPI_WriteSRData();
+    CLK_delay_us(1);
+
+    DBGC(DC_USB_RESET_COMPLETE);
+}
+
+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
+#ifndef MD_BOOTLOADER
+    uint32_t serial_ptrloc = (uint32_t)&_srom - 4;
+#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
+
+    DBGC(DC_USB_CONFIGURE_BEGIN);
+
+    if (serial_address != 0xFFFFFFFF && serial_address < serial_ptrloc) //Check for factory programmed serial address
+    {
+        if ((serial_address & 0xFF) % 4 == 0) //Check alignment
+        {
+            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)
+            {
+                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
+    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->STCD.bit.USB_ATTACH = 1;
+    USB_write2422_block();
+
+    adc_extra = 0;
+
+    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;
+}
+
+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
+    srdata.bit.SRC_1 = 1;       //USBC-1 available for test
+    srdata.bit.SRC_2 = 1;       //USBC-2 available for test
+    srdata.bit.E_UP_N = 1;      //HOST disable
+    srdata.bit.E_DN1_N = 1;     //EXTRA disable
+    srdata.bit.E_VBUS_1 = 0;    //USBC-1 disable full power I/O
+    srdata.bit.E_VBUS_2 = 0;    //USBC-2 disable full power I/O
+
+    SPI_WriteSRData();
+
+    CLK_delay_ms(250);
+
+    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);
+
+    v_con_1_boot = v_con_1;
+    v_con_2_boot = v_con_2;
+
+    if (v_con_1 > v_con_2)
+    {
+        srdata.bit.S_UP = 0;        //HOST to USBC-1
+        srdata.bit.S_DN1 = 1;       //EXTRA to USBC-2
+        srdata.bit.SRC_1 = 1;       //HOST on USBC-1
+        srdata.bit.SRC_2 = 0;       //EXTRA available on USBC-2
+
+        srdata.bit.E_VBUS_1 = 1;    //USBC-1 enable full power I/O
+        srdata.bit.E_VBUS_2 = 0;    //USBC-2 disable full power I/O
+
+        SPI_WriteSRData();
+
+        srdata.bit.E_UP_N = 0;      //HOST enable
+
+        SPI_WriteSRData();
+
+        usb_host_port = USB_HOST_PORT_1;
+    }
+    else
+    {
+        srdata.bit.S_UP = 1;        //EXTRA to USBC-1
+        srdata.bit.S_DN1 = 0;       //HOST to USBC-2
+        srdata.bit.SRC_1 = 0;       //EXTRA available on USBC-1
+        srdata.bit.SRC_2 = 1;       //HOST on USBC-2
+
+        srdata.bit.E_VBUS_1 = 0;    //USBC-1 disable full power I/O
+        srdata.bit.E_VBUS_2 = 1;    //USBC-2 enable full power I/O
+
+        SPI_WriteSRData();
+
+        srdata.bit.E_UP_N = 0;      //HOST enable
+
+        SPI_WriteSRData();
+
+        usb_host_port = USB_HOST_PORT_2;
+    }
+
+#ifndef MD_BOOTLOADER
+    usb_extra_state = USB_EXTRA_STATE_DISABLED;
+#endif //MD_BOOTLOADER
+
+    USB_reset();
+    USB_configure();
+
+    DBGC(DC_USB_SET_HOST_BY_VOLTAGE_COMPLETE);
+}
+
+uint8_t USB2422_Port_Detect_Init(void)
+{
+    uint32_t port_detect_retry_ms;
+    uint32_t tmod;
+
+    DBGC(DC_PORT_DETECT_INIT_BEGIN);
+
+    USB_set_host_by_voltage();
+
+    port_detect_retry_ms = CLK_get_ms() + PORT_DETECT_RETRY_INTERVAL;
+
+    while (!USB_active())
+    {
+        tmod = CLK_get_ms() % PORT_DETECT_RETRY_INTERVAL;
+
+        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) { led_on; }
+            else { 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) { led_on; }
+            else if (tmod > 700 && tmod < 800) { led_on; }
+            else { led_off; }
+        }
+
+        if (CLK_get_ms() > port_detect_retry_ms)
+        {
+            DBGC(DC_PORT_DETECT_INIT_FAILED);
+            return 0;
+        }
+    }
+
+    DBGC(DC_PORT_DETECT_INIT_COMPLETE);
+
+    return 1;
+}
+
+#ifndef MD_BOOTLOADER
+
+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 (usb_host_port == USB_HOST_PORT_1) srdata.bit.E_VBUS_2 = state;
+    else if (usb_host_port == USB_HOST_PORT_2) srdata.bit.E_VBUS_1 = state;
+    else return;
+
+    srdata.bit.E_DN1_N = !state;
+    SPI_WriteSRData();
+
+    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)
+    {
+      CDC_print("USB: Extra disabled\r\n");
+      if (led_animation_breathing) gcr_breathe = gcr_desired;
+    }
+    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)
+{
+    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;
+
+    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
+        if (adc_extra > USB_EXTRA_ADC_THRESHOLD) usb_extra_state = USB_EXTRA_STATE_DISABLED;
+
+        return; //Return even if unplug detected
+    }
+
+    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);
+}
+
+#endif //MD_BOOTLOADER
+
diff --git a/tmk_core/protocol/arm_atsam/usb/usb2422.h b/tmk_core/protocol/arm_atsam/usb/usb2422.h
new file mode 100644
index 000000000..6c763dd8c
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/usb/usb2422.h
@@ -0,0 +1,405 @@
+/*
+Copyright 2018 Massdrop Inc.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _USB2422_H_
+#define _USB2422_H_
+
+#define USB2422_ALT67_1P0
+#define REV_USB2422        0x100
+
+#define USB2422_ADDR       0x58 //I2C device address, one instance
+
+#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              */
+} 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              */
+} 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              */
+} 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              */
+} 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              */
+} 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              */
+} 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              */
+} 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              */
+} 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              */
+} 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              */
+} 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              */
+} 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              */
+} 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              */
+} 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              */
+} 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              */
+} 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              */
+} 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              */
+} 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              */
+} 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              */
+} USB2422_SERSL_Type;
+#endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */
+
+/* -------- USB2422_MFRSTR : (USB2422L Offset: 0x16-53) (R/W 8) Maufacturer String -------- */
+#if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__))
+typedef uint16_t USB2422_MFRSTR_Type;
+#endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */
+
+/* -------- USB2422_PRDSTR : (USB2422L Offset: 0x54-91) (R/W 8) Product String -------- */
+#if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__))
+typedef uint16_t USB2422_PRDSTR_Type;
+#endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */
+
+/* -------- USB2422_SERSTR : (USB2422L Offset: 0x92-CF) (R/W 8) Serial String -------- */
+#if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__))
+typedef uint16_t USB2422_SERSTR_Type;
+#endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */
+
+/* -------- 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              */
+} 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              */
+} 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              */
+} 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              */
+} 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              */
+} USB2422_PRTR12_Type;
+#endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */
+#define USB2422_PRTR12_DISABLE 0
+#define USB2422_PRT12_P2TOL1 1
+#define USB2422_PRT12_P2XTOL2 2
+#define USB2422_PRT12_P1TOL1 1
+#define USB2422_PRT12_P1XTOL2 2
+
+/* -------- 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              */
+} 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;
+#endif
+
+#define PORT_DETECT_RETRY_INTERVAL      2000
+
+#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_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);
+uint16_t USB_active(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_
+
diff --git a/tmk_core/protocol/arm_atsam/usb/usb_atmel.h b/tmk_core/protocol/arm_atsam/usb/usb_atmel.h
new file mode 100644
index 000000000..7febdc9ec
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/usb/usb_atmel.h
@@ -0,0 +1,190 @@
+/**
+ * \file
+ *
+ * \brief All USB VIDs and PIDs from Atmel USB applications
+ *
+ * Copyright (c) 2009-2015 Atmel Corporation. All rights reserved.
+ *
+ * \asf_license_start
+ *
+ * \page License
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. The name of Atmel may not be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * 4. This software may only be redistributed and used in connection with an
+ *    Atmel microcontroller product.
+ *
+ * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
+ * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * \asf_license_stop
+ *
+ */
+/*
+ * Support and FAQ: visit <a href="http://www.atmel.com/design-support/">Atmel Support</a>
+ */
+
+#ifndef _USB_ATMEL_H_
+#define _USB_ATMEL_H_
+
+/**
+ * \defgroup usb_group USB Stack
+ *
+ * This stack includes the USB Device Stack, USB Host Stack and common
+ * definitions.
+ * @{
+ */
+
+//! @}
+
+/**
+ * \ingroup usb_group
+ * \defgroup usb_atmel_ids_group Atmel USB Identifiers
+ *
+ * This module defines Atmel PID and VIDs constants.
+ *
+ * @{
+ */
+
+//! \name Vendor Identifier assigned by USB org to ATMEL
+#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
+//! @}
+
+//! \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
+//! @}
+
+//! \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
+//! @}
+
+//! \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
+//! @}
+
+//! \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
+// 2FFCh to 2FFFh used by C51 family products
+//! @}
+
+//! @}
+
+//! @}
+
+
+#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
new file mode 100644
index 000000000..b31256df7
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/usb/usb_device_udd.c
@@ -0,0 +1,1097 @@
+/**
+ * \file
+ *
+ * \brief USB Device wrapper layer for compliance with common driver UDD
+ *
+ * Copyright (C) 2014-2016 Atmel Corporation. All rights reserved.
+ *
+ * \asf_license_start
+ *
+ * \page License
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. The name of Atmel may not be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * 4. This software may only be redistributed and used in connection with an
+ *    Atmel microcontroller product.
+ *
+ * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
+ * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * \asf_license_stop
+ *
+ */
+/*
+ * Support and FAQ: visit <a href="http://www.atmel.com/design-support/">Atmel Support</a>
+ */
+#include "samd51j18a.h"
+#include <string.h>
+#include <stdlib.h>
+
+// Get USB device configuration
+#include "conf_usb.h"
+#include "udd.h"
+#include "usb.h"
+#include "status_codes.h"
+
+/**
+ * \ingroup usb_device_group
+ * \defgroup usb_device_udd_group USB Device Driver Implement (UDD)
+ * USB low-level driver for USB device mode
+ * @{
+ */
+// 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
+#endif
+
+//Note: This driver is adapted for SAMD51
+
+#ifndef UDC_REMOTEWAKEUP_LPM_ENABLE
+#define UDC_REMOTEWAKEUP_LPM_ENABLE()
+#endif
+#ifndef UDC_REMOTEWAKEUP_LPM_DISABLE
+#define UDC_REMOTEWAKEUP_LPM_DISABLE()
+#endif
+#ifndef UDC_SUSPEND_LPM_EVENT
+#define UDC_SUSPEND_LPM_EVENT()
+#endif
+
+/* for debug text */
+#ifdef USB_DEBUG
+#   define dbg_print printf
+#else
+#   define dbg_print(...)
+#endif
+
+/** Maximum size of a transfer in multi-packet mode */
+#define UDD_ENDPOINT_MAX_TRANS ((8*1024)-1)
+
+/** USB software device instance structure */
+struct usb_module usb_device;
+
+/**
+ * \name Clock management
+ *
+ * @{
+ */
+
+#define UDD_CLOCK_GEN 0
+
+static inline void udd_wait_clock_ready(void)
+{
+
+}
+
+/**
+ * \name Power management
+ *
+ * @{
+ */
+#define udd_sleep_mode(arg)
+/** @} */
+
+/**
+ * \name Control endpoint low level management routine.
+ *
+ * This function performs control endpoint management.
+ * It handles the SETUP/DATA/HANDSHAKE phases of a control transaction.
+ *
+ * @{
+ */
+
+/**
+ * \brief Buffer to store the data received on control endpoint (SETUP/OUT endpoint 0)
+ *
+ * Used to avoid a RAM buffer overflow in case of the payload buffer
+ * is smaller than control endpoint size
+ */
+UDC_BSS(4)
+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_ctrl_ep_state_t;
+
+/** Global variable to give and record information of the set up request management */
+udd_ctrl_request_t udd_g_ctrlreq;
+
+/** State of the endpoint control management */
+static udd_ctrl_ep_state_t udd_ep_control_state;
+
+/** Total number of data received/sent during data packet phase with previous payload buffers */
+static uint16_t udd_ctrl_prev_payload_nb_trans;
+
+/** Number of data received/sent to/from udd_g_ctrlreq.payload buffer */
+static uint16_t udd_ctrl_payload_nb_trans;
+
+/** @} */
+
+/**
+ * \name Management of bulk/interrupt/isochronous endpoints
+ *
+ * The UDD manages the data transfer on endpoints:
+ * - Start data transfer on endpoint with USB Device DMA
+ * - Send a ZLP packet if requested
+ * - Call callback registered to signal end of transfer
+ * The transfer abort and stall feature are supported.
+ *
+ * @{
+ */
+
+/**
+ * \brief Buffer to store the data received on bulk/interrupt endpoints
+ *
+ * Used to avoid a RAM buffer overflow in case of the user buffer
+ * is smaller than endpoint size
+ *
+ * \warning The protected interrupt endpoint size is 512 bytes maximum.
+ * \warning The isochronous and endpoint is not protected by this system and
+ *          the user must always use a buffer corresponding at endpoint size.
+ */
+
+#if (defined USB_DEVICE_LOW_SPEED)
+UDC_BSS(4) uint8_t udd_ep_out_cache_buffer[USB_DEVICE_MAX_EP][8];
+#elif (defined USB_DEVICE_HS_SUPPORT)
+UDC_BSS(4) uint8_t udd_ep_out_cache_buffer[USB_DEVICE_MAX_EP][512];
+#else
+UDC_BSS(4) uint8_t udd_ep_out_cache_buffer[USB_DEVICE_MAX_EP][64];
+#endif
+
+/** Structure definition about job registered on an endpoint */
+typedef struct {
+    union {
+        //! Callback to call at the end of transfer
+        udd_callback_trans_t call_trans;
+        //! Callback to call when the endpoint halt is cleared
+        udd_callback_halt_cleared_t call_nohalt;
+    };
+    //! Buffer located in internal RAM to send or fill during job
+    uint8_t *buf;
+    //! Size of buffer to send or fill
+    iram_size_t buf_size;
+    //! Total number of data transferred on endpoint
+    iram_size_t nb_trans;
+    //! Endpoint size
+    uint16_t ep_size;
+    //! A job is registered on this endpoint
+    uint8_t busy:1;
+    //! A short packet is requested for this job on endpoint IN
+    uint8_t b_shortpacket:1;
+    //! The cache buffer is currently used on endpoint OUT
+    uint8_t b_use_out_cache_buffer:1;
+} udd_ep_job_t;
+
+/** Array to register a job on bulk/interrupt/isochronous endpoint */
+static udd_ep_job_t udd_ep_job[2 * USB_DEVICE_MAX_EP];
+
+/** @} */
+
+/**
+ * \brief     Get the detailed job by endpoint number
+ * \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)
+{
+    if ((ep == 0) || (ep == 0x80)) {
+        return NULL;
+    } else {
+        return &udd_ep_job[(2 * (ep & USB_EP_ADDR_MASK) + ((ep & USB_EP_DIR_IN) ? 1 : 0)) - 2];
+    }
+}
+
+/**
+ * \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;
+
+    ptr_job = udd_ep_get_job(ep);
+    ep_num = ep & USB_EP_ADDR_MASK;
+
+    ep_size = ptr_job->ep_size;
+    /* Update number of data transferred */
+    nb_trans = ep_callback_para->sent_bytes;
+    ptr_job->nb_trans += nb_trans;
+
+    /* Need to send other data */
+    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);
+        }
+        /* 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);
+        return;
+    }
+
+    /* Need to send a ZLP after all data transfer */
+    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);
+        return;
+    }
+
+    /* Job complete then call callback */
+    ptr_job->busy = false;
+    if (NULL != ptr_job->call_trans) {
+        ptr_job->call_trans(UDD_EP_TRANSFER_OK, ptr_job->nb_trans, ep);
+    }
+}
+
+/**
+ * \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;
+
+    ptr_job = udd_ep_get_job(ep);
+    ep_num = ep & USB_EP_ADDR_MASK;
+
+    ep_size = ptr_job->ep_size;
+    /* Update number of data transferred */
+    nb_trans = ep_callback_para->received_bytes;
+
+    /* Can be necessary to copy data receive from cache buffer to user buffer */
+    if (ptr_job->b_use_out_cache_buffer) {
+        memcpy(&ptr_job->buf[ptr_job->nb_trans], udd_ep_out_cache_buffer[ep_num - 1], ptr_job->buf_size % ep_size);
+    }
+
+    /* Update number of data transferred */
+    ptr_job->nb_trans += nb_trans;
+    if (ptr_job->nb_trans > ptr_job->buf_size) {
+        ptr_job->nb_trans = ptr_job->buf_size;
+    }
+
+    /* If all previous data requested are received and user buffer not full
+     * then need to receive other data */
+    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);
+        } else {
+            next_trans -= next_trans % ep_size;
+        }
+
+        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);
+        } else {
+            usb_device_endpoint_read_buffer_job(&usb_device,ep_num,&ptr_job->buf[ptr_job->nb_trans],next_trans);
+        }
+        return;
+    }
+
+    /* Job complete then call callback */
+    ptr_job->busy = false;
+    if (NULL != ptr_job->call_trans) {
+        ptr_job->call_trans(UDD_EP_TRANSFER_OK, ptr_job->nb_trans, ep);
+    }
+}
+
+/**
+ * \brief     Endpoint Transfer Complete callback function, to do the next transfer depends on the direction(IN or OUT)
+ * \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;
+
+    if (ep & USB_EP_DIR_IN) {
+        udd_ep_trans_in_next(pointer);
+    } else {
+        udd_ep_trans_out_next(pointer);
+    }
+}
+
+void udd_ep_abort(udd_ep_id_t ep)
+{
+    udd_ep_job_t *ptr_job;
+
+    usb_device_endpoint_abort_job(&usb_device, ep);
+
+    /* Job complete then call callback */
+    ptr_job = udd_ep_get_job(ep);
+    if (!ptr_job->busy) {
+        return;
+    }
+    ptr_job->busy = false;
+    if (NULL != ptr_job->call_trans) {
+        /* It can be a Transfer or stall callback */
+        ptr_job->call_trans(UDD_EP_TRANSFER_ABORT, ptr_job->nb_trans, ep);
+    }
+}
+
+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_micro_frame_number(void)
+{
+    return usb_device_get_micro_frame_number(&usb_device);
+}
+
+void udd_ep_free(udd_ep_id_t ep)
+{
+    struct usb_device_endpoint_config config_ep;
+    usb_device_endpoint_get_config_defaults(&config_ep);
+
+    uint8_t ep_num = ep & USB_EP_ADDR_MASK;
+    udd_ep_abort(ep);
+
+    config_ep.ep_address = ep;
+    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);
+}
+
+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) {
+        config_ep.ep_size = USB_ENDPOINT_8_BYTE;
+    } else if(MaxEndpointSize <= 16) {
+        config_ep.ep_size = USB_ENDPOINT_16_BYTE;
+    } else if(MaxEndpointSize <= 32) {
+        config_ep.ep_size = USB_ENDPOINT_32_BYTE;
+    } else if(MaxEndpointSize <= 64) {
+        config_ep.ep_size = USB_ENDPOINT_64_BYTE;
+    } else if(MaxEndpointSize <= 128) {
+        config_ep.ep_size = USB_ENDPOINT_128_BYTE;
+    } else if(MaxEndpointSize <= 256) {
+        config_ep.ep_size = USB_ENDPOINT_256_BYTE;
+    } else if(MaxEndpointSize <= 512) {
+        config_ep.ep_size = USB_ENDPOINT_512_BYTE;
+    } 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;
+
+    bmAttributes = bmAttributes & USB_EP_TYPE_MASK;
+
+    /* Check endpoint type */
+    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;
+    } else if (USB_EP_TYPE_INTERRUPT == bmAttributes) {
+        config_ep.ep_type = USB_DEVICE_ENDPOINT_TYPE_INTERRUPT;
+    } else {
+        return false;
+    }
+
+    uint8_t ep_num = ep & USB_EP_ADDR_MASK;
+
+    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);
+
+    return true;
+}
+
+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)
+{
+    uint8_t ep_num = ep & USB_EP_ADDR_MASK;
+
+    if (USB_DEVICE_MAX_EP < ep_num) {
+        return false;
+    }
+
+    usb_device_endpoint_set_halt(&usb_device, ep);
+
+    udd_ep_abort(ep);
+    return true;
+}
+
+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;
+
+    if (USB_DEVICE_MAX_EP < ep_num) {
+        return false;
+    }
+    ptr_job = udd_ep_get_job(ep);
+
+    usb_device_endpoint_clear_halt(&usb_device, ep);
+
+    /* If a job is register on clear halt action then execute callback */
+    if (ptr_job->busy == true) {
+        ptr_job->busy = false;
+        ptr_job->call_nohalt();
+    }
+
+    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;
+    udd_ep_job_t *ptr_job;
+
+    ep_num = ep & USB_EP_ADDR_MASK;
+    if (USB_DEVICE_MAX_EP < ep_num) {
+        return false;
+    }
+
+    ptr_job = udd_ep_get_job(ep);
+    if (ptr_job->busy == true) {
+        return false; /* Job already on going */
+    }
+
+    /* 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->call_nohalt = callback;
+        return true;
+    } else if (usb_device_endpoint_is_configured(&usb_device, ep)) {
+        callback(); /* Endpoint not halted then call directly callback */
+        return true;
+    } else {
+        return false;
+    }
+}
+
+/**
+ * \brief Control Endpoint stall sending data
+ */
+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;
+    udd_ep_job_t *ptr_job;
+    uint32_t irqflags;
+
+    ep_num = ep & USB_EP_ADDR_MASK;
+
+    if ((USB_DEVICE_MAX_EP < ep_num) || (udd_ep_is_halted(ep))) {
+        return false;
+    }
+
+    ptr_job = udd_ep_get_job(ep);
+
+    irqflags = __get_PRIMASK();
+    __disable_irq();
+    __DMB();
+
+    if (ptr_job->busy == true) {
+        __DMB();
+        __set_PRIMASK(irqflags);
+        return false; /* Job already on going */
+    }
+
+    ptr_job->busy = true;
+    __DMB();
+    __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->b_use_out_cache_buffer = false;
+
+    /* Initialize value to simulate a empty transfer */
+    uint16_t next_trans;
+
+    if (ep & USB_EP_DIR_IN) {
+        if (0 != ptr_job->buf_size) {
+            next_trans = ptr_job->buf_size;
+            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));
+        } else if (true == ptr_job->b_shortpacket) {
+            ptr_job->b_shortpacket = false; /* avoid to send zero length packet again */
+            next_trans = 0;
+        } else {
+            ptr_job->busy = false;
+            if (NULL != ptr_job->call_trans) {
+                ptr_job->call_trans(UDD_EP_TRANSFER_OK, 0, ep);
+            }
+            return true;
+        }
+        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);
+            } 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));
+            } else {
+                return (STATUS_OK ==
+                        usb_device_endpoint_read_buffer_job(&usb_device, ep_num,
+                                &ptr_job->buf[0],next_trans));
+            }
+        } else {
+            ptr_job->busy = false;
+            if (NULL != ptr_job->call_trans) {
+                ptr_job->call_trans(UDD_EP_TRANSFER_OK, 0, ep);
+            }
+            return true;
+        }
+    }
+}
+
+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);
+}
+
+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 --) {
+        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;
+    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)
+{
+    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];
+}
+
+/**
+ * \brief Control Endpoint send out zero length packet
+ */
+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);
+}
+
+/**
+ * \brief Process control endpoint IN transaction
+ */
+static void udd_ctrl_in_sent(void)
+{
+    static bool b_shortpacket = false;
+    uint16_t nb_remain;
+
+    nb_remain = udd_g_ctrlreq.payload_size - udd_ctrl_payload_nb_trans;
+
+    if (0 == nb_remain) {
+        /* All content of current buffer payload are sent Update number of total data sending by previous payload buffer */
+        udd_ctrl_prev_payload_nb_trans += udd_ctrl_payload_nb_trans;
+        if ((udd_g_ctrlreq.req.wLength == udd_ctrl_prev_payload_nb_trans) || b_shortpacket) {
+            /* 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);
+            return;
+        }
+        /* Need of new buffer because the data phase is not complete */
+        if ((!udd_g_ctrlreq.over_under_run) || (!udd_g_ctrlreq.over_under_run())) {
+            /* Under run then send zlp on IN
+             * Here nb_remain=0, this allows to send a IN ZLP */
+        } else {
+            /* A new payload buffer is given */
+            udd_ctrl_payload_nb_trans = 0;
+            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;
+        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);
+
+    udd_ctrl_payload_nb_trans += nb_remain;
+}
+
+/**
+ * \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;
+
+    uint16_t nb_data;
+    nb_data = ep_callback_para->received_bytes; /* Read data received during OUT phase */
+
+    if (udd_g_ctrlreq.payload_size < (udd_ctrl_payload_nb_trans + nb_data)) {
+        /* Payload buffer too small */
+        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);
+    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))) {
+        /* End of reception because it is a short packet
+         * or all data are transferred */
+
+        /* Before send ZLP, call intermediate callback
+         * in case of data receive generate a stall */
+        udd_g_ctrlreq.payload_size = udd_ctrl_payload_nb_trans;
+        if (NULL != udd_g_ctrlreq.over_under_run) {
+            if (!udd_g_ctrlreq.over_under_run()) {
+                /* Stall ZLP */
+                udd_ep_control_state = UDD_EPCTRL_STALL_REQ;
+                /* Stall all packets on IN & OUT control endpoint */
+                udd_ep_set_halt(0);
+                /* Ack reception of OUT to replace NAK by a STALL */
+                return;
+            }
+        }
+        /* Send IN ZLP to ACK setup request */
+        udd_ctrl_send_zlp_in();
+        return;
+    }
+
+    if (udd_g_ctrlreq.payload_size == udd_ctrl_payload_nb_trans) {
+        /* Overrun then request a new payload buffer */
+        if (!udd_g_ctrlreq.over_under_run) {
+            /* No callback available to request a new payload buffer
+             * Stall ZLP */
+            udd_ep_control_state = UDD_EPCTRL_STALL_REQ;
+            /* Stall all packets on IN & OUT control endpoint */
+            udd_ep_set_halt(0);
+            return;
+        }
+        if (!udd_g_ctrlreq.over_under_run()) {
+            /* No new payload buffer delivered
+             * Stall ZLP */
+            udd_ep_control_state = UDD_EPCTRL_STALL_REQ;
+            /* Stall all packets on IN & OUT control endpoint */
+            udd_ep_set_halt(0);
+            return;
+        }
+        /* New payload buffer available
+         * Update number of total data received */
+        udd_ctrl_prev_payload_nb_trans += udd_ctrl_payload_nb_trans;
+
+        /* 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);
+}
+
+/**
+ * \internal
+ * \brief     Endpoint 0 (control) SETUP received callback
+ * \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;
+
+    if (UDD_EPCTRL_SETUP != udd_ep_control_state) {
+        if (NULL != udd_g_ctrlreq.callback) {
+            udd_g_ctrlreq.callback();
+        }
+        udd_ep_control_state = UDD_EPCTRL_SETUP;
+    }
+    if ( 8 != ep_callback_para->received_bytes) {
+        udd_ctrl_stall_data();
+        return;
+    } else {
+        udd_ctrl_fetch_ram();
+        if (false == udc_process_setup()) {
+            udd_ctrl_stall_data();
+            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_in_sent();
+        } else {
+            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;
+                /* Initialize buffer size and enable OUT bank */
+                usb_device_endpoint_read_buffer_job(&usb_device,0,udd_ctrl_buffer,USB_DEVICE_EP_CTRL_SIZE);
+            }
+        }
+    }
+}
+
+/**
+ * \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;
+
+    if (UDD_EPCTRL_DATA_OUT == udd_ep_control_state) {
+        /* Host want to stop OUT transaction
+         * then stop to wait OUT data phase and wait IN ZLP handshake */
+        udd_ctrl_send_zlp_in();
+    } else if (UDD_EPCTRL_HANDSHAKE_WAIT_OUT_ZLP == udd_ep_control_state) {
+        /* A OUT handshake is waiting by device,
+         * but host want extra IN data then stall extra IN data */
+        usb_device_endpoint_set_halt(&usb_device, ep_callback_para->endpoint_address);
+    }
+}
+
+/**
+ * \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;
+
+    if (UDD_EPCTRL_DATA_IN == udd_ep_control_state) {
+        /* Host want to stop IN transaction
+         * then stop to wait IN data phase and wait OUT ZLP handshake */
+        udd_ep_control_state = UDD_EPCTRL_HANDSHAKE_WAIT_OUT_ZLP;
+    } else if (UDD_EPCTRL_HANDSHAKE_WAIT_IN_ZLP == udd_ep_control_state) {
+        /* A IN handshake is waiting by device,
+         * but host want extra OUT data then stall extra OUT data and following status stage */
+        usb_device_endpoint_set_halt(&usb_device, ep_callback_para->endpoint_address);
+    }
+}
+
+/**
+ * \internal
+ * \brief Control endpoint transfer fail callback function
+ * \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;
+
+    if(ep_callback_para->endpoint_address & USB_EP_DIR_IN) {
+        udd_ctrl_underflow(pointer);
+    } else {
+        udd_ctrl_overflow(pointer);
+    }
+}
+
+/**
+ * \internal
+ * \brief Control endpoint transfer complete callback function
+ * \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 */
+        udd_ctrl_out_received(pointer);
+    } else if (UDD_EPCTRL_DATA_IN == udd_ep_control_state) { /* handshake In for status stage */
+        udd_ctrl_in_sent();
+    } else {
+        if (NULL != udd_g_ctrlreq.callback) {
+            udd_g_ctrlreq.callback();
+        }
+        udd_ep_control_state = UDD_EPCTRL_SETUP;
+    }
+}
+
+/**
+ * \brief Enable Control Endpoint
+ * \param[in] module_inst Pointer to USB module instance
+ */
+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_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);
+
+#ifdef  USB_DEVICE_LPM_SUPPORT
+    // Enable LPM feature
+    usb_device_set_lpm_mode(module_inst, USB_DEVICE_LPM_ACK);
+#endif
+
+    udd_ep_control_state = UDD_EPCTRL_SETUP;
+}
+
+/**
+ * \internal
+ * \brief Control endpoint Suspend callback function
+ * \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)
+{
+    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);
+#ifdef UDC_SUSPEND_EVENT
+    UDC_SUSPEND_EVENT();
+#endif
+}
+
+#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;
+    lpm_wakeup_enable = (uint32_t *)pointer;
+
+    usb_device_disable_callback(&usb_device, USB_DEVICE_CALLBACK_LPMSUSP);
+    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
+    udd_sleep_mode(UDD_STATE_SUSPEND_LPM);  // Enter in LPM SUSPEND mode
+    if ((*lpm_wakeup_enable)) {
+        UDC_REMOTEWAKEUP_LPM_ENABLE();
+    }
+    if (!(*lpm_wakeup_enable)) {
+        UDC_REMOTEWAKEUP_LPM_DISABLE();
+    }
+    UDC_SUSPEND_LPM_EVENT();
+}
+#endif
+
+/**
+ * \internal
+ * \brief Control endpoint SOF callback function
+ * \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)
+{
+    udc_sof_notify();
+#ifdef UDC_SOF_EVENT
+    UDC_SOF_EVENT();
+#endif
+}
+
+/**
+ * \internal
+ * \brief Control endpoint Reset callback function
+ * \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)
+{
+    // Reset USB Device Stack Core
+    udc_reset();
+    usb_device_set_address(module_inst,0);
+    udd_ctrl_ep_enable(module_inst);
+}
+
+/**
+ * \internal
+ * \brief Control endpoint Wakeup callback function
+ * \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)
+{
+    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
+    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
+    udd_sleep_mode(UDD_STATE_IDLE);
+#ifdef UDC_RESUME_EVENT
+    UDC_RESUME_EVENT();
+#endif
+}
+
+void udd_detach(void)
+{
+    usb_device_detach(&usb_device);
+    udd_sleep_mode(UDD_STATE_SUSPEND);
+}
+
+void udd_attach(void)
+{
+    udd_sleep_mode(UDD_STATE_IDLE);
+    usb_device_attach(&usb_device);
+
+    usb_device_register_callback(&usb_device, USB_DEVICE_CALLBACK_SUSPEND, _usb_on_suspend);
+    usb_device_register_callback(&usb_device, USB_DEVICE_CALLBACK_SOF, _usb_on_sof_notify);
+    usb_device_register_callback(&usb_device, USB_DEVICE_CALLBACK_RESET, _usb_on_bus_reset);
+    usb_device_register_callback(&usb_device, USB_DEVICE_CALLBACK_WAKEUP, _usb_on_wakeup);
+
+    usb_device_enable_callback(&usb_device, USB_DEVICE_CALLBACK_SUSPEND);
+    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
+    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)
+{
+    uint32_t irqflags;
+
+    /* To avoid USB interrupt before end of initialization */
+    irqflags = __get_PRIMASK();
+    __disable_irq();
+    __DMB();
+
+    struct usb_config config_usb;
+
+    /* USB Module configuration */
+    usb_get_config_defaults(&config_usb);
+    config_usb.source_generator = UDD_CLOCK_GEN;
+    usb_init(&usb_device, USB, &config_usb);
+
+    /* USB Module Enable */
+    usb_enable(&usb_device);
+
+    /* Check clock after enable module, request the clock */
+    udd_wait_clock_ready();
+
+    udd_sleep_mode(UDD_STATE_SUSPEND);
+
+    // No VBus detect, assume always high
+#ifndef USB_DEVICE_ATTACH_AUTO_DISABLE
+    udd_attach();
+#endif
+
+    __DMB();
+    __set_PRIMASK(irqflags);
+}
+
+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
new file mode 100644
index 000000000..b7adaa1a7
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/usb/usb_main.h
@@ -0,0 +1,97 @@
+/**
+ * \file
+ *
+ * \brief Declaration of main function used by HID keyboard example
+ *
+ * Copyright (c) 2009-2015 Atmel Corporation. All rights reserved.
+ *
+ * \asf_license_start
+ *
+ * \page License
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. The name of Atmel may not be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * 4. This software may only be redistributed and used in connection with an
+ *    Atmel microcontroller product.
+ *
+ * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
+ * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * \asf_license_stop
+ *
+ */
+/*
+ * Support and FAQ: visit <a href="http://www.atmel.com/design-support/">Atmel Support</a>
+ */
+
+#ifndef _MAIN_H_
+#define _MAIN_H_
+
+//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
+void main_resume_action(void);
+
+//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
+void main_remotewakeup_enable(void);
+
+//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
+
+#ifdef NKRO
+extern volatile bool main_b_nkro_enable;
+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
+
+#ifdef MOU
+extern volatile bool main_b_mou_enable;
+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
+
+#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
new file mode 100644
index 000000000..892a7d3a5
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/usb/usb_protocol.h
@@ -0,0 +1,498 @@
+/**
+ * \file
+ *
+ * \brief USB protocol definitions.
+ *
+ * This file contains the USB definitions and data structures provided by the
+ * USB 2.0 specification.
+ *
+ * Copyright (c) 2009-2015 Atmel Corporation. All rights reserved.
+ *
+ * \asf_license_start
+ *
+ * \page License
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. The name of Atmel may not be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * 4. This software may only be redistributed and used in connection with an
+ *    Atmel microcontroller product.
+ *
+ * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
+ * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * \asf_license_stop
+ *
+ */
+/*
+ * Support and FAQ: visit <a href="http://www.atmel.com/design-support/">Atmel Support</a>
+ */
+
+#ifndef _USB_PROTOCOL_H_
+#define _USB_PROTOCOL_H_
+
+#include "usb_atmel.h"
+
+/**
+ * \ingroup usb_group
+ * \defgroup usb_protocol_group USB Protocol Definitions
+ *
+ * This module defines constants and data structures provided by the USB
+ * 2.0 specification.
+ *
+ * @{
+ */
+
+//! Value for field bcdUSB
+#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
+//! @}
+
+//! \name IAD (Interface Association Descriptor) constants
+//! @{
+#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
+
+/**
+ * \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
+
+/**
+ * \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
+
+/**
+ * \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_CONFIGURATION = 8,
+    USB_REQ_SET_CONFIGURATION = 9,
+    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
+};
+
+/**
+ * \brief Standard USB Interface status flags
+ *
+ */
+enum usb_interface_status {
+    USB_IFACE_STATUS_RESERVED = 0
+};
+
+/**
+ * \brief Standard USB endpoint status flags
+ *
+ */
+enum usb_endpoint_status {
+    USB_EP_STATUS_HALTED = 1,
+};
+
+/**
+ * \brief Standard USB device feature flags
+ *
+ * \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_OTG_A_ALT_HNP_SUPPORT = 5
+};
+
+/**
+ * \brief Test Mode possible on HS USB device
+ *
+ * \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_FORCE_ENABLE = 5,
+};
+
+/**
+ * \brief Standard USB endpoint feature/status flags
+ */
+enum usb_endpoint_feature {
+    USB_EP_FEATURE_HALT = 0,
+};
+
+/**
+ * \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_FORCE_ENABLE = 0x05,
+};
+
+/**
+ * \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_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,
+};
+
+/**
+ * \brief USB Device Capability types
+ */
+enum usb_capability_type {
+    USB_DC_USB20_EXTENSION = 0x02,
+};
+
+/**
+ * \brief USB Device Capability - USB 2.0 Extension
+ * To fill bmAttributes field of usb_capa_ext_desc_t structure.
+ */
+enum usb_capability_extension_attr {
+    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
+
+/** 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)
+
+/**
+ * \brief Standard USB endpoint transfer types
+ */
+enum usb_ep_type {
+    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,
+};
+
+/**
+ * \brief Standard USB language IDs for string descriptors
+ */
+enum usb_langid {
+    USB_LANGID_EN_US = 0x0409, //!< English (United States)
+};
+
+/**
+ * \brief Mask selecting the index part of an endpoint address
+ */
+#define  USB_EP_ADDR_MASK     0x0f
+
+//! \brief USB address identifier
+typedef uint8_t usb_add_t;
+
+/**
+ * \brief Endpoint transfer direction is IN
+ */
+#define  USB_EP_DIR_IN        0x80
+
+/**
+ * \brief Endpoint transfer direction is OUT
+ */
+#define  USB_EP_DIR_OUT       0x00
+
+//! \brief Endpoint identifier
+typedef uint8_t usb_ep_t;
+
+/**
+ * \brief Maximum length in bytes of a USB descriptor
+ *
+ * The maximum length of a USB descriptor is limited by the 8-bit
+ * bLength field.
+ */
+#define  USB_MAX_DESC_LEN     255
+
+/*
+ * 2-byte alignment requested for all USB structures.
+ */
+COMPILER_PACK_SET(1)
+
+/**
+ * \brief A USB Device SETUP request
+ *
+ * The data payload of SETUP packets always follows this structure.
+ */
+typedef struct {
+    uint8_t bmRequestType;
+    uint8_t bRequest;
+    le16_t wValue;
+    le16_t wIndex;
+    le16_t wLength;
+} usb_setup_req_t;
+
+/**
+ * \brief Standard USB device descriptor structure
+ */
+typedef struct {
+    uint8_t bLength;
+    uint8_t bDescriptorType;
+    le16_t bcdUSB;
+    uint8_t bDeviceClass;
+    uint8_t bDeviceSubClass;
+    uint8_t bDeviceProtocol;
+    uint8_t bMaxPacketSize0;
+    le16_t idVendor;
+    le16_t idProduct;
+    le16_t bcdDevice;
+    uint8_t iManufacturer;
+    uint8_t iProduct;
+    uint8_t iSerialNumber;
+    uint8_t bNumConfigurations;
+} usb_dev_desc_t;
+
+/**
+ * \brief Standard USB device qualifier descriptor structure
+ *
+ * This descriptor contains information about the device when running at
+ * the "other" speed (i.e. if the device is currently operating at high
+ * speed, this descriptor can be used to determine what would change if
+ * the device was operating at full speed.)
+ */
+typedef struct {
+    uint8_t bLength;
+    uint8_t bDescriptorType;
+    le16_t bcdUSB;
+    uint8_t bDeviceClass;
+    uint8_t bDeviceSubClass;
+    uint8_t bDeviceProtocol;
+    uint8_t bMaxPacketSize0;
+    uint8_t bNumConfigurations;
+    uint8_t bReserved;
+} usb_dev_qual_desc_t;
+
+/**
+ * \brief USB Device BOS descriptor structure
+ *
+ * The BOS descriptor (Binary device Object Store) defines a root
+ * descriptor that is similar to the configuration descriptor, and is
+ * the base descriptor for accessing a family of related descriptors.
+ * A host can read a BOS descriptor and learn from the wTotalLength field
+ * the entire size of the device-level descriptor set, or it can read in
+ * the entire BOS descriptor set of device capabilities.
+ * The host accesses this descriptor using the GetDescriptor() request.
+ * The descriptor type in the GetDescriptor() request is set to BOS.
+ */
+typedef struct {
+    uint8_t bLength;
+    uint8_t bDescriptorType;
+    le16_t  wTotalLength;
+    uint8_t bNumDeviceCaps;
+} usb_dev_bos_desc_t;
+
+
+/**
+ * \brief USB Device Capabilities - USB 2.0 Extension Descriptor structure
+ *
+ * Defines the set of USB 1.1-specific device level capabilities.
+ */
+typedef struct {
+    uint8_t bLength;
+    uint8_t bDescriptorType;
+    uint8_t bDevCapabilityType;
+    le32_t  bmAttributes;
+} usb_dev_capa_ext_desc_t;
+
+/**
+ * \brief USB Device LPM Descriptor structure
+ *
+ * The BOS descriptor and capabilities descriptors for LPM.
+ */
+typedef struct {
+    usb_dev_bos_desc_t bos;
+    usb_dev_capa_ext_desc_t capa_ext;
+} usb_dev_lpm_desc_t;
+
+/**
+ * \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
+} usb_association_desc_t;
+
+
+/**
+ * \brief Standard USB configuration descriptor structure
+ */
+typedef struct {
+    uint8_t bLength;
+    uint8_t bDescriptorType;
+    le16_t wTotalLength;
+    uint8_t bNumInterfaces;
+    uint8_t bConfigurationValue;
+    uint8_t iConfiguration;
+    uint8_t bmAttributes;
+    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_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
+} usb_iad_desc_t;
+
+/**
+ * \brief Standard USB interface descriptor structure
+ */
+typedef struct {
+    uint8_t bLength;
+    uint8_t bDescriptorType;
+    uint8_t bInterfaceNumber;
+    uint8_t bAlternateSetting;
+    uint8_t bNumEndpoints;
+    uint8_t bInterfaceClass;
+    uint8_t bInterfaceSubClass;
+    uint8_t bInterfaceProtocol;
+    uint8_t iInterface;
+} usb_iface_desc_t;
+
+/**
+ * \brief Standard USB endpoint descriptor structure
+ */
+typedef struct {
+    uint8_t bLength;
+    uint8_t bDescriptorType;
+    uint8_t bEndpointAddress;
+    uint8_t bmAttributes;
+    le16_t wMaxPacketSize;
+    uint8_t bInterval;
+} usb_ep_desc_t;
+
+
+/**
+ * \brief A standard USB string descriptor structure
+ */
+typedef struct {
+    uint8_t bLength;
+    uint8_t bDescriptorType;
+} usb_str_desc_t;
+
+typedef struct {
+    usb_str_desc_t desc;
+    le16_t string[1];
+} usb_str_lgid_desc_t;
+
+COMPILER_PACK_RESET()
+
+//! @}
+
+#endif /* _USB_PROTOCOL_H_ */
diff --git a/tmk_core/protocol/arm_atsam/usb/usb_protocol_cdc.h b/tmk_core/protocol/arm_atsam/usb/usb_protocol_cdc.h
new file mode 100644
index 000000000..479f25d4e
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/usb/usb_protocol_cdc.h
@@ -0,0 +1,193 @@
+/**
+ * \file
+ *
+ * \brief USB Communication Device Class (CDC) protocol definitions
+ *
+ * Copyright (c) 2009-2015 Atmel Corporation. All rights reserved.
+ *
+ * \asf_license_start
+ *
+ * \page License
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. The name of Atmel may not be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * 4. This software may only be redistributed and used in connection with an
+ *    Atmel microcontroller product.
+ *
+ * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
+ * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * \asf_license_stop
+ *
+ */
+/*
+ * Support and FAQ: visit <a href="http://www.atmel.com/design-support/">Atmel Support</a>
+ */
+#ifndef _USB_PROTOCOL_CDC_H_
+#define _USB_PROTOCOL_CDC_H_
+
+#include "compiler.h"
+
+#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
+// 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)
+typedef struct {
+    le32_t dwDTERate;
+    uint8_t bCharFormat;
+    uint8_t bParityType;
+    uint8_t bDataBits;
+} usb_cdc_line_coding_t;
+#pragma pack(pop)
+
+enum cdc_char_format {
+    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
+};
+
+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_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)
+
+
+typedef struct {
+    uint8_t bmRequestType;
+    uint8_t bNotification;
+    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;
+} 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))
+
+#endif
+
+#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
new file mode 100644
index 000000000..c482e9c06
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/usb/usb_protocol_hid.h
@@ -0,0 +1,319 @@
+/**
+ * \file
+ *
+ * \brief USB Human Interface Device (HID) protocol definitions.
+ *
+ * Copyright (c) 2009-2015 Atmel Corporation. All rights reserved.
+ *
+ * \asf_license_start
+ *
+ * \page License
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. The name of Atmel may not be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * 4. This software may only be redistributed and used in connection with an
+ *    Atmel microcontroller product.
+ *
+ * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
+ * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * \asf_license_stop
+ *
+ */
+/*
+ * Support and FAQ: visit <a href="http://www.atmel.com/design-support/">Atmel Support</a>
+ */
+
+#ifndef _USB_PROTOCOL_HID_H_
+#define _USB_PROTOCOL_HID_H_
+
+/**
+ * \ingroup usb_protocol_group
+ * \defgroup usb_hid_protocol USB Human Interface Device (HID)
+ * protocol definitions
+ * \brief USB Human Interface Device (HID) protocol definitions
+ *
+ * @{
+ */
+
+//! \name Possible Class value
+//@{
+#define  HID_CLASS                            0x03
+//@}
+
+//! \name Possible SubClass value
+//@{
+//! Interface subclass NO support BOOT protocol
+#define  HID_SUB_CLASS_NOBOOT                 0x00
+//! Interface subclass support BOOT protocol
+#define  HID_SUB_CLASS_BOOT                   0x01
+//@}
+
+//! \name Possible protocol value
+//@{
+//! Protocol generic standard
+#define  HID_PROTOCOL_GENERIC                 0x00
+//! Protocol keyboard standard
+#define  HID_PROTOCOL_KEYBOARD                0x01
+//! Protocol mouse standard
+#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_PROTOCOL = 0x03,
+    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_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_GLOBAL = 1,
+    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_FEATURE = 3,
+};
+
+
+//! \brief HID protocol
+enum usb_hid_protocol {
+    USB_HID_PROCOTOL_BOOT = 0,
+    USB_HID_PROCOTOL_REPORT = 1,
+};
+
+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
+} 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 Constants of field DESCRIPTOR_HID
+   //! @{
+//! Numeric expression identifying the HID Class
+//! Specification release (here V1.11)
+#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
+
+      //! \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
+
+   //! \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)
+//! @}
+
+#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
new file mode 100644
index 000000000..58b349362
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/usb/usb_util.c
@@ -0,0 +1,59 @@
+#include "samd51j18a.h"
+#include "string.h"
+#include "usb_util.h"
+
+char digit(int d, int radix)
+{
+    if (d < 10)
+    {
+        return d + '0';
+    }
+    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;
+
+    if (value < 0)                  //if it's negative, take the absolute value
+        value = -value;
+
+    do                              //write least significant digit of value that's left
+    {
+        d = (value % radix);
+        buf[--c] = digit(d, radix);
+        value /= radix;
+    } while (value);
+
+    if (original < 0)
+        buf[--c] = '-';
+
+    size = last - c + 1;            //includes null at end
+    memcpy(dest, &buf[c], last - c + 1);
+
+    return (size - 1);              //without null termination
+}
+
+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);
+}
+
diff --git a/tmk_core/protocol/arm_atsam/usb/usb_util.h b/tmk_core/protocol/arm_atsam/usb/usb_util.h
new file mode 100644
index 000000000..2134d5d27
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/usb/usb_util.h
@@ -0,0 +1,10 @@
+#ifndef _USB_UTIL_H_
+#define _USB_UTIL_H_
+
+int UTIL_ltoa_radix(int64_t value, char *dest, int radix);
+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_
+
diff --git a/tmk_core/protocol/arm_atsam/wait_api.h b/tmk_core/protocol/arm_atsam/wait_api.h
new file mode 100644
index 000000000..424fbb53b
--- /dev/null
+++ b/tmk_core/protocol/arm_atsam/wait_api.h
@@ -0,0 +1,8 @@
+#ifndef _wait_api_h_
+#define _wait_api_h_
+
+void wait_ms(uint64_t msec);
+void wait_us(uint16_t usec);
+
+#endif
+