Merge branch 'master' of https://github.com/jackhumbert/qmk_firmware

34 files changed, 3718 insertions, 333 deletions

diff --git a/tmk_core/avr.mk b/tmk_core/avr.mk
new file mode 100644
index 0000000000..72be5e6da1
--- /dev/null
+++ b/tmk_core/avr.mk
@@ -0,0 +1,185 @@
+# Hey Emacs, this is a -*- makefile -*-
+##############################################################################
+# Compiler settings
+#
+CC = avr-gcc
+OBJCOPY = avr-objcopy
+OBJDUMP = avr-objdump
+SIZE = avr-size
+AR = avr-ar rcs
+NM = avr-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) 
+
+
+
+COMPILEFLAGS += -funsigned-char
+COMPILEFLAGS += -funsigned-bitfields
+COMPILEFLAGS += -ffunction-sections
+COMPILEFLAGS += -fdata-sections
+COMPILEFLAGS += -fpack-struct
+COMPILEFLAGS += -fshort-enums
+
+CFLAGS += $(COMPILEFLAGS)
+CFLAGS += -fno-inline-small-functions
+CFLAGS += -fno-strict-aliasing
+
+CPPFLAGS += $(COMPILEFLAGS)
+CPPFLAGS += -fno-exceptions
+
+LDFLAGS +=-Wl,--gc-sections
+
+OPT_DEFS += -DF_CPU=$(F_CPU)UL
+
+MCUFLAGS = -mmcu=$(MCU)
+
+# 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 =
+
+
+#---------------- External Memory Options ----------------
+
+# 64 KB of external RAM, starting after internal RAM (ATmega128!),
+# used for variables (.data/.bss) and heap (malloc()).
+#EXTMEMOPTS = -Wl,-Tdata=0x801100,--defsym=__heap_end=0x80ffff
+
+# 64 KB of external RAM, starting after internal RAM (ATmega128!),
+# only used for heap (malloc()).
+#EXTMEMOPTS = -Wl,--section-start,.data=0x801100,--defsym=__heap_end=0x80ffff
+
+EXTMEMOPTS =
+
+#---------------- Debugging Options ----------------
+
+# Debugging format.
+#     Native formats for AVR-GCC's -g are dwarf-2 [default] or stabs.
+#     AVR Studio 4.10 requires dwarf-2.
+#     AVR [Extended] COFF format requires stabs, plus an avr-objcopy run.
+DEBUG = dwarf-2
+
+# For simulavr only - target MCU frequency.
+DEBUG_MFREQ = $(F_CPU)
+
+# Set the DEBUG_UI to either gdb or insight.
+# DEBUG_UI = gdb
+DEBUG_UI = insight
+
+# Set the debugging back-end to either avarice, simulavr.
+DEBUG_BACKEND = avarice
+#DEBUG_BACKEND = simulavr
+
+# GDB Init Filename.
+GDBINIT_FILE = __avr_gdbinit
+
+# When using avarice settings for the JTAG
+JTAG_DEV = /dev/com1
+
+# Debugging port used to communicate between GDB / avarice / simulavr.
+DEBUG_PORT = 4242
+
+# Debugging host used to communicate between GDB / avarice / simulavr, normally
+#     just set to localhost unless doing some sort of crazy debugging when
+#     avarice is running on a different computer.
+DEBUG_HOST = localhost
+
+#============================================================================
+# Autodecct teensy loader
+ifneq (, $(shell which teensy-loader-cli 2>/dev/null))
+  TEENSY_LOADER_CLI = teensy-loader-cli
+else
+  TEENSY_LOADER_CLI = teensy_loader_cli
+endif
+
+# Program the device.
+program: $(BUILD_DIR)/$(TARGET).hex $(BUILD_DIR)/$(TARGET).eep
+	$(PROGRAM_CMD)
+
+teensy: $(BUILD_DIR)/$(TARGET).hex
+	$(TEENSY_LOADER_CLI) -mmcu=$(MCU) -w -v $(BUILD_DIR)/$(TARGET).hex
+
+flip: $(BUILD_DIR)/$(TARGET).hex
+	batchisp -hardware usb -device $(MCU) -operation erase f
+	batchisp -hardware usb -device $(MCU) -operation loadbuffer $(BUILD_DIR)/$(TARGET).hex program
+	batchisp -hardware usb -device $(MCU) -operation start reset 0
+
+dfu: $(BUILD_DIR)/$(TARGET).hex sizeafter
+ifneq (, $(findstring 0.7, $(shell dfu-programmer --version 2>&1)))
+	dfu-programmer $(MCU) erase --force
+else
+	dfu-programmer $(MCU) erase
+endif
+	dfu-programmer $(MCU) flash $(BUILD_DIR)/$(TARGET).hex
+	dfu-programmer $(MCU) reset
+
+dfu-start:
+	dfu-programmer $(MCU) reset
+	dfu-programmer $(MCU) start
+
+flip-ee: $(BUILD_DIR)/$(TARGET).hex $(BUILD_DIR)/$(TARGET).eep
+	$(COPY) $(BUILD_DIR)/$(TARGET).eep $(BUILD_DIR)/$(TARGET)eep.hex
+	batchisp -hardware usb -device $(MCU) -operation memory EEPROM erase
+	batchisp -hardware usb -device $(MCU) -operation memory EEPROM loadbuffer $(BUILD_DIR)/$(TARGET)eep.hex program
+	batchisp -hardware usb -device $(MCU) -operation start reset 0
+	$(REMOVE) $(BUILD_DIR)/$(TARGET)eep.hex
+
+dfu-ee: $(BUILD_DIR)/$(TARGET).hex $(BUILD_DIR)/$(TARGET).eep
+ifneq (, $(findstring 0.7, $(shell dfu-programmer --version 2>&1)))
+	dfu-programmer $(MCU) flash --eeprom $(BUILD_DIR)/$(TARGET).eep
+else
+	dfu-programmer $(MCU) flash-eeprom $(BUILD_DIR)/$(TARGET).eep
+endif
+	dfu-programmer $(MCU) reset
+
+
+# Generate avr-gdb config/init file which does the following:
+#     define the reset signal, load the target file, connect to target, and set
+#     a breakpoint at main().
+gdb-config:
+	@$(REMOVE) $(GDBINIT_FILE)
+	@echo define reset >> $(GDBINIT_FILE)
+	@echo SIGNAL SIGHUP >> $(GDBINIT_FILE)
+	@echo end >> $(GDBINIT_FILE)
+	@echo file $(BUILD_DIR)/$(TARGET).elf >> $(GDBINIT_FILE)
+	@echo target remote $(DEBUG_HOST):$(DEBUG_PORT)  >> $(GDBINIT_FILE)
+ifeq ($(DEBUG_BACKEND),simulavr)
+	@echo load  >> $(GDBINIT_FILE)
+endif
+	@echo break main >> $(GDBINIT_FILE)
+
+debug: gdb-config $(BUILD_DIR)/$(TARGET).elf
+ifeq ($(DEBUG_BACKEND), avarice)
+	@echo Starting AVaRICE - Press enter when "waiting to connect" message displays.
+	@$(WINSHELL) /c start avarice --jtag $(JTAG_DEV) --erase --program --file \
+	$(BUILD_DIR)/$(TARGET).elf $(DEBUG_HOST):$(DEBUG_PORT)
+	@$(WINSHELL) /c pause
+
+else
+	@$(WINSHELL) /c start simulavr --gdbserver --device $(MCU) --clock-freq \
+	$(DEBUG_MFREQ) --port $(DEBUG_PORT)
+endif
+	@$(WINSHELL) /c start avr-$(DEBUG_UI) --command=$(GDBINIT_FILE)
+
+
+
+
+# Convert ELF to COFF for use in debugging / simulating in AVR Studio or VMLAB.
+COFFCONVERT = $(OBJCOPY) --debugging
+COFFCONVERT += --change-section-address .data-0x800000
+COFFCONVERT += --change-section-address .bss-0x800000
+COFFCONVERT += --change-section-address .noinit-0x800000
+COFFCONVERT += --change-section-address .eeprom-0x810000
+
+
+
+coff: $(BUILD_DIR)/$(TARGET).elf
+	@$(SECHO) $(MSG_COFF) $(BUILD_DIR)/$(TARGET).cof
+	$(COFFCONVERT) -O coff-avr $< $(BUILD_DIR)/$(TARGET).cof
+
+
+extcoff: $(BUILD_DIR)/$(TARGET).elf
+	@$(SECHO) $(MSG_EXTENDED_COFF) $(BUILD_DIR)/$(TARGET).cof
+	$(COFFCONVERT) -O coff-ext-avr $< $(BUILD_DIR)/$(TARGET).cof
+
diff --git a/tmk_core/chibios.mk b/tmk_core/chibios.mk
new file mode 100644
index 0000000000..0abb933a8d
--- /dev/null
+++ b/tmk_core/chibios.mk
@@ -0,0 +1,154 @@
+# Hey Emacs, this is a -*- makefile -*-
+##############################################################################
+# Architecture or project specific options
+#
+
+# Stack size to be allocated to the Cortex-M process stack. This stack is
+# the stack used by the main() thread.
+ifeq ($(USE_PROCESS_STACKSIZE),)
+  USE_PROCESS_STACKSIZE = 0x200
+endif
+
+# Stack size to the allocated to the Cortex-M main/exceptions stack. This
+# stack is used for processing interrupts and exceptions.
+ifeq ($(USE_EXCEPTIONS_STACKSIZE),)
+  USE_EXCEPTIONS_STACKSIZE = 0x400
+endif
+
+#
+# Architecture or project specific options
+##############################################################################
+
+##############################################################################
+# Project, sources and paths
+#
+
+# Imported source files and paths
+CHIBIOS = $(TOP_DIR)/lib/chibios
+CHIBIOS_CONTRIB = $(TOP_DIR)/lib/chibios-contrib
+# Startup files. Try a few different locations, for compability with old versions and 
+# for things hardware in the contrib repository
+STARTUP_MK = $(CHIBIOS)/os/common/ports/ARMCMx/compilers/GCC/mk/startup_$(MCU_STARTUP).mk
+ifeq ("$(wildcard $(STARTUP_MK))","")
+	STARTUP_MK = $(CHIBIOS)/os/common/startup/ARMCMx/compilers/GCC/mk/startup_$(MCU_STARTUP).mk
+	ifeq ("$(wildcard $(STARTUP_MK))","")
+		STARTUP_MK = $(CHIBIOS_CONTRIB)/os/common/startup/ARMCMx/compilers/GCC/mk/startup_$(MCU_STARTUP).mk
+	endif
+endif
+include $(STARTUP_MK)
+# HAL-OSAL files (optional).
+include $(CHIBIOS)/os/hal/hal.mk
+
+PLATFORM_MK = $(CHIBIOS)/os/hal/ports/$(MCU_FAMILY)/$(MCU_SERIES)/platform.mk
+ifeq ("$(wildcard $(PLATFORM_MK))","")
+PLATFORM_MK = $(CHIBIOS_CONTRIB)/os/hal/ports/$(MCU_FAMILY)/$(MCU_SERIES)/platform.mk
+endif
+include $(PLATFORM_MK)
+
+
+BOARD_MK = $(KEYBOARD_PATH)/boards/$(BOARD)/board.mk
+ifeq ("$(wildcard $(BOARD_MK))","")
+	BOARD_MK = $(CHIBIOS)/os/hal/boards/$(BOARD)/board.mk
+	ifeq ("$(wildcard $(BOARD_MK))","")
+		BOARD_MK = $(CHIBIOS_CONTRIB)/os/hal/boards/$(BOARD)/board.mk
+	endif
+endif
+include $(BOARD_MK)
+include $(CHIBIOS)/os/hal/osal/rt/osal.mk
+# RTOS files (optional).
+include $(CHIBIOS)/os/rt/rt.mk
+# Compability with old version
+PORT_V = $(CHIBIOS)/os/rt/ports/ARMCMx/compilers/GCC/mk/port_v$(ARMV)m.mk
+ifeq ("$(wildcard $(PORT_V))","")
+PORT_V = $(CHIBIOS)/os/common/ports/ARMCMx/compilers/GCC/mk/port_v$(ARMV)m.mk
+endif
+include $(PORT_V)
+# Other files (optional).
+include $(CHIBIOS)/os/hal/lib/streams/streams.mk
+
+RULESPATH = $(CHIBIOS)/os/common/ports/ARMCMx/compilers/GCC
+ifeq ("$(wildcard $(RULESPATH)/rules.mk)","")
+RULESPATH = $(CHIBIOS)/os/common/startup/ARMCMx/compilers/GCC
+endif
+
+# Define linker script file here
+ifneq ("$(wildcard $(KEYBOARD_PATH)/ld/$(MCU_LDSCRIPT).ld)","")
+LDSCRIPT = $(KEYBOARD_PATH)/ld/$(MCU_LDSCRIPT).ld
+else
+LDSCRIPT = $(STARTUPLD)/$(MCU_LDSCRIPT).ld
+endif
+
+CHIBISRC = $(STARTUPSRC) \
+       $(KERNSRC) \
+       $(PORTSRC) \
+       $(OSALSRC) \
+       $(HALSRC) \
+       $(PLATFORMSRC) \
+       $(BOARDSRC) \
+       $(STREAMSSRC) \
+	   $(STARTUPASM) \
+	   $(PORTASM) \
+	   $(OSALASM)         
+	   
+SRC += $(patsubst $(TOP_DIR)/%,%,$(CHIBISRC))
+
+EXTRAINCDIRS += $(CHIBIOS)/os/license \
+         $(STARTUPINC) $(KERNINC) $(PORTINC) $(OSALINC) \
+         $(HALINC) $(PLATFORMINC) $(BOARDINC) $(TESTINC) \
+         $(STREAMSINC) $(CHIBIOS)/os/various 
+
+#
+# Project, sources and paths
+##############################################################################
+
+
+##############################################################################
+# 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
+NM = arm-none-eabi-nm
+HEX = $(OBJCOPY) -O $(FORMAT)
+EEP = 
+
+THUMBFLAGS = -DTHUMB_PRESENT -mno-thumb-interwork -DTHUMB_NO_INTERWORKING -mthumb -DTHUMB 
+
+COMPILEFLAGS += -fomit-frame-pointer 
+COMPILEFLAGS += -falign-functions=16
+COMPILEFLAGS += -ffunction-sections
+COMPILEFLAGS += -fdata-sections
+COMPILEFLAGS += -fno-common
+COMPILEFLAGS += $(THUMBFLAGS) 
+
+CFLAGS += $(COMPILEFLAGS)
+
+ASFLAGS += $(THUMBFLAGS)
+
+CPPFLAGS += $(COMPILEFLAGS)
+CPPFLAGS += -fno-rtti
+
+LDFLAGS +=-Wl,--gc-sections
+LDFLAGS += -mno-thumb-interwork -mthumb
+LDSYMBOLS =,--defsym=__process_stack_size__=$(USE_PROCESS_STACKSIZE)
+LDSYMBOLS :=$(LDSYMBOLS),--defsym=__main_stack_size__=$(USE_EXCEPTIONS_STACKSIZE)
+LDFLAGS += -Wl,--script=$(LDSCRIPT)$(LDSYMBOLS)
+
+OPT_DEFS += -DPROTOCOL_CHIBIOS
+
+MCUFLAGS = -mcpu=$(MCU)
+
+DEBUG = gdb
+
+# Define ASM defines here
+# bootloader definitions may be used in the startup .s file
+ifneq ("$(wildcard $(KEYBOARD_PATH)/bootloader_defs.h)","")
+    OPT_DEFS += -include $(KEYBOARD_PATH)/bootloader_defs.h
+else ifneq ("$(wildcard $(KEYBOARD_PATH)/boards/$(BOARD)/bootloader_defs.h)","")
+    OPT_DEFS += -include $(KEYBOARD_PATH)/boards/$(BOARD)/bootloader_defs.h
+endif
+
+# List any extra directories to look for libraries here.
+EXTRALIBDIRS = $(RULESPATH)/ld
\ No newline at end of file
diff --git a/tmk_core/common.mk b/tmk_core/common.mk
index f2a22e4f8c..d71fba9bc1 100644
--- a/tmk_core/common.mk
+++ b/tmk_core/common.mk
@@ -1,4 +1,10 @@
 COMMON_DIR = common
+ifeq ($(PLATFORM),AVR)
+	PLATFORM_COMMON_DIR = $(COMMON_DIR)/avr
+else ifeq ($(PLATFORM),CHIBIOS)
+	PLATFORM_COMMON_DIR = $(COMMON_DIR)/chibios
+endif
+
 SRC +=	$(COMMON_DIR)/host.c \
 	$(COMMON_DIR)/keyboard.c \
 	$(COMMON_DIR)/action.c \
@@ -9,21 +15,29 @@ SRC +=	$(COMMON_DIR)/host.c \
 	$(COMMON_DIR)/print.c \
 	$(COMMON_DIR)/debug.c \
 	$(COMMON_DIR)/util.c \
-	$(COMMON_DIR)/avr/suspend.c \
-	$(COMMON_DIR)/avr/xprintf.S \
-	$(COMMON_DIR)/avr/timer.c \
-	$(COMMON_DIR)/avr/bootloader.c
+	$(COMMON_DIR)/eeconfig.c \
+	$(PLATFORM_COMMON_DIR)/suspend.c \
+	$(PLATFORM_COMMON_DIR)/timer.c \
+	$(PLATFORM_COMMON_DIR)/bootloader.c \
+
+ifeq ($(PLATFORM),AVR)
+	SRC += $(PLATFORM_COMMON_DIR)/xprintf.S
+endif 
+
+ifeq ($(PLATFORM),CHIBIOS)
+	SRC += $(PLATFORM_COMMON_DIR)/printf.c
+	SRC += $(PLATFORM_COMMON_DIR)/eeprom.c
+endif
+
 
 
 # Option modules
 ifeq ($(strip $(BOOTMAGIC_ENABLE)), yes)
     OPT_DEFS += -DBOOTMAGIC_ENABLE
     SRC += $(COMMON_DIR)/bootmagic.c
-    SRC += $(COMMON_DIR)/avr/eeconfig.c
 else
     OPT_DEFS += -DMAGIC_ENABLE
     SRC += $(COMMON_DIR)/magic.c
-    SRC += $(COMMON_DIR)/avr/eeconfig.c
 endif
 
 ifeq ($(strip $(MOUSEKEY_ENABLE)), yes)
@@ -57,14 +71,13 @@ ifeq ($(strip $(USB_6KRO_ENABLE)), yes)
 endif
 
 ifeq ($(strip $(SLEEP_LED_ENABLE)), yes)
-    SRC += $(COMMON_DIR)/sleep_led.c
+    SRC += $(PLATFORM_COMMON_DIR)/sleep_led.c
     OPT_DEFS += -DSLEEP_LED_ENABLE
     OPT_DEFS += -DNO_SUSPEND_POWER_DOWN
 endif
 
 ifeq ($(strip $(BACKLIGHT_ENABLE)), yes)
     SRC += $(COMMON_DIR)/backlight.c
-    SRC += $(COMMON_DIR)/avr/eeconfig.c
     OPT_DEFS += -DBACKLIGHT_ENABLE
 endif
 
@@ -87,6 +100,13 @@ endif
 # Version string
 OPT_DEFS += -DVERSION=$(shell (git describe --always --dirty || echo 'unknown') 2> /dev/null)
 
+# Bootloader address
+ifdef STM32_BOOTLOADER_ADDRESS
+    OPT_DEFS += -DSTM32_BOOTLOADER_ADDRESS=$(STM32_BOOTLOADER_ADDRESS)
+endif
 
 # Search Path
 VPATH += $(TMK_PATH)/$(COMMON_DIR)
+ifeq ($(PLATFORM),CHIBIOS)
+VPATH += $(TMK_PATH)/$(COMMON_DIR)/chibios
+endif
\ No newline at end of file
diff --git a/tmk_core/common/action_tapping.c b/tmk_core/common/action_tapping.c
index ff78d7f2ab..e16e11be7f 100644
--- a/tmk_core/common/action_tapping.c
+++ b/tmk_core/common/action_tapping.c
@@ -257,7 +257,7 @@ bool process_tapping(keyrecord_t *keyp)
                     return true;
                 }
             } else {
-                if (!IS_NOEVENT(event)) debug("Tapping: other key just after tap.\n");
+                if (!IS_NOEVENT(event)) debug("Tapping: other key just after tap.\n") {};
                 process_record(keyp);
                 return true;
             }
diff --git a/tmk_core/common/sleep_led.c b/tmk_core/common/avr/sleep_led.c
index dab3eb0f3c..dab3eb0f3c 100644
--- a/tmk_core/common/sleep_led.c
+++ b/tmk_core/common/avr/sleep_led.c
diff --git a/tmk_core/common/avr/suspend.c b/tmk_core/common/avr/suspend.c
index a6f3c64414..8a7272bbc5 100644
--- a/tmk_core/common/avr/suspend.c
+++ b/tmk_core/common/avr/suspend.c
@@ -114,8 +114,10 @@ bool suspend_wakeup_condition(void)
     matrix_power_up();
     matrix_scan();
     matrix_power_down();
-    if (matrix_key_count()) return true;
-    return false;
+    for (uint8_t r = 0; r < MATRIX_ROWS; r++) {
+        if (matrix_get_row(r)) return true;
+    }
+     return false;
 }
 
 // run immediately after wakeup
diff --git a/tmk_core/common/bootmagic.c b/tmk_core/common/bootmagic.c
index 30e8a0f20f..6730a2a4aa 100644
--- a/tmk_core/common/bootmagic.c
+++ b/tmk_core/common/bootmagic.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <stdbool.h>
-#include <util/delay.h>
+#include "wait.h"
 #include "matrix.h"
 #include "bootloader.h"
 #include "debug.h"
@@ -10,6 +10,7 @@
 #include "eeconfig.h"
 #include "bootmagic.h"
 
+keymap_config_t keymap_config;
 
 void bootmagic(void)
 {
@@ -19,9 +20,9 @@ void bootmagic(void)
     }
 
     /* do scans in case of bounce */
-    print("boogmagic scan: ... ");
+    print("bootmagic scan: ... ");
     uint8_t scan = 100;
-    while (scan--) { matrix_scan(); _delay_ms(10); }
+    while (scan--) { matrix_scan(); wait_ms(10); }
     print("done.\n");
 
     /* bootmagic skip */
@@ -105,13 +106,15 @@ void bootmagic(void)
     }
 }
 
-static bool scan_keycode(uint8_t keycode) {
-    for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
+static bool scan_keycode(uint8_t keycode)
+{
+    for (uint8_t r = 0; r < MATRIX_ROWS; r++) {
         matrix_row_t matrix_row = matrix_get_row(r);
-        for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) {
-            if (matrix_row & (matrix_row_t)1 << c) {
-                keypos_t key = (keypos_t){ .row = r, .col = c };
-                if (keycode == keymap_key_to_keycode(0, key)) return true;
+        for (uint8_t c = 0; c < MATRIX_COLS; c++) {
+            if (matrix_row & ((matrix_row_t)1<<c)) {
+                if (keycode == keymap_key_to_keycode(0, (keypos_t){ .row = r, .col = c })) {
+                    return true;
+                }
             }
         }
     }
@@ -123,4 +126,4 @@ bool bootmagic_scan_keycode(uint8_t keycode)
     if (!scan_keycode(BOOTMAGIC_KEY_SALT)) return false;
 
     return scan_keycode(keycode);
-}
+}
\ No newline at end of file
diff --git a/tmk_core/common/chibios/bootloader.c b/tmk_core/common/chibios/bootloader.c
new file mode 100644
index 0000000000..8a533ab6f6
--- /dev/null
+++ b/tmk_core/common/chibios/bootloader.c
@@ -0,0 +1,47 @@
+#include "bootloader.h"
+
+#include "ch.h"
+#include "hal.h"
+
+#ifdef STM32_BOOTLOADER_ADDRESS
+/* STM32 */
+
+#if defined(STM32F0XX)
+/* This code should be checked whether it runs correctly on platforms */
+#define SYMVAL(sym) (uint32_t)(((uint8_t *)&(sym)) - ((uint8_t *)0))
+extern uint32_t __ram0_end__;
+
+void bootloader_jump(void) {
+  *((unsigned long *)(SYMVAL(__ram0_end__) - 4)) = 0xDEADBEEF; // set magic flag => reset handler will jump into boot loader
+   NVIC_SystemReset();
+}
+
+#else /* defined(STM32F0XX) */
+#error Check that the bootloader code works on your platform and add it to bootloader.c!
+#endif /* defined(STM32F0XX) */
+
+#elif defined(KL2x) || defined(K20x) /* STM32_BOOTLOADER_ADDRESS */
+/* Kinetis */
+
+#if defined(KIIBOHD_BOOTLOADER)
+/* Kiibohd Bootloader (MCHCK and Infinity KB) */
+#define SCB_AIRCR_VECTKEY_WRITEMAGIC 0x05FA0000
+const uint8_t sys_reset_to_loader_magic[] = "\xff\x00\x7fRESET TO LOADER\x7f\x00\xff";
+void bootloader_jump(void) {
+  __builtin_memcpy((void *)VBAT, (const void *)sys_reset_to_loader_magic, sizeof(sys_reset_to_loader_magic));
+  // request reset
+  SCB->AIRCR = SCB_AIRCR_VECTKEY_WRITEMAGIC | SCB_AIRCR_SYSRESETREQ_Msk;
+}
+
+#else /* defined(KIIBOHD_BOOTLOADER) */
+/* Default for Kinetis - expecting an ARM Teensy */
+void bootloader_jump(void) {
+	chThdSleepMilliseconds(100);
+	__BKPT(0);
+}
+#endif /* defined(KIIBOHD_BOOTLOADER) */
+
+#else /* neither STM32 nor KINETIS */
+__attribute__((weak))
+void bootloader_jump(void) {}
+#endif
\ No newline at end of file
diff --git a/tmk_core/common/chibios/eeprom.c b/tmk_core/common/chibios/eeprom.c
new file mode 100644
index 0000000000..5ff8ee86f4
--- /dev/null
+++ b/tmk_core/common/chibios/eeprom.c
@@ -0,0 +1,588 @@
+#include "ch.h"
+#include "hal.h"
+
+#include "eeconfig.h"
+
+/*************************************/
+/*          Hardware backend         */
+/*                                   */
+/*    Code from PJRC/Teensyduino     */
+/*************************************/
+
+/* Teensyduino Core Library
+ * http://www.pjrc.com/teensy/
+ * Copyright (c) 2013 PJRC.COM, LLC.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * 1. The above copyright notice and this permission notice shall be 
+ * included in all copies or substantial portions of the Software.
+ *
+ * 2. If the Software is incorporated into a build system that allows 
+ * selection among a list of target devices, then similar target
+ * devices manufactured by PJRC.COM must be included in the list of
+ * target devices and selectable in the same manner.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+
+#if defined(K20x) /* chip selection */
+/* Teensy 3.0, 3.1, 3.2; mchck; infinity keyboard */
+
+// The EEPROM is really RAM with a hardware-based backup system to
+// flash memory.  Selecting a smaller size EEPROM allows more wear
+// leveling, for higher write endurance.  If you edit this file,
+// set this to the smallest size your application can use.  Also,
+// due to Freescale's implementation, writing 16 or 32 bit words
+// (aligned to 2 or 4 byte boundaries) has twice the endurance
+// compared to writing 8 bit bytes.
+//
+#define EEPROM_SIZE 32
+
+// Writing unaligned 16 or 32 bit data is handled automatically when
+// this is defined, but at a cost of extra code size.  Without this,
+// any unaligned write will cause a hard fault exception!  If you're
+// absolutely sure all 16 and 32 bit writes will be aligned, you can
+// remove the extra unnecessary code.
+//
+#define HANDLE_UNALIGNED_WRITES
+
+// Minimum EEPROM Endurance
+// ------------------------
+#if (EEPROM_SIZE == 2048)	// 35000 writes/byte or 70000 writes/word
+  #define EEESIZE 0x33
+#elif (EEPROM_SIZE == 1024)	// 75000 writes/byte or 150000 writes/word
+  #define EEESIZE 0x34
+#elif (EEPROM_SIZE == 512)	// 155000 writes/byte or 310000 writes/word
+  #define EEESIZE 0x35
+#elif (EEPROM_SIZE == 256)	// 315000 writes/byte or 630000 writes/word
+  #define EEESIZE 0x36
+#elif (EEPROM_SIZE == 128)	// 635000 writes/byte or 1270000 writes/word
+  #define EEESIZE 0x37
+#elif (EEPROM_SIZE == 64)	// 1275000 writes/byte or 2550000 writes/word
+  #define EEESIZE 0x38
+#elif (EEPROM_SIZE == 32)	// 2555000 writes/byte or 5110000 writes/word
+  #define EEESIZE 0x39
+#endif
+
+void eeprom_initialize(void)
+{
+	uint32_t count=0;
+	uint16_t do_flash_cmd[] = {
+		0xf06f, 0x037f, 0x7003, 0x7803,
+		0xf013, 0x0f80, 0xd0fb, 0x4770};
+	uint8_t status;
+
+	if (FTFL->FCNFG & FTFL_FCNFG_RAMRDY) {
+		// FlexRAM is configured as traditional RAM
+		// We need to reconfigure for EEPROM usage
+		FTFL->FCCOB0 = 0x80; // PGMPART = Program Partition Command
+		FTFL->FCCOB4 = EEESIZE; // EEPROM Size
+		FTFL->FCCOB5 = 0x03; // 0K for Dataflash, 32K for EEPROM backup
+		__disable_irq();
+		// do_flash_cmd() must execute from RAM.  Luckily the C syntax is simple...
+		(*((void (*)(volatile uint8_t *))((uint32_t)do_flash_cmd | 1)))(&(FTFL->FSTAT));
+		__enable_irq();
+		status = FTFL->FSTAT;
+		if (status & (FTFL_FSTAT_RDCOLERR|FTFL_FSTAT_ACCERR|FTFL_FSTAT_FPVIOL)) {
+			FTFL->FSTAT = (status & (FTFL_FSTAT_RDCOLERR|FTFL_FSTAT_ACCERR|FTFL_FSTAT_FPVIOL));
+			return; // error
+		}
+	}
+	// wait for eeprom to become ready (is this really necessary?)
+	while (!(FTFL->FCNFG & FTFL_FCNFG_EEERDY)) {
+		if (++count > 20000) break;
+	}
+}
+
+#define FlexRAM ((uint8_t *)0x14000000)
+
+uint8_t eeprom_read_byte(const uint8_t *addr)
+{
+	uint32_t offset = (uint32_t)addr;
+	if (offset >= EEPROM_SIZE) return 0;
+	if (!(FTFL->FCNFG & FTFL_FCNFG_EEERDY)) eeprom_initialize();
+	return FlexRAM[offset];
+}
+
+uint16_t eeprom_read_word(const uint16_t *addr)
+{
+	uint32_t offset = (uint32_t)addr;
+	if (offset >= EEPROM_SIZE-1) return 0;
+	if (!(FTFL->FCNFG & FTFL_FCNFG_EEERDY)) eeprom_initialize();
+	return *(uint16_t *)(&FlexRAM[offset]);
+}
+
+uint32_t eeprom_read_dword(const uint32_t *addr)
+{
+	uint32_t offset = (uint32_t)addr;
+	if (offset >= EEPROM_SIZE-3) return 0;
+	if (!(FTFL->FCNFG & FTFL_FCNFG_EEERDY)) eeprom_initialize();
+	return *(uint32_t *)(&FlexRAM[offset]);
+}
+
+void eeprom_read_block(void *buf, const void *addr, uint32_t len)
+{
+	uint32_t offset = (uint32_t)addr;
+	uint8_t *dest = (uint8_t *)buf;
+	uint32_t end = offset + len;
+	
+	if (!(FTFL->FCNFG & FTFL_FCNFG_EEERDY)) eeprom_initialize();
+	if (end > EEPROM_SIZE) end = EEPROM_SIZE;
+	while (offset < end) {
+		*dest++ = FlexRAM[offset++];
+	}
+}
+
+int eeprom_is_ready(void)
+{
+	return (FTFL->FCNFG & FTFL_FCNFG_EEERDY) ? 1 : 0;
+}
+
+static void flexram_wait(void)
+{
+	while (!(FTFL->FCNFG & FTFL_FCNFG_EEERDY)) {
+		// TODO: timeout
+	}
+}
+
+void eeprom_write_byte(uint8_t *addr, uint8_t value)
+{
+	uint32_t offset = (uint32_t)addr;
+
+	if (offset >= EEPROM_SIZE) return;
+	if (!(FTFL->FCNFG & FTFL_FCNFG_EEERDY)) eeprom_initialize();
+	if (FlexRAM[offset] != value) {
+		FlexRAM[offset] = value;
+		flexram_wait();
+	}
+}
+
+void eeprom_write_word(uint16_t *addr, uint16_t value)
+{
+	uint32_t offset = (uint32_t)addr;
+
+	if (offset >= EEPROM_SIZE-1) return;
+	if (!(FTFL->FCNFG & FTFL_FCNFG_EEERDY)) eeprom_initialize();
+#ifdef HANDLE_UNALIGNED_WRITES
+	if ((offset & 1) == 0) {
+#endif
+		if (*(uint16_t *)(&FlexRAM[offset]) != value) {
+			*(uint16_t *)(&FlexRAM[offset]) = value;
+			flexram_wait();
+		}
+#ifdef HANDLE_UNALIGNED_WRITES
+	} else {
+		if (FlexRAM[offset] != value) {
+			FlexRAM[offset] = value;
+			flexram_wait();
+		}
+		if (FlexRAM[offset + 1] != (value >> 8)) {
+			FlexRAM[offset + 1] = value >> 8;
+			flexram_wait();
+		}
+	}
+#endif
+}
+
+void eeprom_write_dword(uint32_t *addr, uint32_t value)
+{
+	uint32_t offset = (uint32_t)addr;
+
+	if (offset >= EEPROM_SIZE-3) return;
+	if (!(FTFL->FCNFG & FTFL_FCNFG_EEERDY)) eeprom_initialize();
+#ifdef HANDLE_UNALIGNED_WRITES
+	switch (offset & 3) {
+	case 0:
+#endif
+		if (*(uint32_t *)(&FlexRAM[offset]) != value) {
+			*(uint32_t *)(&FlexRAM[offset]) = value;
+			flexram_wait();
+		}
+		return;
+#ifdef HANDLE_UNALIGNED_WRITES
+	case 2:
+		if (*(uint16_t *)(&FlexRAM[offset]) != value) {
+			*(uint16_t *)(&FlexRAM[offset]) = value;
+			flexram_wait();
+		}
+		if (*(uint16_t *)(&FlexRAM[offset + 2]) != (value >> 16)) {
+			*(uint16_t *)(&FlexRAM[offset + 2]) = value >> 16;
+			flexram_wait();
+		}
+		return;
+	default:
+		if (FlexRAM[offset] != value) {
+			FlexRAM[offset] = value;
+			flexram_wait();
+		}
+		if (*(uint16_t *)(&FlexRAM[offset + 1]) != (value >> 8)) {
+			*(uint16_t *)(&FlexRAM[offset + 1]) = value >> 8;
+			flexram_wait();
+		}
+		if (FlexRAM[offset + 3] != (value >> 24)) {
+			FlexRAM[offset + 3] = value >> 24;
+			flexram_wait();
+		}
+	}
+#endif
+}
+
+void eeprom_write_block(const void *buf, void *addr, uint32_t len)
+{
+	uint32_t offset = (uint32_t)addr;
+	const uint8_t *src = (const uint8_t *)buf;
+
+	if (offset >= EEPROM_SIZE) return;
+	if (!(FTFL->FCNFG & FTFL_FCNFG_EEERDY)) eeprom_initialize();
+	if (len >= EEPROM_SIZE) len = EEPROM_SIZE;
+	if (offset + len >= EEPROM_SIZE) len = EEPROM_SIZE - offset;
+	while (len > 0) {
+		uint32_t lsb = offset & 3;
+		if (lsb == 0 && len >= 4) {
+			// write aligned 32 bits
+			uint32_t val32;
+			val32 = *src++;
+			val32 |= (*src++ << 8);
+			val32 |= (*src++ << 16);
+			val32 |= (*src++ << 24);
+			if (*(uint32_t *)(&FlexRAM[offset]) != val32) {
+				*(uint32_t *)(&FlexRAM[offset]) = val32;
+				flexram_wait();
+			}
+			offset += 4;
+			len -= 4;
+		} else if ((lsb == 0 || lsb == 2) && len >= 2) {
+			// write aligned 16 bits
+			uint16_t val16;
+			val16 = *src++;
+			val16 |= (*src++ << 8);
+			if (*(uint16_t *)(&FlexRAM[offset]) != val16) {
+				*(uint16_t *)(&FlexRAM[offset]) = val16;
+				flexram_wait();
+			}
+			offset += 2;
+			len -= 2;
+		} else {
+			// write 8 bits
+			uint8_t val8 = *src++;
+			if (FlexRAM[offset] != val8) {
+				FlexRAM[offset] = val8;
+				flexram_wait();
+			}
+			offset++;
+			len--;
+		}
+	}
+}
+
+/*
+void do_flash_cmd(volatile uint8_t *fstat)
+{
+	*fstat = 0x80;
+	while ((*fstat & 0x80) == 0) ; // wait
+}
+00000000 <do_flash_cmd>:
+   0:	f06f 037f 	mvn.w	r3, #127	; 0x7f
+   4:	7003      	strb	r3, [r0, #0]
+   6:	7803      	ldrb	r3, [r0, #0]
+   8:	f013 0f80 	tst.w	r3, #128	; 0x80
+   c:	d0fb      	beq.n	6 <do_flash_cmd+0x6>
+   e:	4770      	bx	lr
+*/
+
+#elif defined(KL2x) /* chip selection */
+/* Teensy LC (emulated) */
+
+#define SYMVAL(sym) (uint32_t)(((uint8_t *)&(sym)) - ((uint8_t *)0))
+
+extern uint32_t __eeprom_workarea_start__;
+extern uint32_t __eeprom_workarea_end__;
+
+#define EEPROM_SIZE 128
+
+static uint32_t flashend = 0;
+
+void eeprom_initialize(void)
+{
+	const uint16_t *p = (uint16_t *)SYMVAL(__eeprom_workarea_start__);
+
+	do {
+		if (*p++ == 0xFFFF) {
+			flashend = (uint32_t)(p - 2);
+			return;
+		}
+	} while (p < (uint16_t *)SYMVAL(__eeprom_workarea_end__));
+	flashend = (uint32_t)((uint16_t *)SYMVAL(__eeprom_workarea_end__) - 1);
+}
+
+uint8_t eeprom_read_byte(const uint8_t *addr)
+{
+	uint32_t offset = (uint32_t)addr;
+	const uint16_t *p = (uint16_t *)SYMVAL(__eeprom_workarea_start__);
+	const uint16_t *end = (const uint16_t *)((uint32_t)flashend);
+	uint16_t val;
+	uint8_t data=0xFF;
+
+	if (!end) {
+		eeprom_initialize();
+		end = (const uint16_t *)((uint32_t)flashend);
+	}
+	if (offset < EEPROM_SIZE) {
+		while (p <= end) {
+			val = *p++;
+			if ((val & 255) == offset) data = val >> 8;
+		}
+	}
+	return data;
+}
+
+static void flash_write(const uint16_t *code, uint32_t addr, uint32_t data)
+{
+	// with great power comes great responsibility....
+	uint32_t stat;
+	*(uint32_t *)&(FTFA->FCCOB3) = 0x06000000 | (addr & 0x00FFFFFC);
+	*(uint32_t *)&(FTFA->FCCOB7) = data;
+	__disable_irq();
+	(*((void (*)(volatile uint8_t *))((uint32_t)code | 1)))(&(FTFA->FSTAT));
+	__enable_irq();
+	stat = FTFA->FSTAT & (FTFA_FSTAT_RDCOLERR|FTFA_FSTAT_ACCERR|FTFA_FSTAT_FPVIOL);
+	if (stat) {
+		FTFA->FSTAT = stat;
+	}
+	MCM->PLACR |= MCM_PLACR_CFCC;
+}
+
+void eeprom_write_byte(uint8_t *addr, uint8_t data)
+{
+	uint32_t offset = (uint32_t)addr;
+	const uint16_t *p, *end = (const uint16_t *)((uint32_t)flashend);
+	uint32_t i, val, flashaddr;
+	uint16_t do_flash_cmd[] = {
+		0x2380, 0x7003, 0x7803, 0xb25b, 0x2b00, 0xdafb, 0x4770};
+	uint8_t buf[EEPROM_SIZE];
+
+	if (offset >= EEPROM_SIZE) return;
+	if (!end) {
+		eeprom_initialize();
+		end = (const uint16_t *)((uint32_t)flashend);
+	}
+	if (++end < (uint16_t *)SYMVAL(__eeprom_workarea_end__)) {
+		val = (data << 8) | offset;
+		flashaddr = (uint32_t)end;
+		flashend = flashaddr;
+		if ((flashaddr & 2) == 0) {
+			val |= 0xFFFF0000;
+		} else {
+			val <<= 16;
+			val |= 0x0000FFFF;
+		}
+		flash_write(do_flash_cmd, flashaddr, val);
+	} else {
+		for (i=0; i < EEPROM_SIZE; i++) {
+			buf[i] = 0xFF;
+		}
+		val = 0;
+		for (p = (uint16_t *)SYMVAL(__eeprom_workarea_start__); p < (uint16_t *)SYMVAL(__eeprom_workarea_end__); p++) {
+			val = *p;
+			if ((val & 255) < EEPROM_SIZE) {
+				buf[val & 255] = val >> 8;
+			}
+		}
+		buf[offset] = data;
+		for (flashaddr=(uint32_t)(uint16_t *)SYMVAL(__eeprom_workarea_start__); flashaddr < (uint32_t)(uint16_t *)SYMVAL(__eeprom_workarea_end__); flashaddr += 1024) {
+			*(uint32_t *)&(FTFA->FCCOB3) = 0x09000000 | flashaddr;
+			__disable_irq();
+			(*((void (*)(volatile uint8_t *))((uint32_t)do_flash_cmd | 1)))(&(FTFA->FSTAT));
+			__enable_irq();
+			val = FTFA->FSTAT & (FTFA_FSTAT_RDCOLERR|FTFA_FSTAT_ACCERR|FTFA_FSTAT_FPVIOL);;
+			if (val) FTFA->FSTAT = val;
+			MCM->PLACR |= MCM_PLACR_CFCC;
+		}
+		flashaddr=(uint32_t)(uint16_t *)SYMVAL(__eeprom_workarea_start__);
+		for (i=0; i < EEPROM_SIZE; i++) {
+			if (buf[i] == 0xFF) continue;
+			if ((flashaddr & 2) == 0) {
+				val = (buf[i] << 8) | i;
+			} else {
+				val = val | (buf[i] << 24) | (i << 16);
+				flash_write(do_flash_cmd, flashaddr, val);
+			}
+			flashaddr += 2;
+		}
+		flashend = flashaddr;
+		if ((flashaddr & 2)) {
+			val |= 0xFFFF0000;
+			flash_write(do_flash_cmd, flashaddr, val);
+		}
+	}
+}
+
+/*
+void do_flash_cmd(volatile uint8_t *fstat)
+{
+        *fstat = 0x80;
+        while ((*fstat & 0x80) == 0) ; // wait
+}
+00000000 <do_flash_cmd>:
+   0:	2380      	movs	r3, #128	; 0x80
+   2:	7003      	strb	r3, [r0, #0]
+   4:	7803      	ldrb	r3, [r0, #0]
+   6:	b25b      	sxtb	r3, r3
+   8:	2b00      	cmp	r3, #0
+   a:	dafb      	bge.n	4 <do_flash_cmd+0x4>
+   c:	4770      	bx	lr
+*/
+
+
+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++);
+	}
+}
+
+int eeprom_is_ready(void)
+{
+	return 1;
+}
+
+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++);
+	}
+}
+
+#else
+// No EEPROM supported, so emulate it
+
+#define EEPROM_SIZE 32
+static uint8_t buffer[EEPROM_SIZE];
+
+uint8_t eeprom_read_byte(const uint8_t *addr) {
+	uint32_t offset = (uint32_t)addr;
+	return buffer[offset];
+}
+
+void eeprom_write_byte(uint8_t *addr, uint8_t value) {
+	uint32_t offset = (uint32_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++);
+	}
+}
+
+#endif /* chip selection */
+// The update functions just calls write for now, but could probably be optimized
+
+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/chibios/printf.c b/tmk_core/common/chibios/printf.c
new file mode 100644
index 0000000000..72e3d4f8c4
--- /dev/null
+++ b/tmk_core/common/chibios/printf.c
@@ -0,0 +1,240 @@
+/*
+ * found at: http://www.sparetimelabs.com/tinyprintf/tinyprintf.php
+ * and:      http://www.sparetimelabs.com/printfrevisited/printfrevisited.php
+ */
+
+/*
+File: printf.c
+
+Copyright (C) 2004  Kustaa Nyholm
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+*/
+
+#include "printf.h"
+
+typedef void (*putcf) (void*,char);
+static putcf stdout_putf;
+static void* stdout_putp;
+
+// this adds cca 400 bytes
+#define PRINTF_LONG_SUPPORT
+
+#ifdef PRINTF_LONG_SUPPORT
+
+static void uli2a(unsigned long int num, unsigned int base, int uc,char * bf)
+    {
+    int n=0;
+    unsigned int d=1;
+    while (num/d >= base)
+        d*=base;         
+    while (d!=0) {
+        int dgt = num / d;
+        num%=d;
+        d/=base;
+        if (n || dgt>0|| d==0) {
+            *bf++ = dgt+(dgt<10 ? '0' : (uc ? 'A' : 'a')-10);
+            ++n;
+            }
+        }
+    *bf=0;
+    }
+
+static void li2a (long num, char * bf)
+    {
+    if (num<0) {
+        num=-num;
+        *bf++ = '-';
+        }
+    uli2a(num,10,0,bf);
+    }
+
+#endif
+
+static void ui2a(unsigned int num, unsigned int base, int uc,char * bf)
+    {
+    int n=0;
+    unsigned int d=1;
+    while (num/d >= base)
+        d*=base;        
+    while (d!=0) {
+        int dgt = num / d;
+        num%= d;
+        d/=base;
+        if (n || dgt>0 || d==0) {
+            *bf++ = dgt+(dgt<10 ? '0' : (uc ? 'A' : 'a')-10);
+            ++n;
+            }
+        }
+    *bf=0;
+    }
+
+static void i2a (int num, char * bf)
+    {
+    if (num<0) {
+        num=-num;
+        *bf++ = '-';
+        }
+    ui2a(num,10,0,bf);
+    }
+
+static int a2d(char ch)
+    {
+    if (ch>='0' && ch<='9') 
+        return ch-'0';
+    else if (ch>='a' && ch<='f')
+        return ch-'a'+10;
+    else if (ch>='A' && ch<='F')
+        return ch-'A'+10;
+    else return -1;
+    }
+
+static char a2i(char ch, char** src,int base,int* nump)
+    {
+    char* p= *src;
+    int num=0;
+    int digit;
+    while ((digit=a2d(ch))>=0) {
+        if (digit>base) break;
+        num=num*base+digit;
+        ch=*p++;
+        }
+    *src=p;
+    *nump=num;
+    return ch;
+    }
+
+static void putchw(void* putp,putcf putf,int n, char z, char* bf)
+    {
+    char fc=z? '0' : ' ';
+    char ch;
+    char* p=bf;
+    while (*p++ && n > 0)
+        n--;
+    while (n-- > 0) 
+        putf(putp,fc);
+    while ((ch= *bf++))
+        putf(putp,ch);
+    }
+
+void tfp_format(void* putp,putcf putf,char *fmt, va_list va)
+    {
+    char bf[12];
+    
+    char ch;
+
+
+    while ((ch=*(fmt++))) {
+        if (ch!='%') 
+            putf(putp,ch);
+        else {
+            char lz=0;
+#ifdef  PRINTF_LONG_SUPPORT
+            char lng=0;
+#endif
+            int w=0;
+            ch=*(fmt++);
+            if (ch=='0') {
+                ch=*(fmt++);
+                lz=1;
+                }
+            if (ch>='0' && ch<='9') {
+                ch=a2i(ch,&fmt,10,&w);
+                }
+#ifdef  PRINTF_LONG_SUPPORT
+            if (ch=='l') {
+                ch=*(fmt++);
+                lng=1;
+            }
+#endif
+            switch (ch) {
+                case 0: 
+                    goto abort;
+                case 'u' : {
+#ifdef  PRINTF_LONG_SUPPORT
+                    if (lng)
+                        uli2a(va_arg(va, unsigned long int),10,0,bf);
+                    else
+#endif
+                    ui2a(va_arg(va, unsigned int),10,0,bf);
+                    putchw(putp,putf,w,lz,bf);
+                    break;
+                    }
+                case 'd' :  {
+#ifdef  PRINTF_LONG_SUPPORT
+                    if (lng)
+                        li2a(va_arg(va, unsigned long int),bf);
+                    else
+#endif
+                    i2a(va_arg(va, int),bf);
+                    putchw(putp,putf,w,lz,bf);
+                    break;
+                    }
+                case 'x': case 'X' : 
+#ifdef  PRINTF_LONG_SUPPORT
+                    if (lng)
+                        uli2a(va_arg(va, unsigned long int),16,(ch=='X'),bf);
+                    else
+#endif
+                    ui2a(va_arg(va, unsigned int),16,(ch=='X'),bf);
+                    putchw(putp,putf,w,lz,bf);
+                    break;
+                case 'c' : 
+                    putf(putp,(char)(va_arg(va, int)));
+                    break;
+                case 's' : 
+                    putchw(putp,putf,w,0,va_arg(va, char*));
+                    break;
+                case '%' :
+                    putf(putp,ch);
+                default:
+                    break;
+                }
+            }
+        }
+    abort:;
+    }
+
+
+void init_printf(void* putp,void (*putf) (void*,char))
+    {
+    stdout_putf=putf;
+    stdout_putp=putp;
+    }
+
+void tfp_printf(char *fmt, ...)
+    {
+    va_list va;
+    va_start(va,fmt);
+    tfp_format(stdout_putp,stdout_putf,fmt,va);
+    va_end(va);
+    }
+
+static void putcp(void* p,char c)
+    {
+    *(*((char**)p))++ = c;
+    }
+
+
+
+void tfp_sprintf(char* s,char *fmt, ...)
+    {
+    va_list va;
+    va_start(va,fmt);
+    tfp_format(&s,putcp,fmt,va);
+    putcp(&s,0);
+    va_end(va);
+    }
diff --git a/tmk_core/common/chibios/printf.h b/tmk_core/common/chibios/printf.h
new file mode 100644
index 0000000000..678a100c6e
--- /dev/null
+++ b/tmk_core/common/chibios/printf.h
@@ -0,0 +1,111 @@
+/*
+ * found at: http://www.sparetimelabs.com/tinyprintf/tinyprintf.php
+ * and:      http://www.sparetimelabs.com/printfrevisited/printfrevisited.php
+ */
+
+/*
+File: printf.h
+
+Copyright (C) 2004  Kustaa Nyholm
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+This library is realy just two files: 'printf.h' and 'printf.c'.
+
+They provide a simple and small (+200 loc) printf functionality to 
+be used in embedded systems.
+
+I've found them so usefull in debugging that I do not bother with a 
+debugger at all.
+
+They are distributed in source form, so to use them, just compile them 
+into your project. 
+
+Two printf variants are provided: printf and sprintf. 
+
+The formats supported by this implementation are: 'd' 'u' 'c' 's' 'x' 'X'.
+
+Zero padding and field width are also supported.
+
+If the library is compiled with 'PRINTF_SUPPORT_LONG' defined then the 
+long specifier is also
+supported. Note that this will pull in some long math routines (pun intended!)
+and thus make your executable noticably longer.
+
+The memory foot print of course depends on the target cpu, compiler and 
+compiler options, but a rough guestimate (based on a H8S target) is about 
+1.4 kB for code and some twenty 'int's and 'char's, say 60 bytes of stack space. 
+Not too bad. Your milage may vary. By hacking the source code you can 
+get rid of some hunred bytes, I'm sure, but personally I feel the balance of 
+functionality and flexibility versus  code size is close to optimal for
+many embedded systems.
+
+To use the printf you need to supply your own character output function, 
+something like :
+
+    void putc ( void* p, char c)
+        {
+        while (!SERIAL_PORT_EMPTY) ;
+        SERIAL_PORT_TX_REGISTER = c;
+        }
+
+Before you can call printf you need to initialize it to use your 
+character output function with something like:
+
+    init_printf(NULL,putc);
+
+Notice the 'NULL' in 'init_printf' and the parameter 'void* p' in 'putc', 
+the NULL (or any pointer) you pass into the 'init_printf' will eventually be 
+passed to your 'putc' routine. This allows you to pass some storage space (or 
+anything realy) to the character output function, if necessary. 
+This is not often needed but it was implemented like that because it made 
+implementing the sprintf function so neat (look at the source code).
+
+The code is re-entrant, except for the 'init_printf' function, so it 
+is safe to call it from interupts too, although this may result in mixed output. 
+If you rely on re-entrancy, take care that your 'putc' function is re-entrant!
+
+The printf and sprintf functions are actually macros that translate to 
+'tfp_printf' and 'tfp_sprintf'. This makes it possible
+to use them along with 'stdio.h' printf's in a single source file. 
+You just need to undef the names before you include the 'stdio.h'.
+Note that these are not function like macros, so if you have variables
+or struct members with these names, things will explode in your face.
+Without variadic macros this is the best we can do to wrap these
+fucnction. If it is a problem just give up the macros and use the
+functions directly or rename them.
+
+For further details see source code.
+
+regs Kusti, 23.10.2004
+*/
+
+
+#ifndef __TFP_PRINTF__
+#define __TFP_PRINTF__
+
+#include <stdarg.h>
+
+void init_printf(void* putp,void (*putf) (void*,char));
+
+void tfp_printf(char *fmt, ...);
+void tfp_sprintf(char* s,char *fmt, ...);
+
+void tfp_format(void* putp,void (*putf) (void*,char),char *fmt, va_list va);
+
+#define printf tfp_printf 
+#define sprintf tfp_sprintf 
+
+#endif
diff --git a/tmk_core/common/chibios/sleep_led.c b/tmk_core/common/chibios/sleep_led.c
new file mode 100644
index 0000000000..4c35cfcbac
--- /dev/null
+++ b/tmk_core/common/chibios/sleep_led.c
@@ -0,0 +1,226 @@
+#include "ch.h"
+#include "hal.h"
+
+#include "led.h"
+#include "sleep_led.h"
+
+/* All right, we go the "software" way: timer, toggle LED in interrupt.
+ * Based on hasu's code for AVRs.
+ * Use LP timer on Kinetises, TIM14 on STM32F0.
+ */
+
+#if defined(KL2x) || defined(K20x)
+
+/* Use Low Power Timer (LPTMR) */
+#define TIMER_INTERRUPT_VECTOR KINETIS_LPTMR0_IRQ_VECTOR
+#define RESET_COUNTER LPTMR0->CSR |= LPTMRx_CSR_TCF
+
+#elif defined(STM32F0XX)
+
+/* Use TIM14 manually */
+#define TIMER_INTERRUPT_VECTOR STM32_TIM14_HANDLER
+#define RESET_COUNTER STM32_TIM14->SR &= ~STM32_TIM_SR_UIF
+
+#endif
+
+#if defined(KL2x) || defined(K20x) || defined(STM32F0XX) /* common parts for timers/interrupts */
+
+/* Breathing Sleep LED brighness(PWM On period) table
+ * (64[steps] * 4[duration]) / 64[PWM periods/s] = 4 second breath cycle
+ *
+ * http://www.wolframalpha.com/input/?i=%28sin%28+x%2F64*pi%29**8+*+255%2C+x%3D0+to+63
+ * (0..63).each {|x| p ((sin(x/64.0*PI)**8)*255).to_i }
+ */
+static const uint8_t breathing_table[64] = {
+0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 4, 6, 10,
+15, 23, 32, 44, 58, 74, 93, 113, 135, 157, 179, 199, 218, 233, 245, 252,
+255, 252, 245, 233, 218, 199, 179, 157, 135, 113, 93, 74, 58, 44, 32, 23,
+15, 10, 6, 4, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+};
+
+/* interrupt handler */
+OSAL_IRQ_HANDLER(TIMER_INTERRUPT_VECTOR) {
+    OSAL_IRQ_PROLOGUE();
+
+    /* Software PWM
+    * timer:1111 1111 1111 1111
+    *       \_____/\/ \_______/____  count(0-255)
+    *          \    \______________  duration of step(4)
+    *           \__________________  index of step table(0-63)
+    */
+
+    // this works for cca 65536 irqs/sec
+    static union {
+    uint16_t row;
+    struct {
+      uint8_t count:8;
+      uint8_t duration:2;
+      uint8_t index:6;
+    } pwm;
+    } timer = { .row = 0 };
+
+    timer.row++;
+
+    // LED on
+    if (timer.pwm.count == 0) {
+        led_set(1<<USB_LED_CAPS_LOCK);
+    }
+    // LED off
+    if (timer.pwm.count == breathing_table[timer.pwm.index]) {
+        led_set(0);
+    }
+
+    /* Reset the counter */
+    RESET_COUNTER;
+
+    OSAL_IRQ_EPILOGUE();
+}
+
+#endif /* common parts for known platforms */
+
+
+#if defined(KL2x) || defined(K20x) /* platform selection: familiar Kinetis chips */
+
+/* LPTMR clock options */
+#define LPTMR_CLOCK_MCGIRCLK 0 /* 4MHz clock */
+#define LPTMR_CLOCK_LPO      1 /* 1kHz clock */
+#define LPTMR_CLOCK_ERCLK32K 2 /* external 32kHz crystal */
+#define LPTMR_CLOCK_OSCERCLK 3 /* output from OSC */
+
+/* Work around inconsistencies in Freescale naming */
+#if !defined(SIM_SCGC5_LPTMR)
+#define SIM_SCGC5_LPTMR SIM_SCGC5_LPTIMER
+#endif
+
+/* Initialise the timer */
+void sleep_led_init(void) {
+    /* Make sure the clock to the LPTMR is enabled */
+    SIM->SCGC5 |= SIM_SCGC5_LPTMR;
+    /* Reset LPTMR settings */
+    LPTMR0->CSR = 0;
+    /* Set the compare value */
+    LPTMR0->CMR = 0;  // trigger on counter value (i.e. every time)
+
+    /* Set up clock source and prescaler */
+    /* Software PWM
+    *  ______           ______           __
+    * |  ON  |___OFF___|  ON  |___OFF___|   ....
+    * |<-------------->|<-------------->|<- ....
+    *     PWM period       PWM period
+    *
+    * R                interrupts/period[resolution]
+    * F                periods/second[frequency]
+    * R * F            interrupts/second
+    */
+
+    /* === OPTION 1 === */
+    #if 0
+    //  1kHz LPO
+    //  No prescaler => 1024 irqs/sec
+    //  Note: this is too slow for a smooth breathe
+    LPTMR0->PSR = LPTMRx_PSR_PCS(LPTMR_CLOCK_LPO)|LPTMRx_PSR_PBYP;
+    #endif /* OPTION 1 */
+
+    /* === OPTION 2 === */
+    #if 1
+    //  nMHz IRC (n=4 on KL25Z, KL26Z and K20x; n=2 or 8 on KL27Z)
+    MCG->C2 |= MCG_C2_IRCS; // fast (4MHz) internal ref clock
+    #if defined(KL27) // divide the 8MHz IRC by 2, to have the same MCGIRCLK speed as others
+    MCG->MC |= MCG_MC_LIRC_DIV2_DIV2;
+    #endif /* KL27 */
+    MCG->C1 |= MCG_C1_IRCLKEN; // enable internal ref clock
+    //  to work in stop mode, also MCG_C1_IREFSTEN
+    //  Divide 4MHz by 2^N (N=6) => 62500 irqs/sec =>
+    //  => approx F=61, R=256, duration = 4
+    LPTMR0->PSR = LPTMRx_PSR_PCS(LPTMR_CLOCK_MCGIRCLK)|LPTMRx_PSR_PRESCALE(6);
+    #endif /* OPTION 2 */
+
+    /* === OPTION 3 === */
+    #if 0
+    //  OSC output (external crystal), usually 8MHz or 16MHz
+    OSC0->CR |= OSC_CR_ERCLKEN; // enable ext ref clock
+    //  to work in stop mode, also OSC_CR_EREFSTEN
+    //  Divide by 2^N
+    LPTMR0->PSR = LPTMRx_PSR_PCS(LPTMR_CLOCK_OSCERCLK)|LPTMRx_PSR_PRESCALE(7);
+    #endif /* OPTION 3 */
+    /* === END OPTIONS === */
+
+    /* Interrupt on TCF set (compare flag) */
+    nvicEnableVector(LPTMR0_IRQn, 2); // vector, priority
+    LPTMR0->CSR |= LPTMRx_CSR_TIE;
+}
+
+void sleep_led_enable(void) {
+    /* Enable the timer */
+    LPTMR0->CSR |= LPTMRx_CSR_TEN;
+}
+
+void sleep_led_disable(void) {
+    /* Disable the timer */
+    LPTMR0->CSR &= ~LPTMRx_CSR_TEN;
+}
+
+void sleep_led_toggle(void) {
+    /* Toggle the timer */
+    LPTMR0->CSR ^= LPTMRx_CSR_TEN;
+}
+
+#elif defined(STM32F0XX) /* platform selection: STM32F0XX */
+
+/* Initialise the timer */
+void sleep_led_init(void) {
+    /* enable clock */
+    rccEnableTIM14(FALSE); /* low power enable = FALSE */
+    rccResetTIM14();
+
+    /* prescale */
+    /* Assuming 48MHz internal clock */
+    /* getting cca 65484 irqs/sec */
+    STM32_TIM14->PSC = 733;
+
+    /* auto-reload */
+    /* 0 => interrupt every time */
+    STM32_TIM14->ARR = 3;
+
+    /* enable counter update event interrupt */
+    STM32_TIM14->DIER |= STM32_TIM_DIER_UIE;
+
+    /* register interrupt vector */
+    nvicEnableVector(STM32_TIM14_NUMBER, 2); /* vector, priority */
+}
+
+void sleep_led_enable(void) {
+    /* Enable the timer */
+    STM32_TIM14->CR1 = STM32_TIM_CR1_CEN | STM32_TIM_CR1_URS;
+    /* URS => update event only on overflow; setting UG bit disabled */
+}
+
+void sleep_led_disable(void) {
+    /* Disable the timer */
+    STM32_TIM14->CR1 = 0;
+}
+
+void sleep_led_toggle(void) {
+    /* Toggle the timer */
+    STM32_TIM14->CR1 ^= STM32_TIM_CR1_CEN;
+}
+
+
+#else /* platform selection: not on familiar chips */
+
+void sleep_led_init(void) {
+}
+ 
+void sleep_led_enable(void) {
+    led_set(1<<USB_LED_CAPS_LOCK);
+}
+ 
+void sleep_led_disable(void) {
+    led_set(0);
+}
+ 
+void sleep_led_toggle(void) {
+    // not implemented
+}
+
+#endif /* platform selection */
\ No newline at end of file
diff --git a/tmk_core/common/chibios/suspend.c b/tmk_core/common/chibios/suspend.c
new file mode 100644
index 0000000000..6ca16034f3
--- /dev/null
+++ b/tmk_core/common/chibios/suspend.c
@@ -0,0 +1,65 @@
+/* TODO */
+
+#include "ch.h"
+#include "hal.h"
+
+#include "matrix.h"
+#include "action.h"
+#include "action_util.h"
+#include "mousekey.h"
+#include "host.h"
+#include "backlight.h"
+#include "suspend.h"
+
+void suspend_idle(uint8_t time) {
+	// TODO: this is not used anywhere - what units is 'time' in?
+	chThdSleepMilliseconds(time);
+}
+
+void suspend_power_down(void) {
+	// TODO: figure out what to power down and how
+	// shouldn't power down TPM/FTM if we want a breathing LED
+	// also shouldn't power down USB
+
+	// on AVR, this enables the watchdog for 15ms (max), and goes to
+	// SLEEP_MODE_PWR_DOWN
+
+	chThdSleepMilliseconds(17);
+}
+
+__attribute__ ((weak)) void matrix_power_up(void) {}
+__attribute__ ((weak)) void matrix_power_down(void) {}
+bool suspend_wakeup_condition(void)
+{
+    matrix_power_up();
+    matrix_scan();
+    matrix_power_down();
+    for (uint8_t r = 0; r < MATRIX_ROWS; r++) {
+        if (matrix_get_row(r)) return true;
+    }
+    return false;
+}
+
+// run immediately after wakeup
+void suspend_wakeup_init(void)
+{
+    // clear keyboard state
+    // need to do it manually, because we're running from ISR
+    //  and clear_keyboard() calls print
+    // so only clear the variables in memory
+    // the reports will be sent from main.c afterwards
+    // or if the PC asks for GET_REPORT
+    clear_mods();
+    clear_weak_mods();
+    clear_keys();
+#ifdef MOUSEKEY_ENABLE
+    mousekey_clear();
+#endif /* MOUSEKEY_ENABLE */
+#ifdef EXTRAKEY_ENABLE
+    host_system_send(0);
+    host_consumer_send(0);
+#endif /* EXTRAKEY_ENABLE */
+#ifdef BACKLIGHT_ENABLE
+    backlight_init();
+#endif /* BACKLIGHT_ENABLE */
+}
diff --git a/tmk_core/common/chibios/timer.c b/tmk_core/common/chibios/timer.c
new file mode 100644
index 0000000000..3de4cc368b
--- /dev/null
+++ b/tmk_core/common/chibios/timer.c
@@ -0,0 +1,27 @@
+#include "ch.h"
+
+#include "timer.h"
+
+void timer_init(void) {}
+
+void timer_clear(void) {}
+
+uint16_t timer_read(void)
+{
+    return (uint16_t)ST2MS(chVTGetSystemTime());
+}
+
+uint32_t timer_read32(void)
+{
+    return ST2MS(chVTGetSystemTime());
+}
+
+uint16_t timer_elapsed(uint16_t last)
+{
+    return (uint16_t)(ST2MS(chVTTimeElapsedSinceX(MS2ST(last))));
+}
+
+uint32_t timer_elapsed32(uint32_t last)
+{
+    return ST2MS(chVTTimeElapsedSinceX(MS2ST(last)));
+}
diff --git a/tmk_core/common/command.c b/tmk_core/common/command.c
index 187a2b9496..084c9fe155 100644
--- a/tmk_core/common/command.c
+++ b/tmk_core/common/command.c
@@ -16,7 +16,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 #include <stdint.h>
 #include <stdbool.h>
-#include <util/delay.h>
+#include "wait.h"
 #include "keycode.h"
 #include "host.h"
 #include "keymap.h"
@@ -103,12 +103,14 @@ bool command_proc(uint8_t code)
 bool command_extra(uint8_t code) __attribute__ ((weak));
 bool command_extra(uint8_t code)
 {
+    (void)code;
     return false;
 }
 
 bool command_console_extra(uint8_t code) __attribute__ ((weak));
 bool command_console_extra(uint8_t code)
 {
+    (void)code;
     return false;
 }
 
@@ -217,8 +219,11 @@ static void print_version(void)
 	    " " STR(BOOTLOADER_SIZE) "\n");
 
     print("GCC: " STR(__GNUC__) "." STR(__GNUC_MINOR__) "." STR(__GNUC_PATCHLEVEL__)
+#if defined(__AVR__)
           " AVR-LIBC: " __AVR_LIBC_VERSION_STRING__
-          " AVR_ARCH: avr" STR(__AVR_ARCH__) "\n");
+          " AVR_ARCH: avr" STR(__AVR_ARCH__)
+#endif
+		  "\n");
 
 	return;
 }
@@ -234,7 +239,7 @@ static void print_status(void)
 #ifdef NKRO_ENABLE
     print_val_hex8(keyboard_nkro);
 #endif
-    print_val_hex32(timer_count);
+    print_val_hex32(timer_read32());
 
 #ifdef PROTOCOL_PJRC
     print_val_hex8(UDCON);
@@ -360,7 +365,7 @@ static bool command_common(uint8_t code)
 	            stop_all_notes();
                 shutdown_user();
             #else
-	            _delay_ms(1000);
+	            wait_ms(1000);
             #endif
             bootloader_jump(); // not return
             break;
@@ -430,10 +435,11 @@ static bool command_common(uint8_t code)
         case MAGIC_KC(MAGIC_KEY_NKRO):
             clear_keyboard(); // clear to prevent stuck keys
             keyboard_nkro = !keyboard_nkro;
-            if (keyboard_nkro)
+            if (keyboard_nkro) {
                 print("NKRO: on\n");
-            else
+            } else {
                 print("NKRO: off\n");
+            }
             break;
 #endif
 
@@ -750,10 +756,11 @@ static bool mousekey_console(uint8_t code)
             print("?");
             return false;
     }
-    if (mousekey_param)
+    if (mousekey_param) {
         xprintf("M%d> ", mousekey_param);
-    else
+    } else {
         print("M>" );
+    }
     return true;
 }
 #endif
diff --git a/tmk_core/common/avr/eeconfig.c b/tmk_core/common/eeconfig.c
index 656938fb33..140d2b85bb 100644
--- a/tmk_core/common/avr/eeconfig.c
+++ b/tmk_core/common/eeconfig.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <stdbool.h>
-#include <avr/eeprom.h>
+#include "eeprom.h"
 #include "eeconfig.h"
 
 void eeconfig_init(void)
diff --git a/tmk_core/common/eeprom.h b/tmk_core/common/eeprom.h
new file mode 100644
index 0000000000..2cc2ccee3f
--- /dev/null
+++ b/tmk_core/common/eeprom.h
@@ -0,0 +1,22 @@
+#ifndef TMK_CORE_COMMON_EEPROM_H_
+#define TMK_CORE_COMMON_EEPROM_H_
+
+#if defined(__AVR__)
+#include <avr/eeprom.h>
+#else
+uint8_t 	eeprom_read_byte (const uint8_t *__p);
+uint16_t 	eeprom_read_word (const uint16_t *__p);
+uint32_t 	eeprom_read_dword (const uint32_t *__p);
+void 	eeprom_read_block (void *__dst, const void *__src, uint32_t __n);
+void 	eeprom_write_byte (uint8_t *__p, uint8_t __value);
+void 	eeprom_write_word (uint16_t *__p, uint16_t __value);
+void 	eeprom_write_dword (uint32_t *__p, uint32_t __value);
+void 	eeprom_write_block (const void *__src, void *__dst, uint32_t __n);
+void 	eeprom_update_byte (uint8_t *__p, uint8_t __value);
+void 	eeprom_update_word (uint16_t *__p, uint16_t __value);
+void 	eeprom_update_dword (uint32_t *__p, uint32_t __value);
+void 	eeprom_update_block (const void *__src, void *__dst, uint32_t __n);
+#endif
+
+
+#endif /* TMK_CORE_COMMON_EEPROM_H_ */
diff --git a/tmk_core/common/keyboard.c b/tmk_core/common/keyboard.c
index 34e1ceeca5..81df8eb73b 100644
--- a/tmk_core/common/keyboard.c
+++ b/tmk_core/common/keyboard.c
@@ -51,17 +51,20 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #endif
 
 #ifdef MATRIX_HAS_GHOST
-static bool is_row_ghosting(uint8_t row){
-    matrix_row_t state = matrix_get_row(row);
-    /* no ghosting happens when only one key in the row is pressed */
-    if (!(state - 1 & state)) return false;
-    /* ghosting occurs when two keys in the same column are pressed */
-    for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
-        if (r != row && matrix_get_row(r) & state) return true;
+static bool has_ghost_in_row(uint8_t row)
+{
+    matrix_row_t matrix_row = matrix_get_row(row);
+    // No ghost exists when less than 2 keys are down on the row
+    if (((matrix_row - 1) & matrix_row) == 0)
+        return false;
+
+    // Ghost occurs when the row shares column line with other row
+    for (uint8_t i=0; i < MATRIX_ROWS; i++) {
+        if (i != row && (matrix_get_row(i) & matrix_row))
+            return true;
     }
     return false;
 }
-
 #endif
 
 __attribute__ ((weak))
@@ -100,72 +103,86 @@ void keyboard_init(void) {
 #endif
 }
 
-/* does routine keyboard jobs */
-void keyboard_task(void) {
-    static uint8_t led_status;
+/*
+ * Do keyboard routine jobs: scan mantrix, light LEDs, ...
+ * This is repeatedly called as fast as possible.
+ */
+void keyboard_task(void)
+{
+    static matrix_row_t matrix_prev[MATRIX_ROWS];
+#ifdef MATRIX_HAS_GHOST
+    static matrix_row_t matrix_ghost[MATRIX_ROWS];
+#endif
+    static uint8_t led_status = 0;
+    matrix_row_t matrix_row = 0;
+    matrix_row_t matrix_change = 0;
+
     matrix_scan();
-    for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
-        static matrix_row_t previous_matrix[MATRIX_ROWS];
-        matrix_row_t state = matrix_get_row(r);
-        matrix_row_t changes = state ^ previous_matrix[r];
-        if (changes) {
+    for (uint8_t r = 0; r < MATRIX_ROWS; r++) {
+        matrix_row = matrix_get_row(r);
+        matrix_change = matrix_row ^ matrix_prev[r];
+        if (matrix_change) {
 #ifdef MATRIX_HAS_GHOST
-            static matrix_row_t deghosting_matrix[MATRIX_ROWS];
-            if (is_row_ghosting(r)) {
-                /* debugs the deghosting mechanism */
-                /* doesn't update previous_matrix until the ghosting has stopped
-                 * in order to prevent the last key from being lost
+            if (has_ghost_in_row(r)) {
+                /* Keep track of whether ghosted status has changed for
+                 * debugging. But don't update matrix_prev until un-ghosted, or
+                 * the last key would be lost.
                  */
-                if (debug_matrix && deghosting_matrix[r] != state) {
+                if (debug_matrix && matrix_ghost[r] != matrix_row) {
                     matrix_print();
                 }
-                deghosting_matrix[r] = state;
+                matrix_ghost[r] = matrix_row;
                 continue;
             }
-            deghosting_matrix[r] = state;
+            matrix_ghost[r] = matrix_row;
 #endif
             if (debug_matrix) matrix_print();
-            for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) {
-                matrix_row_t mask = (matrix_row_t)1 << c;
-                if (changes & mask) {
-                    keyevent_t event;
-                    event.key = (keypos_t){ .row = r, .col = c };
-                    event.pressed = state & mask;
-                    /* the time should not be 0 */
-                    event.time = timer_read() | 1;
-                    action_exec(event);
-                    /* records the processed key event */
-                    previous_matrix[r] ^= mask;
-                    /* processes one key event per call */
-                    goto event_processed;
+            for (uint8_t c = 0; c < MATRIX_COLS; c++) {
+                if (matrix_change & ((matrix_row_t)1<<c)) {
+                    action_exec((keyevent_t){
+                        .key = (keypos_t){ .row = r, .col = c },
+                        .pressed = (matrix_row & ((matrix_row_t)1<<c)),
+                        .time = (timer_read() | 1) /* time should not be 0 */
+                    });
+                    // record a processed key
+                    matrix_prev[r] ^= ((matrix_row_t)1<<c);
+                    // process a key per task call
+                    goto MATRIX_LOOP_END;
                 }
             }
         }
     }
-    /* sends tick events when the keyboard is idle */
+    // call with pseudo tick event when no real key event.
     action_exec(TICK);
-event_processed:
+
+MATRIX_LOOP_END:
+
 #ifdef MOUSEKEY_ENABLE
-    /* repeats and accelerates the mouse keys */
+    // mousekey repeat & acceleration
     mousekey_task();
 #endif
+
 #ifdef PS2_MOUSE_ENABLE
     ps2_mouse_task();
 #endif
+
 #ifdef SERIAL_MOUSE_ENABLE
-    serial_mouse_task();
+        serial_mouse_task();
 #endif
+
 #ifdef ADB_MOUSE_ENABLE
-    adb_mouse_task();
+        adb_mouse_task();
 #endif
-    /* updates the LEDs */
+
+    // update LED
     if (led_status != host_keyboard_leds()) {
         led_status = host_keyboard_leds();
         keyboard_set_leds(led_status);
     }
 }
 
-void keyboard_set_leds(uint8_t leds) {
-    if (debug_keyboard) dprintf("Keyboard LEDs state: %x\n", leds);
+void keyboard_set_leds(uint8_t leds)
+{
+    if (debug_keyboard) { debug("keyboard_set_led: "); debug_hex8(leds); debug("\n"); }
     led_set(leds);
 }
diff --git a/tmk_core/common/magic.c b/tmk_core/common/magic.c
index f21d1346c7..194e4cc026 100644
--- a/tmk_core/common/magic.c
+++ b/tmk_core/common/magic.c
@@ -1,6 +1,8 @@
 #include <stdint.h>
 #include <stdbool.h>
+#if defined(__AVR__)
 #include <util/delay.h>
+#endif
 #include "matrix.h"
 #include "bootloader.h"
 #include "debug.h"
@@ -33,4 +35,4 @@ void magic(void)
     default_layer = eeconfig_read_default_layer();
     default_layer_set((uint32_t)default_layer);
 
-}
\ No newline at end of file
+}
diff --git a/tmk_core/common/matrix.h b/tmk_core/common/matrix.h
index 5f2f831b45..71153a5f58 100644
--- a/tmk_core/common/matrix.h
+++ b/tmk_core/common/matrix.h
@@ -20,59 +20,48 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include <stdint.h>
 #include <stdbool.h>
 
-#if MATRIX_COLS <= 8
-typedef uint8_t matrix_row_t;
-#elif MATRIX_COLS <= 16
-typedef uint16_t matrix_row_t;
-#elif MATRIX_COLS <= 32
-typedef uint32_t matrix_row_t;
+
+#if (MATRIX_COLS <= 8)
+typedef  uint8_t    matrix_row_t;
+#elif (MATRIX_COLS <= 16)
+typedef  uint16_t   matrix_row_t;
+#elif (MATRIX_COLS <= 32)
+typedef  uint32_t   matrix_row_t;
 #else
-#   error "There are too many columns."
+#error "MATRIX_COLS: invalid value"
 #endif
 
-#if DIODE_DIRECTION == ROW2COL
-#   if MATRIX_ROWS <= 8
-typedef uint8_t matrix_col_t;
-#   elif MATRIX_ROWS <= 16
-typedef uint16_t matrix_col_t;
-#   elif MATRIX_ROWS <= 32
-typedef uint32_t matrix_col_t;
-#   else
-#       error "There are too many rows."
-#   endif
-#endif
+#define MATRIX_IS_ON(row, col)  (matrix_get_row(row) && (1<<col))
 
-typedef struct {
-    uint8_t input_addr:4;
-    uint8_t bit:4;
-} io_pin_t;
 
 #ifdef __cplusplus
 extern "C" {
 #endif
-/* counts the number of rows in the matrix */
+
+/* number of matrix rows */
 uint8_t matrix_rows(void);
-/* counts the number of columns in the matrix */
+/* number of matrix columns */
 uint8_t matrix_cols(void);
-/* sets up the matrix before matrix_init */
+/* should be called at early stage of startup before matrix_init.(optional) */
 void matrix_setup(void);
-/* intializes the matrix */
+/* intialize matrix for scaning. */
 void matrix_init(void);
-/* scans the entire matrix */
+/* scan all key states on matrix */
 uint8_t matrix_scan(void);
-/* checks if the matrix has been modified */
+/* whether modified from previous scan. used after matrix_scan. */
 bool matrix_is_modified(void) __attribute__ ((deprecated));
-/* checks if a key is pressed */
+/* whether a swtich is on */
 bool matrix_is_on(uint8_t row, uint8_t col);
-/* inspects the state of a row in the matrix */
+/* matrix state on row */
 matrix_row_t matrix_get_row(uint8_t row);
-/* prints the matrix for debugging */
+/* print matrix for debug */
 void matrix_print(void);
-/* counts the total number of keys pressed */
-uint8_t matrix_key_count(void);
-/* controls power to the matrix */
+
+
+/* power control */
 void matrix_power_up(void);
 void matrix_power_down(void);
+
 /* executes code for Quantum */
 void matrix_init_quantum(void);
 void matrix_scan_quantum(void);
diff --git a/tmk_core/common/print.c b/tmk_core/common/print.c
index ca94e1e5d6..00489557f2 100644
--- a/tmk_core/common/print.c
+++ b/tmk_core/common/print.c
@@ -38,11 +38,15 @@ void print_set_sendchar(int8_t (*sendchar_func)(uint8_t))
     xdev_out(sendchar_func);
 }
 
-#elif defined(__arm__)
+#elif defined(PROTOCOL_CHIBIOS) /* __AVR__ */
+
+// don't need anything extra
+
+#elif defined(__arm__) /* __AVR__ */
 
 // TODO
 //void print_set_sendchar(int8_t (*sendchar_func)(uint8_t)) { }
 
-#endif
+#endif /* __AVR__ */
 
 #endif
diff --git a/tmk_core/common/print.h b/tmk_core/common/print.h
index 4f3dde65aa..0368bcd4a1 100644
--- a/tmk_core/common/print.h
+++ b/tmk_core/common/print.h
@@ -47,7 +47,15 @@ extern "C"
 /* function pointer of sendchar to be used by print utility */
 void print_set_sendchar(int8_t (*print_sendchar_func)(uint8_t));
 
-#elif defined(__arm__)
+#elif defined(PROTOCOL_CHIBIOS) /* __AVR__ */
+
+#include "chibios/printf.h"
+
+#define print(s)    printf(s)
+#define println(s)  printf(s "\r\n")
+#define xprintf  printf
+
+#elif defined(__arm__) /* __AVR__ */
 
 #include "mbed/xprintf.h"
 
diff --git a/tmk_core/common/progmem.h b/tmk_core/common/progmem.h
index 199b1bedfe..5b27656250 100644
--- a/tmk_core/common/progmem.h
+++ b/tmk_core/common/progmem.h
@@ -5,8 +5,8 @@
 #   include <avr/pgmspace.h>
 #elif defined(__arm__)
 #   define PROGMEM
-#   define pgm_read_byte(p)     *(p)
-#   define pgm_read_word(p)     *(p)
+#   define pgm_read_byte(p)     *((unsigned char*)p)
+#   define pgm_read_word(p)     *((uint16_t*)p)
 #endif
 
 #endif
diff --git a/tmk_core/common/report.h b/tmk_core/common/report.h
index f6c0a315de..0c799eca39 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_CHIBIOS) && defined(NKRO_ENABLE)
+#   include "protocol/chibios/usb_main.h"
+#   define KEYBOARD_REPORT_SIZE NKRO_EPSIZE
+#   define KEYBOARD_REPORT_KEYS (NKRO_EPSIZE - 2)
+#   define KEYBOARD_REPORT_BITS (NKRO_EPSIZE - 1)
 
 #else
 #   define KEYBOARD_REPORT_SIZE 8
diff --git a/tmk_core/common/wait.h b/tmk_core/common/wait.h
index 40d00b0c75..82727be012 100644
--- a/tmk_core/common/wait.h
+++ b/tmk_core/common/wait.h
@@ -9,9 +9,13 @@ extern "C" {
 #   include <util/delay.h>
 #   define wait_ms(ms)  _delay_ms(ms)
 #   define wait_us(us)  _delay_us(us)
-#elif defined(__arm__)
+#elif defined(PROTOCOL_CHIBIOS) /* __AVR__ */
+#   include "ch.h"
+#   define wait_ms(ms) chThdSleepMilliseconds(ms)
+#   define wait_us(us) chThdSleepMicroseconds(us)
+#elif defined(__arm__) /* __AVR__ */
 #   include "wait_api.h"
-#endif
+#endif /* __AVR__ */
 
 #ifdef __cplusplus
 }
diff --git a/tmk_core/protocol/chibios.mk b/tmk_core/protocol/chibios.mk
new file mode 100644
index 0000000000..3f4e0a71fc
--- /dev/null
+++ b/tmk_core/protocol/chibios.mk
@@ -0,0 +1,10 @@
+PROTOCOL_DIR = protocol
+CHIBIOS_DIR = $(PROTOCOL_DIR)/chibios
+
+
+SRC += $(CHIBIOS_DIR)/usb_main.c
+SRC += $(CHIBIOS_DIR)/main.c
+
+VPATH += $(TMK_PATH)/$(PROTOCOL_DIR)
+VPATH += $(TMK_PATH)/$(CHIBIOS_DIR)
+
diff --git a/tmk_core/protocol/chibios/README.md b/tmk_core/protocol/chibios/README.md
new file mode 100644
index 0000000000..63e6641f82
--- /dev/null
+++ b/tmk_core/protocol/chibios/README.md
@@ -0,0 +1,55 @@
+## TMK running on top of ChibiOS
+
+This code can be used to run TMK keyboard logic on top of [ChibiOS], meaning that you can run TMK on whatever [ChibiOS] supports. The notable examples are ARM-based Teensies (3.x and LC) and on the boards with STM32 MCUs.
+
+### Usage
+
+- To use, [get a zip of chibios](https://github.com/ChibiOS/ChibiOS/archive/a7df9a891067621e8e1a5c2a2c0ceada82403afe.zip) and unpack/rename it to `tmk_core/tool/chibios/chibios`; or you can just clone [the repo](https://github.com/ChibiOS/ChibiOS) there. For Freescale/NXP Kinetis support (meaning ARM Teensies and the Infinity keyboard), you'll also need [a zip of chibios-contrib](https://github.com/ChibiOS/ChibiOS-Contrib/archive/e1311c4db6cd366cf760673f769e925741ac0ad3.zip), unpacked/renamed to `tmk_core/tool/chibios/chibios-contrib`. Likewise, for git-savvy people, just clone [the repo](https://github.com/ChibiOS/ChibiOS-Contrib) there.
+- Note: the abovementioned directories are the defaults. You can have the two chibios repositories wherever you want, just define their location in `CHIBIOS` and `CHIBIOS_CONTRIB` variables in your `Makefile`.
+- You will also need to install an ARM toolchain, for instance from [here](https://launchpad.net/gcc-arm-embedded). On linux, this is usually also present as a package for your distribution (as `gcc-arm` or something similar). On OS X, you can use [homebrew](http://brew.sh/) with an appropriate tap.
+
+### Notes
+
+- Some comments about ChibiOS syntax and the most commonly used GPIO functions are, as well as an example for ARM Teensies, is [here](https://github.com/tmk/tmk_keyboard/blob/master/keyboard/teensy_lc_onekey/instructions.md).
+- For gcc options, inspect `tmk_core/tool/chibios/chibios.mk`. For instance, I enabled `-Wno-missing-field-initializers`, because TMK common bits generated a lot of warnings on that.
+- For debugging, it is sometimes useful disable gcc optimisations, you can do that by adding `-O0` to `OPT_DEFS` in your `Makefile`.
+- USB string descriptors are messy. I did not find a way to cleanly generate the right structures from actual strings, so the definitions in individual keyboards' `config.h` are ugly as heck.
+- It is easy to add some code for testing (e.g. blink LED, do stuff on button press, etc...) - just create another thread in `main.c`, it will run independently of the keyboard business.
+- Jumping to (the built-in) bootloaders on STM32 works, but it is not entirely pleasant, since it is very much MCU dependent. So, one needs to dig out the right address to jump to, and either pass it to the compiler in the `Makefile`, or better, define it in `<your_kb>/bootloader_defs.h`. An additional startup code is also needed; the best way to deal with this is to define custom board files. (Example forthcoming.) In any case, there are no problems for Teensies.
+
+
+### Immediate todo
+
+- power saving for suspend
+
+### Not tested, but possibly working
+
+- backlight
+
+### Missing / not working (TMK vs ChibiOS bits)
+
+- eeprom / bootmagic for STM32 (will be chip dependent; eeprom needs to be emulated in flash, which means less writes; wear-levelling?) There is a semi-official ST "driver" for eeprom, with wear-levelling, but I think it consumes a lot of RAM (like 2 pages, i.e. 1kB or so).
+
+### Tried with
+
+- Infinity, WhiteFox keyboards
+- all ARM-based Teensies
+- some STM32-based boards (e.g. ST-F072RB-DISCOVERY board, STM32F042 breakout board, Maple Mini (STM32F103-based))
+
+## ChibiOS-supported MCUs
+
+- Pretty much all STM32 chips.
+- K20x and KL2x Freescale/NXP chips (i.e. Teensy 3.x/LC, mchck, FRDM-KL2{5,6}Z, FRDM-K20D50M), via the [ChibiOS-Contrib](https://github.com/ChibiOS/ChibiOS-Contrib) repository.
+- There is also support for AVR8, but the USB stack is not implemented for them yet (some news on that front recently though), and also the kernel itself takes about 1k of RAM. I think people managed to get ChibiOS running on atmega32[8p/u4] though.
+- There is also support for Nordic NRF51822 (the chip in Adafruit's Bluefruit bluetooth-low-energy boards), but be aware that that chip does *not* have USB, and the BLE softdevice (i.e. Bluetooth) is not supported directly at the moment.
+
+## STM32-based keyboard design considerations
+
+- STM32F0x2 chips can do crystal-less USB, but they still need a 3.3V voltage regulator.
+- The BOOT0 pin should be tied to GND.
+- For a hardware way of accessing the in-built DFU bootloader, in addition to the reset button, put another button between the BOOT0 pin and 3V3.
+- There is a working example of a STM32F042-based keyboard: [firmware here](https://github.com/flabbergast/flabber_kbs/tree/master/kb45p) and [hardware (kicad) here](https://github.com/flabbergast/kicad/tree/master/kb45p). You can check this example firmware for custom board files, and a more complicated matrix than just one key.
+
+
+
+[ChibiOS]: http://chibios.org
diff --git a/tmk_core/protocol/chibios/main.c b/tmk_core/protocol/chibios/main.c
new file mode 100644
index 0000000000..54bb6a8f55
--- /dev/null
+++ b/tmk_core/protocol/chibios/main.c
@@ -0,0 +1,147 @@
+/*
+ * (c) 2015 flabberast <s3+flabbergast@sdfeu.org>
+ *
+ * Based on the following work:
+ *  - Guillaume Duc's raw hid example (MIT License)
+ *    https://github.com/guiduc/usb-hid-chibios-example
+ *  - PJRC Teensy examples (MIT License)
+ *    https://www.pjrc.com/teensy/usb_keyboard.html
+ *  - hasu's TMK keyboard code (GPL v2 and some code Modified BSD)
+ *    https://github.com/tmk/tmk_keyboard/
+ *  - ChibiOS demo code (Apache 2.0 License)
+ *    http://www.chibios.org
+ *
+ * Since some GPL'd code is used, this work is licensed under
+ * GPL v2 or later.
+ */
+
+#include "ch.h"
+#include "hal.h"
+
+#include "usb_main.h"
+
+/* TMK includes */
+#include "report.h"
+#include "host.h"
+#include "host_driver.h"
+#include "keyboard.h"
+#include "action.h"
+#include "action_util.h"
+#include "mousekey.h"
+#include "led.h"
+#include "sendchar.h"
+#include "debug.h"
+#include "printf.h"
+#ifdef SLEEP_LED_ENABLE
+#include "sleep_led.h"
+#endif
+#include "suspend.h"
+
+
+/* -------------------------
+ *   TMK host driver defs
+ * -------------------------
+ */
+
+/* declarations */
+uint8_t keyboard_leds(void);
+void send_keyboard(report_keyboard_t *report);
+void send_mouse(report_mouse_t *report);
+void send_system(uint16_t data);
+void send_consumer(uint16_t data);
+
+/* host struct */
+host_driver_t chibios_driver = {
+  keyboard_leds,
+  send_keyboard,
+  send_mouse,
+  send_system,
+  send_consumer
+};
+
+
+/* TESTING
+ * Amber LED blinker thread, times are in milliseconds.
+ */
+/* set this variable to non-zero anywhere to blink once */
+// uint8_t blinkLed = 0;
+// static THD_WORKING_AREA(waBlinkerThread, 128);
+// static THD_FUNCTION(blinkerThread, arg) {
+//   (void)arg;
+//   chRegSetThreadName("blinkOrange");
+//   while(true) {
+//     if(blinkLed) {
+//       blinkLed = 0;
+//       palSetPad(TEENSY_PIN13_IOPORT, TEENSY_PIN13);
+//       chThdSleepMilliseconds(100);
+//       palClearPad(TEENSY_PIN13_IOPORT, TEENSY_PIN13);
+//     }
+//     chThdSleepMilliseconds(100);
+//   }
+// }
+
+
+
+/* Main thread
+ */
+int main(void) {
+  /* ChibiOS/RT init */
+  halInit();
+  chSysInit();
+
+  // TESTING
+  // chThdCreateStatic(waBlinkerThread, sizeof(waBlinkerThread), NORMALPRIO, blinkerThread, NULL);
+
+  /* Init USB */
+  init_usb_driver(&USB_DRIVER);
+
+  /* init printf */
+  init_printf(NULL,sendchar_pf);
+
+  /* Wait until the USB is active */
+  while(USB_DRIVER.state != USB_ACTIVE)
+    chThdSleepMilliseconds(50);
+
+  /* Do need to wait here!
+   * Otherwise the next print might start a transfer on console EP
+   * before the USB is completely ready, which sometimes causes
+   * HardFaults.
+   */
+  chThdSleepMilliseconds(50);
+
+  print("USB configured.\n");
+
+  /* init TMK modules */
+  keyboard_init();
+  host_set_driver(&chibios_driver);
+
+#ifdef SLEEP_LED_ENABLE
+  sleep_led_init();
+#endif
+
+  print("Keyboard start.\n");
+
+  /* Main loop */
+  while(true) {
+
+    if(USB_DRIVER.state == USB_SUSPENDED) {
+      print("[s]");
+      while(USB_DRIVER.state == USB_SUSPENDED) {
+        /* Do this in the suspended state */
+        suspend_power_down(); // on AVR this deep sleeps for 15ms
+        /* Remote wakeup */
+        if((USB_DRIVER.status & 2) && suspend_wakeup_condition()) {
+          send_remote_wakeup(&USB_DRIVER);
+        }
+      }
+      /* Woken up */
+      // variables has been already cleared by the wakeup hook
+      send_keyboard_report();
+#ifdef MOUSEKEY_ENABLE
+      mousekey_send();
+#endif /* MOUSEKEY_ENABLE */
+    }
+
+    keyboard_task();
+  }
+}
diff --git a/tmk_core/protocol/chibios/usb_main.c b/tmk_core/protocol/chibios/usb_main.c
new file mode 100644
index 0000000000..e2c9d9bf14
--- /dev/null
+++ b/tmk_core/protocol/chibios/usb_main.c
@@ -0,0 +1,1372 @@
+/*
+ * (c) 2015 flabberast <s3+flabbergast@sdfeu.org>
+ *
+ * Based on the following work:
+ *  - Guillaume Duc's raw hid example (MIT License)
+ *    https://github.com/guiduc/usb-hid-chibios-example
+ *  - PJRC Teensy examples (MIT License)
+ *    https://www.pjrc.com/teensy/usb_keyboard.html
+ *  - hasu's TMK keyboard code (GPL v2 and some code Modified BSD)
+ *    https://github.com/tmk/tmk_keyboard/
+ *  - ChibiOS demo code (Apache 2.0 License)
+ *    http://www.chibios.org
+ *
+ * Since some GPL'd code is used, this work is licensed under
+ * GPL v2 or later.
+ */
+
+#include "ch.h"
+#include "hal.h"
+
+#include "usb_main.h"
+
+#include "host.h"
+#include "debug.h"
+#include "suspend.h"
+#ifdef SLEEP_LED_ENABLE
+#include "sleep_led.h"
+#include "led.h"
+#endif
+
+/* ---------------------------------------------------------
+ *       Global interface variables and declarations
+ * ---------------------------------------------------------
+ */
+
+uint8_t keyboard_idle __attribute__((aligned(2))) = 0;
+uint8_t keyboard_protocol __attribute__((aligned(2))) = 1;
+uint16_t keyboard_led_stats __attribute__((aligned(2))) = 0;
+volatile uint16_t keyboard_idle_count = 0;
+static virtual_timer_t keyboard_idle_timer;
+static void keyboard_idle_timer_cb(void *arg);
+#ifdef NKRO_ENABLE
+extern bool keyboard_nkro;
+#endif /* NKRO_ENABLE */
+
+report_keyboard_t keyboard_report_sent = {{0}};
+#ifdef MOUSE_ENABLE
+report_mouse_t mouse_report_blank = {0};
+#endif /* MOUSE_ENABLE */
+#ifdef EXTRAKEY_ENABLE
+uint8_t extra_report_blank[3] = {0};
+#endif /* EXTRAKEY_ENABLE */
+
+#ifdef CONSOLE_ENABLE
+/* The emission buffers queue */
+output_buffers_queue_t console_buf_queue;
+static uint8_t console_queue_buffer[BQ_BUFFER_SIZE(CONSOLE_QUEUE_CAPACITY, CONSOLE_EPSIZE)];
+
+static virtual_timer_t console_flush_timer;
+void console_queue_onotify(io_buffers_queue_t *bqp);
+static void console_flush_cb(void *arg);
+#endif /* CONSOLE_ENABLE */
+
+/* ---------------------------------------------------------
+ *            Descriptors and USB driver objects
+ * ---------------------------------------------------------
+ */
+
+/* HID specific constants */
+#define USB_DESCRIPTOR_HID 0x21
+#define USB_DESCRIPTOR_HID_REPORT 0x22
+#define HID_GET_REPORT 0x01
+#define HID_GET_IDLE 0x02
+#define HID_GET_PROTOCOL 0x03
+#define HID_SET_REPORT 0x09
+#define HID_SET_IDLE 0x0A
+#define HID_SET_PROTOCOL 0x0B
+
+/* USB Device Descriptor */
+static const uint8_t usb_device_descriptor_data[] = {
+  USB_DESC_DEVICE(0x0200,      // bcdUSB (1.1)
+                  0,           // bDeviceClass (defined in later in interface)
+                  0,           // bDeviceSubClass
+                  0,           // bDeviceProtocol
+                  64,          // bMaxPacketSize (64 bytes) (the driver didn't work with 32)
+                  VENDOR_ID,   // idVendor
+                  PRODUCT_ID,  // idProduct
+                  DEVICE_VER,      // bcdDevice
+                  1,           // iManufacturer
+                  2,           // iProduct
+                  3,           // iSerialNumber
+                  1)           // bNumConfigurations
+};
+
+/* Device Descriptor wrapper */
+static const USBDescriptor usb_device_descriptor = {
+  sizeof usb_device_descriptor_data,
+  usb_device_descriptor_data
+};
+
+/*
+ * HID Report Descriptor
+ *
+ * See "Device Class Definition for Human Interface Devices (HID)"
+ * (http://www.usb.org/developers/hidpage/HID1_11.pdf) for the
+ * detailed descrition of all the fields
+ */
+
+/* Keyboard Protocol 1, HID 1.11 spec, Appendix B, page 59-60 */
+static const uint8_t keyboard_hid_report_desc_data[] = {
+  0x05, 0x01,                // Usage Page (Generic Desktop),
+  0x09, 0x06,                // Usage (Keyboard),
+  0xA1, 0x01,                // Collection (Application),
+  0x75, 0x01,                //   Report Size (1),
+  0x95, 0x08,                //   Report Count (8),
+  0x05, 0x07,                //   Usage Page (Key Codes),
+  0x19, 0xE0,                //   Usage Minimum (224),
+  0x29, 0xE7,                //   Usage Maximum (231),
+  0x15, 0x00,                //   Logical Minimum (0),
+  0x25, 0x01,                //   Logical Maximum (1),
+  0x81, 0x02,                //   Input (Data, Variable, Absolute), ;Modifier byte
+  0x95, 0x01,                //   Report Count (1),
+  0x75, 0x08,                //   Report Size (8),
+  0x81, 0x03,                //   Input (Constant),                 ;Reserved byte
+  0x95, 0x05,                //   Report Count (5),
+  0x75, 0x01,                //   Report Size (1),
+  0x05, 0x08,                //   Usage Page (LEDs),
+  0x19, 0x01,                //   Usage Minimum (1),
+  0x29, 0x05,                //   Usage Maximum (5),
+  0x91, 0x02,                //   Output (Data, Variable, Absolute), ;LED report
+  0x95, 0x01,                //   Report Count (1),
+  0x75, 0x03,                //   Report Size (3),
+  0x91, 0x03,                //   Output (Constant),                 ;LED report padding
+  0x95, KBD_REPORT_KEYS,          //   Report Count (),
+  0x75, 0x08,                //   Report Size (8),
+  0x15, 0x00,                //   Logical Minimum (0),
+  0x25, 0xFF,                //   Logical Maximum(255),
+  0x05, 0x07,                //   Usage Page (Key Codes),
+  0x19, 0x00,                //   Usage Minimum (0),
+  0x29, 0xFF,                //   Usage Maximum (255),
+  0x81, 0x00,                //   Input (Data, Array),
+  0xc0                       // End Collection
+};
+/* wrapper */
+static const USBDescriptor keyboard_hid_report_descriptor = {
+  sizeof keyboard_hid_report_desc_data,
+  keyboard_hid_report_desc_data
+};
+
+#ifdef NKRO_ENABLE
+static const uint8_t nkro_hid_report_desc_data[] = {
+  0x05, 0x01,                           // Usage Page (Generic Desktop),
+  0x09, 0x06,                           // Usage (Keyboard),
+  0xA1, 0x01,                           // Collection (Application),
+  // bitmap of modifiers
+  0x75, 0x01,                           //   Report Size (1),
+  0x95, 0x08,                           //   Report Count (8),
+  0x05, 0x07,                           //   Usage Page (Key Codes),
+  0x19, 0xE0,                           //   Usage Minimum (224),
+  0x29, 0xE7,                           //   Usage Maximum (231),
+  0x15, 0x00,                           //   Logical Minimum (0),
+  0x25, 0x01,                           //   Logical Maximum (1),
+  0x81, 0x02,                           //   Input (Data, Variable, Absolute), ;Modifier byte
+  // LED output report
+  0x95, 0x05,                           //   Report Count (5),
+  0x75, 0x01,                           //   Report Size (1),
+  0x05, 0x08,                           //   Usage Page (LEDs),
+  0x19, 0x01,                           //   Usage Minimum (1),
+  0x29, 0x05,                           //   Usage Maximum (5),
+  0x91, 0x02,                           //   Output (Data, Variable, Absolute),
+  0x95, 0x01,                           //   Report Count (1),
+  0x75, 0x03,                           //   Report Size (3),
+  0x91, 0x03,                           //   Output (Constant),
+  // bitmap of keys
+  0x95, NKRO_REPORT_KEYS * 8,           //   Report Count (),
+  0x75, 0x01,                           //   Report Size (1),
+  0x15, 0x00,                           //   Logical Minimum (0),
+  0x25, 0x01,                           //   Logical Maximum(1),
+  0x05, 0x07,                           //   Usage Page (Key Codes),
+  0x19, 0x00,                           //   Usage Minimum (0),
+  0x29, NKRO_REPORT_KEYS * 8 - 1,       //   Usage Maximum (),
+  0x81, 0x02,                           //   Input (Data, Variable, Absolute),
+  0xc0                                  // End Collection
+};
+/* wrapper */
+static const USBDescriptor nkro_hid_report_descriptor = {
+  sizeof nkro_hid_report_desc_data,
+  nkro_hid_report_desc_data
+};
+#endif /* NKRO_ENABLE */
+
+#ifdef MOUSE_ENABLE
+/* Mouse Protocol 1, HID 1.11 spec, Appendix B, page 59-60, with wheel extension
+ * http://www.microchip.com/forums/tm.aspx?high=&m=391435&mpage=1#391521
+ * http://www.keil.com/forum/15671/
+ * http://www.microsoft.com/whdc/device/input/wheel.mspx */
+static const uint8_t mouse_hid_report_desc_data[] = {
+  /* mouse */
+  0x05, 0x01,                      // USAGE_PAGE (Generic Desktop)
+  0x09, 0x02,                      // USAGE (Mouse)
+  0xa1, 0x01,                      // COLLECTION (Application)
+  //0x85, REPORT_ID_MOUSE,         //   REPORT_ID (1)
+  0x09, 0x01,                      //   USAGE (Pointer)
+  0xa1, 0x00,                      //   COLLECTION (Physical)
+                                   // ----------------------------  Buttons
+  0x05, 0x09,                      //     USAGE_PAGE (Button)
+  0x19, 0x01,                      //     USAGE_MINIMUM (Button 1)
+  0x29, 0x05,                      //     USAGE_MAXIMUM (Button 5)
+  0x15, 0x00,                      //     LOGICAL_MINIMUM (0)
+  0x25, 0x01,                      //     LOGICAL_MAXIMUM (1)
+  0x75, 0x01,                      //     REPORT_SIZE (1)
+  0x95, 0x05,                      //     REPORT_COUNT (5)
+  0x81, 0x02,                      //     INPUT (Data,Var,Abs)
+  0x75, 0x03,                      //     REPORT_SIZE (3)
+  0x95, 0x01,                      //     REPORT_COUNT (1)
+  0x81, 0x03,                      //     INPUT (Cnst,Var,Abs)
+                                   // ----------------------------  X,Y position
+  0x05, 0x01,                      //     USAGE_PAGE (Generic Desktop)
+  0x09, 0x30,                      //     USAGE (X)
+  0x09, 0x31,                      //     USAGE (Y)
+  0x15, 0x81,                      //     LOGICAL_MINIMUM (-127)
+  0x25, 0x7f,                      //     LOGICAL_MAXIMUM (127)
+  0x75, 0x08,                      //     REPORT_SIZE (8)
+  0x95, 0x02,                      //     REPORT_COUNT (2)
+  0x81, 0x06,                      //     INPUT (Data,Var,Rel)
+                                   // ----------------------------  Vertical wheel
+  0x09, 0x38,                      //     USAGE (Wheel)
+  0x15, 0x81,                      //     LOGICAL_MINIMUM (-127)
+  0x25, 0x7f,                      //     LOGICAL_MAXIMUM (127)
+  0x35, 0x00,                      //     PHYSICAL_MINIMUM (0)        - reset physical
+  0x45, 0x00,                      //     PHYSICAL_MAXIMUM (0)
+  0x75, 0x08,                      //     REPORT_SIZE (8)
+  0x95, 0x01,                      //     REPORT_COUNT (1)
+  0x81, 0x06,                      //     INPUT (Data,Var,Rel)
+                                   // ----------------------------  Horizontal wheel
+  0x05, 0x0c,                      //     USAGE_PAGE (Consumer Devices)
+  0x0a, 0x38, 0x02,                //     USAGE (AC Pan)
+  0x15, 0x81,                      //     LOGICAL_MINIMUM (-127)
+  0x25, 0x7f,                      //     LOGICAL_MAXIMUM (127)
+  0x75, 0x08,                      //     REPORT_SIZE (8)
+  0x95, 0x01,                      //     REPORT_COUNT (1)
+  0x81, 0x06,                      //     INPUT (Data,Var,Rel)
+  0xc0,                            //   END_COLLECTION
+  0xc0,                            // END_COLLECTION
+};
+/* wrapper */
+static const USBDescriptor mouse_hid_report_descriptor = {
+  sizeof mouse_hid_report_desc_data,
+  mouse_hid_report_desc_data
+};
+#endif /* MOUSE_ENABLE */
+
+#ifdef CONSOLE_ENABLE
+static const uint8_t console_hid_report_desc_data[] = {
+  0x06, 0x31, 0xFF, // Usage Page 0xFF31 (vendor defined)
+  0x09, 0x74,       // Usage 0x74
+  0xA1, 0x53,       // Collection 0x53
+  0x75, 0x08,       // report size = 8 bits
+  0x15, 0x00,       // logical minimum = 0
+  0x26, 0xFF, 0x00, // logical maximum = 255
+  0x95, CONSOLE_EPSIZE, // report count
+  0x09, 0x75,       // usage
+  0x81, 0x02,       // Input (array)
+  0xC0              // end collection
+};
+/* wrapper */
+static const USBDescriptor console_hid_report_descriptor = {
+  sizeof console_hid_report_desc_data,
+  console_hid_report_desc_data
+};
+#endif /* CONSOLE_ENABLE */
+
+#ifdef EXTRAKEY_ENABLE
+/* audio controls & system controls
+ * http://www.microsoft.com/whdc/archive/w2kbd.mspx */
+static const uint8_t extra_hid_report_desc_data[] = {
+  /* system control */
+  0x05, 0x01,                      // USAGE_PAGE (Generic Desktop)
+  0x09, 0x80,                      // USAGE (System Control)
+  0xa1, 0x01,                      // COLLECTION (Application)
+  0x85, REPORT_ID_SYSTEM,          //   REPORT_ID (2)
+  0x15, 0x01,                      //   LOGICAL_MINIMUM (0x1)
+  0x25, 0xb7,                      //   LOGICAL_MAXIMUM (0xb7)
+  0x19, 0x01,                      //   USAGE_MINIMUM (0x1)
+  0x29, 0xb7,                      //   USAGE_MAXIMUM (0xb7)
+  0x75, 0x10,                      //   REPORT_SIZE (16)
+  0x95, 0x01,                      //   REPORT_COUNT (1)
+  0x81, 0x00,                      //   INPUT (Data,Array,Abs)
+  0xc0,                            // END_COLLECTION
+  /* consumer */
+  0x05, 0x0c,                      // USAGE_PAGE (Consumer Devices)
+  0x09, 0x01,                      // USAGE (Consumer Control)
+  0xa1, 0x01,                      // COLLECTION (Application)
+  0x85, REPORT_ID_CONSUMER,        //   REPORT_ID (3)
+  0x15, 0x01,                      //   LOGICAL_MINIMUM (0x1)
+  0x26, 0x9c, 0x02,                //   LOGICAL_MAXIMUM (0x29c)
+  0x19, 0x01,                      //   USAGE_MINIMUM (0x1)
+  0x2a, 0x9c, 0x02,                //   USAGE_MAXIMUM (0x29c)
+  0x75, 0x10,                      //   REPORT_SIZE (16)
+  0x95, 0x01,                      //   REPORT_COUNT (1)
+  0x81, 0x00,                      //   INPUT (Data,Array,Abs)
+  0xc0,                            // END_COLLECTION
+};
+/* wrapper */
+static const USBDescriptor extra_hid_report_descriptor = {
+  sizeof extra_hid_report_desc_data,
+  extra_hid_report_desc_data
+};
+#endif /* EXTRAKEY_ENABLE */
+
+
+/*
+ * Configuration Descriptor tree for a HID device
+ *
+ * The HID Specifications version 1.11 require the following order:
+ * - Configuration Descriptor
+ * - Interface Descriptor
+ * - HID Descriptor
+ * - Endpoints Descriptors
+ */
+#define KBD_HID_DESC_NUM                0
+#define KBD_HID_DESC_OFFSET             (9 + (9 + 9 + 7) * KBD_HID_DESC_NUM + 9)
+
+#ifdef MOUSE_ENABLE
+#   define MOUSE_HID_DESC_NUM           (KBD_HID_DESC_NUM + 1)
+#   define MOUSE_HID_DESC_OFFSET        (9 + (9 + 9 + 7) * MOUSE_HID_DESC_NUM + 9)
+#else /* MOUSE_ENABLE */
+#   define MOUSE_HID_DESC_NUM           (KBD_HID_DESC_NUM + 0)
+#endif /* MOUSE_ENABLE */
+
+#ifdef CONSOLE_ENABLE
+#define CONSOLE_HID_DESC_NUM            (MOUSE_HID_DESC_NUM + 1)
+#define CONSOLE_HID_DESC_OFFSET         (9 + (9 + 9 + 7) * CONSOLE_HID_DESC_NUM + 9)
+#else /* CONSOLE_ENABLE */
+#   define CONSOLE_HID_DESC_NUM         (MOUSE_HID_DESC_NUM + 0)
+#endif /* CONSOLE_ENABLE */
+
+#ifdef EXTRAKEY_ENABLE
+#   define EXTRA_HID_DESC_NUM           (CONSOLE_HID_DESC_NUM + 1)
+#   define EXTRA_HID_DESC_OFFSET        (9 + (9 + 9 + 7) * EXTRA_HID_DESC_NUM + 9)
+#else /* EXTRAKEY_ENABLE */
+#   define EXTRA_HID_DESC_NUM           (CONSOLE_HID_DESC_NUM + 0)
+#endif /* EXTRAKEY_ENABLE */
+
+#ifdef NKRO_ENABLE
+#   define NKRO_HID_DESC_NUM            (EXTRA_HID_DESC_NUM + 1)
+#   define NKRO_HID_DESC_OFFSET         (9 + (9 + 9 + 7) * EXTRA_HID_DESC_NUM + 9)
+#else /* NKRO_ENABLE */
+#   define NKRO_HID_DESC_NUM            (EXTRA_HID_DESC_NUM + 0)
+#endif /* NKRO_ENABLE */
+
+#define NUM_INTERFACES                  (NKRO_HID_DESC_NUM + 1)
+#define CONFIG1_DESC_SIZE               (9 + (9 + 9 + 7) * NUM_INTERFACES)
+
+static const uint8_t hid_configuration_descriptor_data[] = {
+  /* Configuration Descriptor (9 bytes) USB spec 9.6.3, page 264-266, Table 9-10 */
+  USB_DESC_CONFIGURATION(CONFIG1_DESC_SIZE, // wTotalLength
+                         NUM_INTERFACES,    // bNumInterfaces
+                         1,    // bConfigurationValue
+                         0,    // iConfiguration
+                         0xA0, // bmAttributes (RESERVED|REMOTEWAKEUP)
+                         50),  // bMaxPower (50mA)
+
+  /* Interface Descriptor (9 bytes) USB spec 9.6.5, page 267-269, Table 9-12 */
+  USB_DESC_INTERFACE(KBD_INTERFACE,        // bInterfaceNumber
+                     0,        // bAlternateSetting
+                     1,        // bNumEndpoints
+                     0x03,     // bInterfaceClass: HID
+                     0x01,     // bInterfaceSubClass: Boot
+                     0x01,     // bInterfaceProtocol: Keyboard
+                     0),       // iInterface
+
+  /* HID descriptor (9 bytes) HID 1.11 spec, section 6.2.1 */
+  USB_DESC_BYTE(9),            // bLength
+  USB_DESC_BYTE(0x21),         // bDescriptorType (HID class)
+  USB_DESC_BCD(0x0111),        // bcdHID: HID version 1.11
+  USB_DESC_BYTE(0),            // bCountryCode
+  USB_DESC_BYTE(1),            // bNumDescriptors
+  USB_DESC_BYTE(0x22),         // bDescriptorType (report desc)
+  USB_DESC_WORD(sizeof(keyboard_hid_report_desc_data)), // wDescriptorLength
+
+  /* Endpoint Descriptor (7 bytes) USB spec 9.6.6, page 269-271, Table 9-13 */
+  USB_DESC_ENDPOINT(KBD_ENDPOINT | 0x80,  // bEndpointAddress
+                    0x03,      // bmAttributes (Interrupt)
+                    KBD_EPSIZE,// wMaxPacketSize
+                    10),       // bInterval
+
+  #ifdef MOUSE_ENABLE
+  /* Interface Descriptor (9 bytes) USB spec 9.6.5, page 267-269, Table 9-12 */
+  USB_DESC_INTERFACE(MOUSE_INTERFACE,   // bInterfaceNumber
+                     0,        // bAlternateSetting
+                     1,        // bNumEndpoints
+                     0x03,     // bInterfaceClass (0x03 = HID)
+                     // ThinkPad T23 BIOS doesn't work with boot mouse.
+                     0x00,     // bInterfaceSubClass (0x01 = Boot)
+                     0x00,     // bInterfaceProtocol (0x02 = Mouse)
+                     /*
+                        0x01,      // bInterfaceSubClass (0x01 = Boot)
+                        0x02,      // bInterfaceProtocol (0x02 = Mouse)
+                      */
+                     0),        // iInterface
+
+  /* HID descriptor (9 bytes) HID 1.11 spec, section 6.2.1 */
+  USB_DESC_BYTE(9),            // bLength
+  USB_DESC_BYTE(0x21),         // bDescriptorType (HID class)
+  USB_DESC_BCD(0x0111),        // bcdHID: HID version 1.11
+  USB_DESC_BYTE(0),            // bCountryCode
+  USB_DESC_BYTE(1),            // bNumDescriptors
+  USB_DESC_BYTE(0x22),         // bDescriptorType (report desc)
+  USB_DESC_WORD(sizeof(mouse_hid_report_desc_data)), // wDescriptorLength
+
+  /* Endpoint Descriptor (7 bytes) USB spec 9.6.6, page 269-271, Table 9-13 */
+  USB_DESC_ENDPOINT(MOUSE_ENDPOINT | 0x80,  // bEndpointAddress
+                    0x03,      // bmAttributes (Interrupt)
+                    MOUSE_EPSIZE,  // wMaxPacketSize
+                    1),        // bInterval
+  #endif /* MOUSE_ENABLE */
+
+  #ifdef CONSOLE_ENABLE
+  /* Interface Descriptor (9 bytes) USB spec 9.6.5, page 267-269, Table 9-12 */
+  USB_DESC_INTERFACE(CONSOLE_INTERFACE, // bInterfaceNumber
+                     0,        // bAlternateSetting
+                     1,        // bNumEndpoints
+                     0x03,     // bInterfaceClass: HID
+                     0x00,     // bInterfaceSubClass: None
+                     0x00,     // bInterfaceProtocol: None
+                     0),       // iInterface
+
+  /* HID descriptor (9 bytes) HID 1.11 spec, section 6.2.1 */
+  USB_DESC_BYTE(9),            // bLength
+  USB_DESC_BYTE(0x21),         // bDescriptorType (HID class)
+  USB_DESC_BCD(0x0111),        // bcdHID: HID version 1.11
+  USB_DESC_BYTE(0),            // bCountryCode
+  USB_DESC_BYTE(1),            // bNumDescriptors
+  USB_DESC_BYTE(0x22),         // bDescriptorType (report desc)
+  USB_DESC_WORD(sizeof(console_hid_report_desc_data)), // wDescriptorLength
+
+  /* Endpoint Descriptor (7 bytes) USB spec 9.6.6, page 269-271, Table 9-13 */
+  USB_DESC_ENDPOINT(CONSOLE_ENDPOINT | 0x80,  // bEndpointAddress
+                    0x03,      // bmAttributes (Interrupt)
+                    CONSOLE_EPSIZE, // wMaxPacketSize
+                    1),        // bInterval
+  #endif /* CONSOLE_ENABLE */
+
+  #ifdef EXTRAKEY_ENABLE
+  /* Interface Descriptor (9 bytes) USB spec 9.6.5, page 267-269, Table 9-12 */
+  USB_DESC_INTERFACE(EXTRA_INTERFACE, // bInterfaceNumber
+                     0,        // bAlternateSetting
+                     1,        // bNumEndpoints
+                     0x03,     // bInterfaceClass: HID
+                     0x00,     // bInterfaceSubClass: None
+                     0x00,     // bInterfaceProtocol: None
+                     0),       // iInterface
+
+  /* HID descriptor (9 bytes) HID 1.11 spec, section 6.2.1 */
+  USB_DESC_BYTE(9),            // bLength
+  USB_DESC_BYTE(0x21),         // bDescriptorType (HID class)
+  USB_DESC_BCD(0x0111),        // bcdHID: HID version 1.11
+  USB_DESC_BYTE(0),            // bCountryCode
+  USB_DESC_BYTE(1),            // bNumDescriptors
+  USB_DESC_BYTE(0x22),         // bDescriptorType (report desc)
+  USB_DESC_WORD(sizeof(extra_hid_report_desc_data)), // wDescriptorLength
+
+  /* Endpoint Descriptor (7 bytes) USB spec 9.6.6, page 269-271, Table 9-13 */
+  USB_DESC_ENDPOINT(EXTRA_ENDPOINT | 0x80,  // bEndpointAddress
+                    0x03,      // bmAttributes (Interrupt)
+                    EXTRA_EPSIZE, // wMaxPacketSize
+                    10),       // bInterval
+  #endif /* EXTRAKEY_ENABLE */
+
+  #ifdef NKRO_ENABLE
+  /* Interface Descriptor (9 bytes) USB spec 9.6.5, page 267-269, Table 9-12 */
+  USB_DESC_INTERFACE(NKRO_INTERFACE, // bInterfaceNumber
+                     0,        // bAlternateSetting
+                     1,        // bNumEndpoints
+                     0x03,     // bInterfaceClass: HID
+                     0x00,     // bInterfaceSubClass: None
+                     0x00,     // bInterfaceProtocol: None
+                     0),       // iInterface
+
+  /* HID descriptor (9 bytes) HID 1.11 spec, section 6.2.1 */
+  USB_DESC_BYTE(9),            // bLength
+  USB_DESC_BYTE(0x21),         // bDescriptorType (HID class)
+  USB_DESC_BCD(0x0111),        // bcdHID: HID version 1.11
+  USB_DESC_BYTE(0),            // bCountryCode
+  USB_DESC_BYTE(1),            // bNumDescriptors
+  USB_DESC_BYTE(0x22),         // bDescriptorType (report desc)
+  USB_DESC_WORD(sizeof(nkro_hid_report_desc_data)), // wDescriptorLength
+
+  /* Endpoint Descriptor (7 bytes) USB spec 9.6.6, page 269-271, Table 9-13 */
+  USB_DESC_ENDPOINT(NKRO_ENDPOINT | 0x80,  // bEndpointAddress
+                    0x03,      // bmAttributes (Interrupt)
+                    NKRO_EPSIZE, // wMaxPacketSize
+                    1),       // bInterval
+  #endif /* NKRO_ENABLE */
+};
+
+/* Configuration Descriptor wrapper */
+static const USBDescriptor hid_configuration_descriptor = {
+  sizeof hid_configuration_descriptor_data,
+  hid_configuration_descriptor_data
+};
+
+/* wrappers */
+#define HID_DESCRIPTOR_SIZE 9
+static const USBDescriptor keyboard_hid_descriptor = {
+  HID_DESCRIPTOR_SIZE,
+  &hid_configuration_descriptor_data[KBD_HID_DESC_OFFSET]
+};
+#ifdef MOUSE_ENABLE
+static const USBDescriptor mouse_hid_descriptor = {
+  HID_DESCRIPTOR_SIZE,
+  &hid_configuration_descriptor_data[MOUSE_HID_DESC_OFFSET]
+};
+#endif /* MOUSE_ENABLE */
+#ifdef CONSOLE_ENABLE
+static const USBDescriptor console_hid_descriptor = {
+  HID_DESCRIPTOR_SIZE,
+  &hid_configuration_descriptor_data[CONSOLE_HID_DESC_OFFSET]
+};
+#endif /* CONSOLE_ENABLE */
+#ifdef EXTRAKEY_ENABLE
+static const USBDescriptor extra_hid_descriptor = {
+  HID_DESCRIPTOR_SIZE,
+  &hid_configuration_descriptor_data[EXTRA_HID_DESC_OFFSET]
+};
+#endif /* EXTRAKEY_ENABLE */
+#ifdef NKRO_ENABLE
+static const USBDescriptor nkro_hid_descriptor = {
+  HID_DESCRIPTOR_SIZE,
+  &hid_configuration_descriptor_data[NKRO_HID_DESC_OFFSET]
+};
+#endif /* NKRO_ENABLE */
+
+
+/* U.S. English language identifier */
+static const uint8_t usb_string_langid[] = {
+  USB_DESC_BYTE(4),                        // bLength
+  USB_DESC_BYTE(USB_DESCRIPTOR_STRING),    // bDescriptorType
+  USB_DESC_WORD(0x0409)                    // wLANGID (U.S. English)
+};
+
+/* ugly ugly hack */
+#define PP_NARG(...) \
+         PP_NARG_(__VA_ARGS__,PP_RSEQ_N())
+#define PP_NARG_(...) \
+         PP_ARG_N(__VA_ARGS__)
+#define PP_ARG_N( \
+          _1, _2, _3, _4, _5, _6, _7, _8, _9,_10, \
+         _11,_12,_13,_14,_15,_16,_17,_18,_19,_20, \
+         _21,_22,_23,_24,_25,_26,_27,_28,_29,_30, \
+         _31,_32,_33,_34,_35,_36,_37,_38,_39,_40, \
+         _41,_42,_43,_44,_45,_46,_47,_48,_49,_50, \
+         _51,_52,_53,_54,_55,_56,_57,_58,_59,_60, \
+         _61,_62,_63,N,...) N
+#define PP_RSEQ_N() \
+         63,62,61,60,                   \
+         59,58,57,56,55,54,53,52,51,50, \
+         49,48,47,46,45,44,43,42,41,40, \
+         39,38,37,36,35,34,33,32,31,30, \
+         29,28,27,26,25,24,23,22,21,20, \
+         19,18,17,16,15,14,13,12,11,10, \
+         9,8,7,6,5,4,3,2,1,0
+
+/* Vendor string = manufacturer */
+static const uint8_t usb_string_vendor[] = {
+  USB_DESC_BYTE(PP_NARG(USBSTR_MANUFACTURER)+2),                       // bLength
+  USB_DESC_BYTE(USB_DESCRIPTOR_STRING),    // bDescriptorType
+  USBSTR_MANUFACTURER
+};
+
+/* Device Description string = product */
+static const uint8_t usb_string_description[] = {
+  USB_DESC_BYTE(PP_NARG(USBSTR_PRODUCT)+2),           // bLength
+  USB_DESC_BYTE(USB_DESCRIPTOR_STRING),    // bDescriptorType
+  USBSTR_PRODUCT
+};
+
+/* Serial Number string (will be filled by the function init_usb_serial_string) */
+static uint8_t usb_string_serial[] = {
+  USB_DESC_BYTE(22),                       // bLength
+  USB_DESC_BYTE(USB_DESCRIPTOR_STRING),    // bDescriptorType
+  '0', 0, 'x', 0, 'D', 0, 'E', 0, 'A', 0, 'D', 0, 'B', 0, 'E', 0, 'E', 0, 'F', 0
+};
+
+/* Strings wrappers array */
+static const USBDescriptor usb_strings[] = {
+  { sizeof usb_string_langid, usb_string_langid }
+  ,
+  { sizeof usb_string_vendor, usb_string_vendor }
+  ,
+  { sizeof usb_string_description, usb_string_description }
+  ,
+  { sizeof usb_string_serial, usb_string_serial }
+};
+
+/*
+ * Handles the GET_DESCRIPTOR callback
+ *
+ * Returns the proper descriptor
+ */
+static const USBDescriptor *usb_get_descriptor_cb(USBDriver *usbp, uint8_t dtype, uint8_t dindex, uint16_t lang) {
+  (void)usbp;
+  (void)lang;
+  switch(dtype) {
+  /* Generic descriptors */
+  case USB_DESCRIPTOR_DEVICE:   /* Device Descriptor */
+    return &usb_device_descriptor;
+
+  case USB_DESCRIPTOR_CONFIGURATION:    /* Configuration Descriptor */
+    return &hid_configuration_descriptor;
+
+  case USB_DESCRIPTOR_STRING:   /* Strings */
+    if(dindex < 4)
+      return &usb_strings[dindex];
+    break;
+
+  /* HID specific descriptors */
+  case USB_DESCRIPTOR_HID:      /* HID Descriptors */
+    switch(lang) {    /* yea, poor label, it's actually wIndex from the setup packet */
+    case KBD_INTERFACE:
+      return &keyboard_hid_descriptor;
+
+#ifdef MOUSE_ENABLE
+    case MOUSE_INTERFACE:
+      return &mouse_hid_descriptor;
+#endif /* MOUSE_ENABLE */
+#ifdef CONSOLE_ENABLE
+    case CONSOLE_INTERFACE:
+      return &console_hid_descriptor;
+#endif /* CONSOLE_ENABLE */
+#ifdef EXTRAKEY_ENABLE
+    case EXTRA_INTERFACE:
+      return &extra_hid_descriptor;
+#endif /* EXTRAKEY_ENABLE */
+#ifdef NKRO_ENABLE
+    case NKRO_INTERFACE:
+      return &nkro_hid_descriptor;
+#endif /* NKRO_ENABLE */
+    }
+
+  case USB_DESCRIPTOR_HID_REPORT:       /* HID Report Descriptor */
+    switch(lang) {
+    case KBD_INTERFACE:
+      return &keyboard_hid_report_descriptor;
+
+#ifdef MOUSE_ENABLE
+    case MOUSE_INTERFACE:
+      return &mouse_hid_report_descriptor;
+#endif /* MOUSE_ENABLE */
+#ifdef CONSOLE_ENABLE
+    case CONSOLE_INTERFACE:
+      return &console_hid_report_descriptor;
+#endif /* CONSOLE_ENABLE */
+#ifdef EXTRAKEY_ENABLE
+    case EXTRA_INTERFACE:
+      return &extra_hid_report_descriptor;
+#endif /* EXTRAKEY_ENABLE */
+#ifdef NKRO_ENABLE
+    case NKRO_INTERFACE:
+      return &nkro_hid_report_descriptor;
+#endif /* NKRO_ENABLE */
+    }
+  }
+  return NULL;
+}
+
+/* keyboard endpoint state structure */
+static USBInEndpointState kbd_ep_state;
+/* keyboard endpoint initialization structure (IN) */
+static const USBEndpointConfig kbd_ep_config = {
+  USB_EP_MODE_TYPE_INTR,        /* Interrupt EP */
+  NULL,                         /* SETUP packet notification callback */
+  kbd_in_cb,                    /* IN notification callback */
+  NULL,                         /* OUT notification callback */
+  KBD_EPSIZE,                   /* IN maximum packet size */
+  0,                            /* OUT maximum packet size */
+  &kbd_ep_state,                /* IN Endpoint state */
+  NULL,                         /* OUT endpoint state */
+  2,                            /* IN multiplier */
+  NULL                          /* SETUP buffer (not a SETUP endpoint) */
+};
+
+#ifdef MOUSE_ENABLE
+/* mouse endpoint state structure */
+static USBInEndpointState mouse_ep_state;
+
+/* mouse endpoint initialization structure (IN) */
+static const USBEndpointConfig mouse_ep_config = {
+  USB_EP_MODE_TYPE_INTR,        /* Interrupt EP */
+  NULL,                         /* SETUP packet notification callback */
+  mouse_in_cb,                  /* IN notification callback */
+  NULL,                         /* OUT notification callback */
+  MOUSE_EPSIZE,                 /* IN maximum packet size */
+  0,                            /* OUT maximum packet size */
+  &mouse_ep_state,              /* IN Endpoint state */
+  NULL,                         /* OUT endpoint state */
+  2,                            /* IN multiplier */
+  NULL                          /* SETUP buffer (not a SETUP endpoint) */
+};
+#endif /* MOUSE_ENABLE */
+
+#ifdef CONSOLE_ENABLE
+/* console endpoint state structure */
+static USBInEndpointState console_ep_state;
+
+/* console endpoint initialization structure (IN) */
+static const USBEndpointConfig console_ep_config = {
+  USB_EP_MODE_TYPE_INTR,        /* Interrupt EP */
+  NULL,                         /* SETUP packet notification callback */
+  console_in_cb,                /* IN notification callback */
+  NULL,                         /* OUT notification callback */
+  CONSOLE_EPSIZE,               /* IN maximum packet size */
+  0,                            /* OUT maximum packet size */
+  &console_ep_state,            /* IN Endpoint state */
+  NULL,                         /* OUT endpoint state */
+  2,                            /* IN multiplier */
+  NULL                          /* SETUP buffer (not a SETUP endpoint) */
+};
+#endif /* CONSOLE_ENABLE */
+
+#ifdef EXTRAKEY_ENABLE
+/* extrakey endpoint state structure */
+static USBInEndpointState extra_ep_state;
+
+/* extrakey endpoint initialization structure (IN) */
+static const USBEndpointConfig extra_ep_config = {
+  USB_EP_MODE_TYPE_INTR,        /* Interrupt EP */
+  NULL,                         /* SETUP packet notification callback */
+  extra_in_cb,                  /* IN notification callback */
+  NULL,                         /* OUT notification callback */
+  EXTRA_EPSIZE,                 /* IN maximum packet size */
+  0,                            /* OUT maximum packet size */
+  &extra_ep_state,              /* IN Endpoint state */
+  NULL,                         /* OUT endpoint state */
+  2,                            /* IN multiplier */
+  NULL                          /* SETUP buffer (not a SETUP endpoint) */
+};
+#endif /* EXTRAKEY_ENABLE */
+
+#ifdef NKRO_ENABLE
+/* nkro endpoint state structure */
+static USBInEndpointState nkro_ep_state;
+
+/* nkro endpoint initialization structure (IN) */
+static const USBEndpointConfig nkro_ep_config = {
+  USB_EP_MODE_TYPE_INTR,        /* Interrupt EP */
+  NULL,                         /* SETUP packet notification callback */
+  nkro_in_cb,                   /* IN notification callback */
+  NULL,                         /* OUT notification callback */
+  NKRO_EPSIZE,                  /* IN maximum packet size */
+  0,                            /* OUT maximum packet size */
+  &nkro_ep_state,               /* IN Endpoint state */
+  NULL,                         /* OUT endpoint state */
+  2,                            /* IN multiplier */
+  NULL                          /* SETUP buffer (not a SETUP endpoint) */
+};
+#endif /* NKRO_ENABLE */
+
+/* ---------------------------------------------------------
+ *                  USB driver functions
+ * ---------------------------------------------------------
+ */
+
+/* Handles the USB driver global events
+ * TODO: maybe disable some things when connection is lost? */
+static void usb_event_cb(USBDriver *usbp, usbevent_t event) {
+  switch(event) {
+  case USB_EVENT_RESET:
+    //TODO: from ISR! print("[R]");
+    return;
+
+  case USB_EVENT_ADDRESS:
+    return;
+
+  case USB_EVENT_CONFIGURED:
+    osalSysLockFromISR();
+    /* Enable the endpoints specified into the configuration. */
+    usbInitEndpointI(usbp, KBD_ENDPOINT, &kbd_ep_config);
+#ifdef MOUSE_ENABLE
+    usbInitEndpointI(usbp, MOUSE_ENDPOINT, &mouse_ep_config);
+#endif /* MOUSE_ENABLE */
+#ifdef CONSOLE_ENABLE
+    usbInitEndpointI(usbp, CONSOLE_ENDPOINT, &console_ep_config);
+    /* don't need to start the flush timer, it starts from console_in_cb automatically */
+#endif /* CONSOLE_ENABLE */
+#ifdef EXTRAKEY_ENABLE
+    usbInitEndpointI(usbp, EXTRA_ENDPOINT, &extra_ep_config);
+#endif /* EXTRAKEY_ENABLE */
+#ifdef NKRO_ENABLE
+    usbInitEndpointI(usbp, NKRO_ENDPOINT, &nkro_ep_config);
+#endif /* NKRO_ENABLE */
+    osalSysUnlockFromISR();
+    return;
+
+  case USB_EVENT_SUSPEND:
+    //TODO: from ISR! print("[S]");
+#ifdef SLEEP_LED_ENABLE
+    sleep_led_enable();
+#endif /* SLEEP_LED_ENABLE */
+    return;
+
+  case USB_EVENT_WAKEUP:
+    //TODO: from ISR! print("[W]");
+    suspend_wakeup_init();
+#ifdef SLEEP_LED_ENABLE
+    sleep_led_disable();
+    // NOTE: converters may not accept this
+    led_set(host_keyboard_leds());
+#endif /* SLEEP_LED_ENABLE */
+    return;
+
+  case USB_EVENT_STALLED:
+    return;
+  }
+}
+
+/* Function used locally in os/hal/src/usb.c for getting descriptors
+ * need it here for HID descriptor */
+static uint16_t get_hword(uint8_t *p) {
+  uint16_t hw;
+
+  hw = (uint16_t)*p++;
+  hw |= (uint16_t)*p << 8U;
+  return hw;
+}
+
+/*
+ * Appendix G: HID Request Support Requirements
+ *
+ * The following table enumerates the requests that need to be supported by various types of HID class devices.
+ * Device type     GetReport   SetReport   GetIdle     SetIdle     GetProtocol SetProtocol
+ * ------------------------------------------------------------------------------------------
+ * Boot Mouse      Required    Optional    Optional    Optional    Required    Required
+ * Non-Boot Mouse  Required    Optional    Optional    Optional    Optional    Optional
+ * Boot Keyboard   Required    Optional    Required    Required    Required    Required
+ * Non-Boot Keybrd Required    Optional    Required    Required    Optional    Optional
+ * Other Device    Required    Optional    Optional    Optional    Optional    Optional
+ */
+
+/* Callback for SETUP request on the endpoint 0 (control) */
+static bool usb_request_hook_cb(USBDriver *usbp) {
+  const USBDescriptor *dp;
+
+  /* usbp->setup fields:
+   *  0:   bmRequestType (bitmask)
+   *  1:   bRequest
+   *  2,3: (LSB,MSB) wValue
+   *  4,5: (LSB,MSB) wIndex
+   *  6,7: (LSB,MSB) wLength (number of bytes to transfer if there is a data phase) */
+
+  /* Handle HID class specific requests */
+  if(((usbp->setup[0] & USB_RTYPE_TYPE_MASK) == USB_RTYPE_TYPE_CLASS) &&
+     ((usbp->setup[0] & USB_RTYPE_RECIPIENT_MASK) == USB_RTYPE_RECIPIENT_INTERFACE)) {
+    switch(usbp->setup[0] & USB_RTYPE_DIR_MASK) {
+    case USB_RTYPE_DIR_DEV2HOST:
+      switch(usbp->setup[1]) {   /* bRequest */
+      case HID_GET_REPORT:
+        switch(usbp->setup[4]) {     /* LSB(wIndex) (check MSB==0?) */
+        case KBD_INTERFACE:
+#ifdef NKRO_ENABLE
+        case NKRO_INTERFACE:
+#endif /* NKRO_ENABLE */
+          usbSetupTransfer(usbp, (uint8_t *)&keyboard_report_sent, sizeof(keyboard_report_sent), NULL);
+          return TRUE;
+          break;
+
+#ifdef MOUSE_ENABLE
+        case MOUSE_INTERFACE:
+          usbSetupTransfer(usbp, (uint8_t *)&mouse_report_blank, sizeof(mouse_report_blank), NULL);
+          return TRUE;
+          break;
+#endif /* MOUSE_ENABLE */
+
+#ifdef CONSOLE_ENABLE
+        case CONSOLE_INTERFACE:
+          usbSetupTransfer(usbp, console_queue_buffer, CONSOLE_EPSIZE, NULL);
+          return TRUE;
+          break;
+#endif /* CONSOLE_ENABLE */
+
+#ifdef EXTRAKEY_ENABLE
+        case EXTRA_INTERFACE:
+          if(usbp->setup[3] == 1) { /* MSB(wValue) [Report Type] == 1 [Input Report] */
+            switch(usbp->setup[2]) { /* LSB(wValue) [Report ID] */
+              case REPORT_ID_SYSTEM:
+                extra_report_blank[0] = REPORT_ID_SYSTEM;
+                usbSetupTransfer(usbp, (uint8_t *)extra_report_blank, sizeof(extra_report_blank), NULL);
+                return TRUE;
+                break;
+              case REPORT_ID_CONSUMER:
+                extra_report_blank[0] = REPORT_ID_CONSUMER;
+                usbSetupTransfer(usbp, (uint8_t *)extra_report_blank, sizeof(extra_report_blank), NULL);
+                return TRUE;
+                break;
+              default:
+                return FALSE;
+            }
+          } else {
+            return FALSE;
+          }
+          break;
+#endif /* EXTRAKEY_ENABLE */
+
+        default:
+          usbSetupTransfer(usbp, NULL, 0, NULL);
+          return TRUE;
+          break;
+        }
+        break;
+
+      case HID_GET_PROTOCOL:
+        if((usbp->setup[4] == KBD_INTERFACE) && (usbp->setup[5] == 0)) {   /* wIndex */
+          usbSetupTransfer(usbp, &keyboard_protocol, 1, NULL);
+          return TRUE;
+        }
+        break;
+
+      case HID_GET_IDLE:
+        usbSetupTransfer(usbp, &keyboard_idle, 1, NULL);
+        return TRUE;
+        break;
+      }
+      break;
+
+    case USB_RTYPE_DIR_HOST2DEV:
+      switch(usbp->setup[1]) {   /* bRequest */
+      case HID_SET_REPORT:
+        switch(usbp->setup[4]) {       /* LSB(wIndex) (check MSB==0 and wLength==1?) */
+        case KBD_INTERFACE:
+#ifdef NKRO_ENABLE
+        case NKRO_INTERFACE:
+#endif  /* NKRO_ENABLE */
+        /* keyboard_led_stats = <read byte from next OUT report>
+         * keyboard_led_stats needs be word (or dword), otherwise we get an exception on F0 */
+          usbSetupTransfer(usbp, (uint8_t *)&keyboard_led_stats, 1, NULL);
+          return TRUE;
+          break;
+        }
+        break;
+
+      case HID_SET_PROTOCOL:
+        if((usbp->setup[4] == KBD_INTERFACE) && (usbp->setup[5] == 0)) {   /* wIndex */
+          keyboard_protocol = ((usbp->setup[2]) != 0x00);   /* LSB(wValue) */
+#ifdef NKRO_ENABLE
+          keyboard_nkro = !!keyboard_protocol;
+          if(!keyboard_nkro && keyboard_idle) {
+#else /* NKRO_ENABLE */
+          if(keyboard_idle) {
+#endif /* NKRO_ENABLE */
+          /* arm the idle timer if boot protocol & idle */
+            osalSysLockFromISR();
+            chVTSetI(&keyboard_idle_timer, 4*MS2ST(keyboard_idle), keyboard_idle_timer_cb, (void *)usbp);
+            osalSysUnlockFromISR();
+          }
+        }
+        usbSetupTransfer(usbp, NULL, 0, NULL);
+        return TRUE;
+        break;
+
+      case HID_SET_IDLE:
+        keyboard_idle = usbp->setup[3];     /* MSB(wValue) */
+        /* arm the timer */
+#ifdef NKRO_ENABLE
+        if(!keyboard_nkro && keyboard_idle) {
+#else /* NKRO_ENABLE */
+        if(keyboard_idle) {
+#endif /* NKRO_ENABLE */
+          osalSysLockFromISR();
+          chVTSetI(&keyboard_idle_timer, 4*MS2ST(keyboard_idle), keyboard_idle_timer_cb, (void *)usbp);
+          osalSysUnlockFromISR();
+        }
+        usbSetupTransfer(usbp, NULL, 0, NULL);
+        return TRUE;
+        break;
+      }
+      break;
+    }
+  }
+
+  /* Handle the Get_Descriptor Request for HID class (not handled by the default hook) */
+  if((usbp->setup[0] == 0x81) && (usbp->setup[1] == USB_REQ_GET_DESCRIPTOR)) {
+    dp = usbp->config->get_descriptor_cb(usbp, usbp->setup[3], usbp->setup[2], get_hword(&usbp->setup[4]));
+    if(dp == NULL)
+      return FALSE;
+    usbSetupTransfer(usbp, (uint8_t *)dp->ud_string, dp->ud_size, NULL);
+    return TRUE;
+  }
+
+  return FALSE;
+}
+
+/* Start-of-frame callback */
+static void usb_sof_cb(USBDriver *usbp) {
+  kbd_sof_cb(usbp);
+}
+
+
+/* USB driver configuration */
+static const USBConfig usbcfg = {
+  usb_event_cb,                 /* USB events callback */
+  usb_get_descriptor_cb,        /* Device GET_DESCRIPTOR request callback */
+  usb_request_hook_cb,          /* Requests hook callback */
+  usb_sof_cb                    /* Start Of Frame callback */
+};
+
+/*
+ * Initialize the USB driver
+ */
+void init_usb_driver(USBDriver *usbp) {
+  /*
+   * Activates the USB driver and then the USB bus pull-up on D+.
+   * Note, a delay is inserted in order to not have to disconnect the cable
+   * after a reset.
+   */
+  usbDisconnectBus(usbp);
+  chThdSleepMilliseconds(1500);
+  usbStart(usbp, &usbcfg);
+  usbConnectBus(usbp);
+
+  chVTObjectInit(&keyboard_idle_timer);
+#ifdef CONSOLE_ENABLE
+  obqObjectInit(&console_buf_queue, console_queue_buffer, CONSOLE_EPSIZE, CONSOLE_QUEUE_CAPACITY, console_queue_onotify, (void*)usbp);
+  chVTObjectInit(&console_flush_timer);
+#endif
+}
+
+/*
+ * Send remote wakeup packet
+ * Note: should not be called from ISR
+ */
+void send_remote_wakeup(USBDriver *usbp) {
+  (void)usbp;
+#if defined(K20x) || defined(KL2x)
+#if KINETIS_USB_USE_USB0
+  USB0->CTL |= USBx_CTL_RESUME;
+  chThdSleepMilliseconds(15);
+  USB0->CTL &= ~USBx_CTL_RESUME;
+#endif /* KINETIS_USB_USE_USB0 */
+#elif defined(STM32F0XX) || defined(STM32F1XX) /* K20x || KL2x */
+  STM32_USB->CNTR |= CNTR_RESUME;
+  chThdSleepMilliseconds(15);
+  STM32_USB->CNTR &= ~CNTR_RESUME;
+#else /* STM32F0XX || STM32F1XX */
+#warning Sending remote wakeup packet not implemented for your platform.
+#endif /* K20x || KL2x */
+}
+
+/* ---------------------------------------------------------
+ *                  Keyboard functions
+ * ---------------------------------------------------------
+ */
+
+/* keyboard IN callback hander (a kbd report has made it IN) */
+void kbd_in_cb(USBDriver *usbp, usbep_t ep) {
+  /* STUB */
+  (void)usbp;
+  (void)ep;
+}
+
+#ifdef NKRO_ENABLE
+/* nkro IN callback hander (a nkro report has made it IN) */
+void nkro_in_cb(USBDriver *usbp, usbep_t ep) {
+  /* STUB */
+  (void)usbp;
+  (void)ep;
+}
+#endif /* NKRO_ENABLE */
+
+/* start-of-frame handler
+ * TODO: i guess it would be better to re-implement using timers,
+ *  so that this is not going to have to be checked every 1ms */
+void kbd_sof_cb(USBDriver *usbp) {
+  (void)usbp;
+}
+
+/* Idle requests timer code
+ * callback (called from ISR, unlocked state) */
+static void keyboard_idle_timer_cb(void *arg) {
+  USBDriver *usbp = (USBDriver *)arg;
+
+  osalSysLockFromISR();
+
+  /* check that the states of things are as they're supposed to */
+  if(usbGetDriverStateI(usbp) != USB_ACTIVE) {
+    /* do not rearm the timer, should be enabled on IDLE request */
+    osalSysUnlockFromISR();
+    return;
+  }
+
+#ifdef NKRO_ENABLE
+  if(!keyboard_nkro && keyboard_idle) {
+#else /* NKRO_ENABLE */
+  if(keyboard_idle) {
+#endif /* NKRO_ENABLE */
+    /* TODO: are we sure we want the KBD_ENDPOINT? */
+    if(!usbGetTransmitStatusI(usbp, KBD_ENDPOINT)) {
+      usbStartTransmitI(usbp, KBD_ENDPOINT, (uint8_t *)&keyboard_report_sent, KBD_EPSIZE);
+    }
+    /* rearm the timer */
+    chVTSetI(&keyboard_idle_timer, 4*MS2ST(keyboard_idle), keyboard_idle_timer_cb, (void *)usbp);
+  }
+
+  /* do not rearm the timer if the condition above fails
+   * it should be enabled again on either IDLE or SET_PROTOCOL requests */
+  osalSysUnlockFromISR();
+}
+
+/* LED status */
+uint8_t keyboard_leds(void) {
+  return (uint8_t)(keyboard_led_stats & 0xFF);
+}
+
+/* prepare and start sending a report IN
+ * not callable from ISR or locked state */
+void send_keyboard(report_keyboard_t *report) {
+  osalSysLock();
+  if(usbGetDriverStateI(&USB_DRIVER) != USB_ACTIVE) {
+    osalSysUnlock();
+    return;
+  }
+  osalSysUnlock();
+
+#ifdef NKRO_ENABLE
+  if(keyboard_nkro) {  /* NKRO protocol */
+    /* need to wait until the previous packet has made it through */
+    /* can rewrite this using the synchronous API, then would wait
+     * until *after* the packet has been transmitted. I think
+     * this is more efficient */
+    /* busy wait, should be short and not very common */
+    osalSysLock();
+    if(usbGetTransmitStatusI(&USB_DRIVER, NKRO_ENDPOINT)) {
+      /* Need to either suspend, or loop and call unlock/lock during
+       * every iteration - otherwise the system will remain locked,
+       * no interrupts served, so USB not going through as well.
+       * Note: for suspend, need USB_USE_WAIT == TRUE in halconf.h */
+      osalThreadSuspendS(&(&USB_DRIVER)->epc[NKRO_ENDPOINT]->in_state->thread);
+    }
+    usbStartTransmitI(&USB_DRIVER, NKRO_ENDPOINT, (uint8_t *)report, sizeof(report_keyboard_t));
+    osalSysUnlock();
+  } else
+#endif /* NKRO_ENABLE */
+  { /* boot protocol */
+    /* need to wait until the previous packet has made it through */
+    /* busy wait, should be short and not very common */
+    osalSysLock();
+    if(usbGetTransmitStatusI(&USB_DRIVER, KBD_ENDPOINT)) {
+      /* Need to either suspend, or loop and call unlock/lock during
+       * every iteration - otherwise the system will remain locked,
+       * no interrupts served, so USB not going through as well.
+       * Note: for suspend, need USB_USE_WAIT == TRUE in halconf.h */
+      osalThreadSuspendS(&(&USB_DRIVER)->epc[KBD_ENDPOINT]->in_state->thread);
+    }
+    usbStartTransmitI(&USB_DRIVER, KBD_ENDPOINT, (uint8_t *)report, KBD_EPSIZE);
+    osalSysUnlock();
+  }
+  keyboard_report_sent = *report;
+}
+
+/* ---------------------------------------------------------
+ *                     Mouse functions
+ * ---------------------------------------------------------
+ */
+
+#ifdef MOUSE_ENABLE
+
+/* mouse IN callback hander (a mouse report has made it IN) */
+void mouse_in_cb(USBDriver *usbp, usbep_t ep) {
+  (void)usbp;
+  (void)ep;
+}
+
+void send_mouse(report_mouse_t *report) {
+  osalSysLock();
+  if(usbGetDriverStateI(&USB_DRIVER) != USB_ACTIVE) {
+    osalSysUnlock();
+    return;
+  }
+  osalSysUnlock();
+
+  /* TODO: LUFA manually waits for the endpoint to become ready
+   * for about 10ms for mouse, kbd, system; 1ms for nkro
+   * is this really needed?
+   */
+
+  osalSysLock();
+  usbStartTransmitI(&USB_DRIVER, MOUSE_ENDPOINT, (uint8_t *)report, sizeof(report_mouse_t));
+  osalSysUnlock();
+}
+
+#else /* MOUSE_ENABLE */
+void send_mouse(report_mouse_t *report) {
+  (void)report;
+}
+#endif /* MOUSE_ENABLE */
+
+/* ---------------------------------------------------------
+ *                   Extrakey functions
+ * ---------------------------------------------------------
+ */
+
+#ifdef EXTRAKEY_ENABLE
+
+/* extrakey IN callback hander */
+void extra_in_cb(USBDriver *usbp, usbep_t ep) {
+  /* STUB */
+  (void)usbp;
+  (void)ep;
+}
+
+static void send_extra_report(uint8_t report_id, uint16_t data) {
+  osalSysLock();
+  if(usbGetDriverStateI(&USB_DRIVER) != USB_ACTIVE) {
+    osalSysUnlock();
+    return;
+  }
+
+  report_extra_t report = {
+    .report_id = report_id,
+    .usage = data
+  };
+
+  usbStartTransmitI(&USB_DRIVER, EXTRA_ENDPOINT, (uint8_t *)&report, sizeof(report_extra_t));
+  osalSysUnlock();
+}
+
+void send_system(uint16_t data) {
+  send_extra_report(REPORT_ID_SYSTEM, data);
+}
+
+void send_consumer(uint16_t data) {
+  send_extra_report(REPORT_ID_CONSUMER, data);
+}
+
+#else /* EXTRAKEY_ENABLE */
+void send_system(uint16_t data) {
+  (void)data;
+}
+void send_consumer(uint16_t data) {
+  (void)data;
+}
+#endif /* EXTRAKEY_ENABLE */
+
+/* ---------------------------------------------------------
+ *                   Console functions
+ * ---------------------------------------------------------
+ */
+
+#ifdef CONSOLE_ENABLE
+
+/* console IN callback hander */
+void console_in_cb(USBDriver *usbp, usbep_t ep) {
+  (void)ep; /* should have ep == CONSOLE_ENDPOINT, so use that to save time/space */
+  uint8_t *buf;
+  size_t n;
+
+  osalSysLockFromISR();
+
+  /* rearm the timer */
+  chVTSetI(&console_flush_timer, MS2ST(CONSOLE_FLUSH_MS), console_flush_cb, (void *)usbp);
+
+  /* Freeing the buffer just transmitted, if it was not a zero size packet.*/
+  if (usbp->epc[CONSOLE_ENDPOINT]->in_state->txsize > 0U) {
+    obqReleaseEmptyBufferI(&console_buf_queue);
+  }
+
+  /* Checking if there is a buffer ready for transmission.*/
+  buf = obqGetFullBufferI(&console_buf_queue, &n);
+
+  if (buf != NULL) {
+    /* The endpoint cannot be busy, we are in the context of the callback,
+       so it is safe to transmit without a check.*/
+    /* Should have n == CONSOLE_EPSIZE; check it? */
+    usbStartTransmitI(usbp, CONSOLE_ENDPOINT, buf, CONSOLE_EPSIZE);
+  } else {
+    /* Nothing to transmit.*/
+  }
+
+  osalSysUnlockFromISR();
+}
+
+/* Callback when data is inserted into the output queue
+ * Called from a locked state */
+void console_queue_onotify(io_buffers_queue_t *bqp) {
+  size_t n;
+  USBDriver *usbp = bqGetLinkX(bqp);
+
+  if(usbGetDriverStateI(usbp) != USB_ACTIVE)
+    return;
+
+  /* Checking if there is already a transaction ongoing on the endpoint.*/
+  if (!usbGetTransmitStatusI(usbp, CONSOLE_ENDPOINT)) {
+    /* Trying to get a full buffer.*/
+    uint8_t *buf = obqGetFullBufferI(&console_buf_queue, &n);
+    if (buf != NULL) {
+      /* Buffer found, starting a new transaction.*/
+      /* Should have n == CONSOLE_EPSIZE; check this? */
+      usbStartTransmitI(usbp, CONSOLE_ENDPOINT, buf, CONSOLE_EPSIZE);
+    }
+  }
+}
+
+/* Flush timer code
+ * callback (called from ISR, unlocked state) */
+static void console_flush_cb(void *arg) {
+  USBDriver *usbp = (USBDriver *)arg;
+  osalSysLockFromISR();
+
+  /* check that the states of things are as they're supposed to */
+  if(usbGetDriverStateI(usbp) != USB_ACTIVE) {
+    /* rearm the timer */
+    chVTSetI(&console_flush_timer, MS2ST(CONSOLE_FLUSH_MS), console_flush_cb, (void *)usbp);
+    osalSysUnlockFromISR();
+    return;
+  }
+
+  /* If there is already a transaction ongoing then another one cannot be
+     started.*/
+  if (usbGetTransmitStatusI(usbp, CONSOLE_ENDPOINT)) {
+    /* rearm the timer */
+    chVTSetI(&console_flush_timer, MS2ST(CONSOLE_FLUSH_MS), console_flush_cb, (void *)usbp);
+    osalSysUnlockFromISR();
+    return;
+  }
+
+  /* Checking if there only a buffer partially filled, if so then it is
+     enforced in the queue and transmitted.*/
+  if(obqTryFlushI(&console_buf_queue)) {
+    size_t n,i;
+    uint8_t *buf = obqGetFullBufferI(&console_buf_queue, &n);
+
+    osalDbgAssert(buf != NULL, "queue is empty");
+
+    /* zero the rest of the buffer (buf should point to allocated space) */
+    for(i=n; i<CONSOLE_EPSIZE; i++)
+      buf[i]=0;
+    usbStartTransmitI(usbp, CONSOLE_ENDPOINT, buf, CONSOLE_EPSIZE);
+  }
+
+  /* rearm the timer */
+  chVTSetI(&console_flush_timer, MS2ST(CONSOLE_FLUSH_MS), console_flush_cb, (void *)usbp);
+  osalSysUnlockFromISR();
+}
+
+
+int8_t sendchar(uint8_t c) {
+  osalSysLock();
+  if(usbGetDriverStateI(&USB_DRIVER) != USB_ACTIVE) {
+    osalSysUnlock();
+    return 0;
+  }
+  osalSysUnlock();
+  /* Timeout after 100us if the queue is full.
+   * Increase this timeout if too much stuff is getting
+   * dropped (i.e. the buffer is getting full too fast
+   * for USB/HIDRAW to dequeue). Another possibility
+   * for fixing this kind of thing is to increase
+   * CONSOLE_QUEUE_CAPACITY. */
+  return(obqPutTimeout(&console_buf_queue, c, US2ST(100)));
+}
+
+#else /* CONSOLE_ENABLE */
+int8_t sendchar(uint8_t c) {
+  (void)c;
+  return 0;
+}
+#endif /* CONSOLE_ENABLE */
+
+void sendchar_pf(void *p, char c) {
+  (void)p;
+  sendchar((uint8_t)c);
+}
diff --git a/tmk_core/protocol/chibios/usb_main.h b/tmk_core/protocol/chibios/usb_main.h
new file mode 100644
index 0000000000..30d8fcaef7
--- /dev/null
+++ b/tmk_core/protocol/chibios/usb_main.h
@@ -0,0 +1,139 @@
+/*
+ * (c) 2015 flabberast <s3+flabbergast@sdfeu.org>
+ *
+ * Based on the following work:
+ *  - Guillaume Duc's raw hid example (MIT License)
+ *    https://github.com/guiduc/usb-hid-chibios-example
+ *  - PJRC Teensy examples (MIT License)
+ *    https://www.pjrc.com/teensy/usb_keyboard.html
+ *  - hasu's TMK keyboard code (GPL v2 and some code Modified BSD)
+ *    https://github.com/tmk/tmk_keyboard/
+ *  - ChibiOS demo code (Apache 2.0 License)
+ *    http://www.chibios.org
+ *
+ * Since some GPL'd code is used, this work is licensed under
+ * GPL v2 or later.
+ */
+
+
+#ifndef _USB_MAIN_H_
+#define _USB_MAIN_H_
+
+// TESTING
+// extern uint8_t blinkLed;
+
+#include "ch.h"
+#include "hal.h"
+
+/* -------------------------
+ * General USB driver header
+ * -------------------------
+ */
+
+/* The USB driver to use */
+#define USB_DRIVER USBD1
+
+/* Initialize the USB driver and bus */
+void init_usb_driver(USBDriver *usbp);
+
+/* Send remote wakeup packet */
+void send_remote_wakeup(USBDriver *usbp);
+
+/* ---------------
+ * Keyboard header
+ * ---------------
+ */
+
+/* main keyboard (6kro) */
+#define KBD_INTERFACE   0
+#define KBD_ENDPOINT    1
+#define KBD_EPSIZE      8
+#define KBD_REPORT_KEYS (KBD_EPSIZE - 2)
+
+/* secondary keyboard */
+#ifdef NKRO_ENABLE
+#define NKRO_INTERFACE    4
+#define NKRO_ENDPOINT     5
+#define NKRO_EPSIZE       16
+#define NKRO_REPORT_KEYS  (NKRO_EPSIZE - 1)
+#endif
+
+/* extern report_keyboard_t keyboard_report_sent; */
+
+/* keyboard IN request callback handler */
+void kbd_in_cb(USBDriver *usbp, usbep_t ep);
+
+/* start-of-frame handler */
+void kbd_sof_cb(USBDriver *usbp);
+
+#ifdef NKRO_ENABLE
+/* nkro IN callback hander */
+void nkro_in_cb(USBDriver *usbp, usbep_t ep);
+#endif /* NKRO_ENABLE */
+
+/* ------------
+ * Mouse header
+ * ------------
+ */
+
+#ifdef MOUSE_ENABLE
+
+#define MOUSE_INTERFACE         1
+#define MOUSE_ENDPOINT          2
+#define MOUSE_EPSIZE            8
+
+/* mouse IN request callback handler */
+void mouse_in_cb(USBDriver *usbp, usbep_t ep);
+#endif /* MOUSE_ENABLE */
+
+/* ---------------
+ * Extrakey header
+ * ---------------
+ */
+
+#ifdef EXTRAKEY_ENABLE
+
+#define EXTRA_INTERFACE         3
+#define EXTRA_ENDPOINT          4
+#define EXTRA_EPSIZE            8
+
+/* extrakey IN request callback handler */
+void extra_in_cb(USBDriver *usbp, usbep_t ep);
+
+/* extra report structure */
+typedef struct {
+  uint8_t report_id;
+  uint16_t usage;
+} __attribute__ ((packed)) report_extra_t;
+#endif /* EXTRAKEY_ENABLE */
+
+/* --------------
+ * Console header
+ * --------------
+ */
+
+#ifdef CONSOLE_ENABLE
+
+#define CONSOLE_INTERFACE      2
+#define CONSOLE_ENDPOINT       3
+#define CONSOLE_EPSIZE         16
+
+/* Number of IN reports that can be stored inside the output queue */
+#define CONSOLE_QUEUE_CAPACITY 4
+
+/* Console flush time */
+#define CONSOLE_FLUSH_MS 50
+
+/* Putchar over the USB console */
+int8_t sendchar(uint8_t c);
+
+/* Flush output (send everything immediately) */
+void console_flush_output(void);
+
+/* console IN request callback handler */
+void console_in_cb(USBDriver *usbp, usbep_t ep);
+#endif /* CONSOLE_ENABLE */
+
+void sendchar_pf(void *p, char c);
+
+#endif /* _USB_MAIN_H_ */
diff --git a/tmk_core/readme.md b/tmk_core/readme.md
index 6b6714a6a2..f460d0ed44 100644
--- a/tmk_core/readme.md
+++ b/tmk_core/readme.md
@@ -5,6 +5,16 @@ This is a keyboard firmware library with some useful features for Atmel AVR and
 Source code is available here: <https://github.com/tmk/tmk_keyboard/tree/core>
 
 
+Updates
+-------
+#### 2016/02/10
+flabbergast's Chibios protocol was merged from <https://github.com/flabbergast/tmk_keyboard/tree/chibios>. See [protocol/chibios/README.md](protocol/chibios/README.md). Chibios protocol supports Cortex-M such as STM32 and Kinetis.
+
+#### 2015/04/22
+separated with TMK Keyboard Firmware Collection
+
+
+
 Features
 --------
 These features can be used in your keyboard.
@@ -27,12 +37,6 @@ These features can be used in your keyboard.
 
 
 
-Updates
--------
-2015/04/22  separated with TMK Keyboard Firmware Collection
-
-
-
 TMK Keyboard Firmware Collection
 --------------------------------
 Complete firmwares for various keyboards and protocol converters.
diff --git a/tmk_core/rules.mk b/tmk_core/rules.mk
index f8f77e892e..7d3d8f9a6b 100644
--- a/tmk_core/rules.mk
+++ b/tmk_core/rules.mk
@@ -16,30 +16,14 @@
 #
 
 
-
 # Output format. (can be srec, ihex, binary)
 FORMAT = ihex
 
-BUILD_DIR = .build
-
-# Object files directory
-#     To put object files in current directory, use a dot (.), do NOT make
-#     this an empty or blank macro!
-OBJDIR = $(BUILD_DIR)/obj_$(TARGET)
-
-
 # Optimization level, can be [0, 1, 2, 3, s].
 #     0 = turn off optimization. s = optimize for size.
 #     (Note: 3 is not always the best optimization level. See avr-libc FAQ.)
 OPT = s
 
-
-# Debugging format.
-#     Native formats for AVR-GCC's -g are dwarf-2 [default] or stabs.
-#     AVR Studio 4.10 requires dwarf-2.
-#     AVR [Extended] COFF format requires stabs, plus an avr-objcopy run.
-DEBUG = dwarf-2
-
 COLOR ?= true
 
 ifeq ($(COLOR),true)
@@ -87,7 +71,7 @@ BUILD_CMD = LOG=$$($(CMD) 2>&1) ; if [ $$? -gt 0 ]; then $(PRINT_ERROR); elif [
 #     Each directory must be seperated by a space.
 #     Use forward slashes for directory separators.
 #     For a directory that has spaces, enclose it in quotes.
-EXTRAINCDIRS = $(subst :, ,$(VPATH))
+EXTRAINCDIRS += $(subst :, ,$(VPATH))
 
 
 # Compiler flag to set the C Standard level.
@@ -99,17 +83,14 @@ CSTANDARD = -std=gnu99
 
 
 # Place -D or -U options here for C sources
-CDEFS = -DF_CPU=$(F_CPU)UL
 CDEFS += $(OPT_DEFS)
 
 
 # Place -D or -U options here for ASM sources
-ADEFS = -DF_CPU=$(F_CPU)
 ADEFS += $(OPT_DEFS)
 
 
 # Place -D or -U options here for C++ sources
-CPPDEFS = -DF_CPU=$(F_CPU)UL
 #CPPDEFS += -D__STDC_LIMIT_MACROS
 #CPPDEFS += -D__STDC_CONSTANT_MACROS
 CPPDEFS += $(OPT_DEFS)
@@ -123,17 +104,9 @@ CPPDEFS += $(OPT_DEFS)
 #  -Wall...:     warning level
 #  -Wa,...:      tell GCC to pass this to the assembler.
 #    -adhlns...: create assembler listing
-CFLAGS = -g$(DEBUG)
+CFLAGS += -g$(DEBUG)
 CFLAGS += $(CDEFS)
 CFLAGS += -O$(OPT)
-CFLAGS += -funsigned-char
-CFLAGS += -funsigned-bitfields
-CFLAGS += -ffunction-sections
-CFLAGS += -fdata-sections
-CFLAGS += -fno-inline-small-functions
-CFLAGS += -fpack-struct
-CFLAGS += -fshort-enums
-CFLAGS += -fno-strict-aliasing
 # add color
 ifeq ($(COLOR),true)
 ifeq ("$(shell echo "int main(){}" | $(CC) -fdiagnostics-color -x c - -o /dev/null 2>&1)", "")
@@ -162,16 +135,9 @@ endif
 #  -Wall...:     warning level
 #  -Wa,...:      tell GCC to pass this to the assembler.
 #    -adhlns...: create assembler listing
-CPPFLAGS = -g$(DEBUG)
+CPPFLAGS += -g$(DEBUG)
 CPPFLAGS += $(CPPDEFS)
 CPPFLAGS += -O$(OPT)
-CPPFLAGS += -funsigned-char
-CPPFLAGS += -funsigned-bitfields
-CPPFLAGS += -fpack-struct
-CPPFLAGS += -fshort-enums
-CPPFLAGS += -fno-exceptions
-CPPFLAGS += -ffunction-sections
-CPPFLAGS += -fdata-sections
 # to supress "warning: only initialized variables can be placed into program memory area"
 CPPFLAGS += -w
 CPPFLAGS += -Wall
@@ -198,7 +164,7 @@ endif
 #             files -- see avr-libc docs [FIXME: not yet described there]
 #  -listing-cont-lines: Sets the maximum number of continuation lines of hex
 #       dump that will be displayed for a given single line of source input.
-ASFLAGS = $(ADEFS) -Wa,-adhlns=$(@:%.o=%.lst),-gstabs,--listing-cont-lines=100
+ASFLAGS += $(ADEFS) -Wa,-adhlns=$(@:%.o=%.lst),-gstabs,--listing-cont-lines=100
 ASFLAGS += $(patsubst %,-I%,$(EXTRAINCDIRS))
 ifdef CONFIG_H
     ASFLAGS += -include $(CONFIG_H)
@@ -232,28 +198,6 @@ SCANF_LIB =
 MATH_LIB = -lm
 
 
-# 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 =
-
-
-
-#---------------- External Memory Options ----------------
-
-# 64 KB of external RAM, starting after internal RAM (ATmega128!),
-# used for variables (.data/.bss) and heap (malloc()).
-#EXTMEMOPTS = -Wl,-Tdata=0x801100,--defsym=__heap_end=0x80ffff
-
-# 64 KB of external RAM, starting after internal RAM (ATmega128!),
-# only used for heap (malloc()).
-#EXTMEMOPTS = -Wl,--section-start,.data=0x801100,--defsym=__heap_end=0x80ffff
-
-EXTMEMOPTS =
-
-
-
 #---------------- Linker Options ----------------
 #  -Wl,...:     tell GCC to pass this to linker.
 #    -Map:      create map file
@@ -262,9 +206,8 @@ EXTMEMOPTS =
 # Comennt out "--relax" option to avoid a error such:
 # 	(.vectors+0x30): relocation truncated to fit: R_AVR_13_PCREL against symbol `__vector_12'
 #
-LDFLAGS = -Wl,-Map=$(BUILD_DIR)/$(TARGET).map,--cref
+LDFLAGS += -Wl,-Map=$(BUILD_DIR)/$(TARGET).map,--cref
 #LDFLAGS += -Wl,--relax
-LDFLAGS += -Wl,--gc-sections
 LDFLAGS += $(EXTMEMOPTS)
 LDFLAGS += $(patsubst %,-L%,$(EXTRALIBDIRS))
 LDFLAGS += $(PRINTF_LIB) $(SCANF_LIB) $(MATH_LIB)
@@ -272,59 +215,13 @@ LDFLAGS += $(PRINTF_LIB) $(SCANF_LIB) $(MATH_LIB)
 # You can give EXTRALDFLAGS at 'make' command line.
 LDFLAGS += $(EXTRALDFLAGS)
 
-
-
-#---------------- Debugging Options ----------------
-
-# For simulavr only - target MCU frequency.
-DEBUG_MFREQ = $(F_CPU)
-
-# Set the DEBUG_UI to either gdb or insight.
-# DEBUG_UI = gdb
-DEBUG_UI = insight
-
-# Set the debugging back-end to either avarice, simulavr.
-DEBUG_BACKEND = avarice
-#DEBUG_BACKEND = simulavr
-
-# GDB Init Filename.
-GDBINIT_FILE = __avr_gdbinit
-
-# When using avarice settings for the JTAG
-JTAG_DEV = /dev/com1
-
-# Debugging port used to communicate between GDB / avarice / simulavr.
-DEBUG_PORT = 4242
-
-# Debugging host used to communicate between GDB / avarice / simulavr, normally
-#     just set to localhost unless doing some sort of crazy debugging when
-#     avarice is running on a different computer.
-DEBUG_HOST = localhost
-
-
-
-#============================================================================
-
-
 # Define programs and commands.
 SHELL = sh
-CC = avr-gcc
-OBJCOPY = avr-objcopy
-OBJDUMP = avr-objdump
-SIZE = avr-size
-AR = avr-ar rcs
-NM = avr-nm
 REMOVE = rm -f
 REMOVEDIR = rmdir
 COPY = cp
 WINSHELL = cmd
 SECHO = $(SILENT) || echo
-# Autodecct teensy loader
-ifneq (, $(shell which teensy-loader-cli 2>/dev/null))
-  TEENSY_LOADER_CLI = teensy-loader-cli
-else
-  TEENSY_LOADER_CLI = teensy_loader_cli
-endif
 
 # Define Messages
 # English
@@ -345,8 +242,12 @@ MSG_COMPILING_CPP = Compiling:
 MSG_ASSEMBLING = Assembling:
 MSG_CLEANING = Cleaning project:
 MSG_CREATING_LIBRARY = Creating library:
-
-
+MSG_SUBMODULE_DIRTY = $(WARN_COLOR)WARNING:$(NO_COLOR)\n \
+	Some git sub-modules are out of date or modified, please consider runnning:$(BOLD)\n\
+	git submodule sync --recursive\n\
+	git submodule update --init --recursive$(NO_COLOR)\n\n\
+	You can ignore this warning if you are not compiling any ChibiOS keyboards,\n\
+	or if you have modified the ChibiOS libraries yourself. \n\n
 
 
 # Define all object files.
@@ -364,9 +265,9 @@ GENDEPFLAGS = -MMD -MP -MF $(BUILD_DIR)/.dep/$(subst /,_,$@).d
 # Combine all necessary flags and optional flags.
 # Add target processor to flags.
 # You can give extra flags at 'make' command line like: make EXTRAFLAGS=-DFOO=bar
-ALL_CFLAGS = -mmcu=$(MCU) $(CFLAGS) $(GENDEPFLAGS) $(EXTRAFLAGS)
-ALL_CPPFLAGS = -mmcu=$(MCU) -x c++ $(CPPFLAGS) $(GENDEPFLAGS) $(EXTRAFLAGS)
-ALL_ASFLAGS = -mmcu=$(MCU) -x assembler-with-cpp $(ASFLAGS) $(EXTRAFLAGS)
+ALL_CFLAGS = $(MCUFLAGS) $(CFLAGS) $(GENDEPFLAGS) $(EXTRAFLAGS)
+ALL_CPPFLAGS = $(MCUFLAGS) -x c++ $(CPPFLAGS) $(GENDEPFLAGS) $(EXTRAFLAGS)
+ALL_ASFLAGS = $(MCUFLAGS) -x assembler-with-cpp $(ASFLAGS) $(EXTRAFLAGS)
 
 # Default target.
 all:
@@ -408,6 +309,13 @@ lib: $(LIBNAME)
 # the following magic strings to be generated by the compile job.
 begin:
 	@$(SECHO) $(MSG_BEGIN)
+	git submodule status --recursive | \
+	while IFS= read -r x; do \
+		case "$$x" in \
+			\ *) ;; \
+			*) printf "$(MSG_SUBMODULE_DIRTY)";break;; \
+		esac \
+	done
 
 end:
 	@$(SECHO) $(MSG_END)
@@ -432,104 +340,10 @@ sizeafter:
 gccversion :
 	@$(SILENT) || $(CC) --version
 
-
-
-# Program the device.
-program: $(BUILD_DIR)/$(TARGET).hex $(BUILD_DIR)/$(TARGET).eep
-	$(PROGRAM_CMD)
-
-teensy: $(BUILD_DIR)/$(TARGET).hex
-	$(TEENSY_LOADER_CLI) -mmcu=$(MCU) -w -v $(BUILD_DIR)/$(TARGET).hex
-
-flip: $(BUILD_DIR)/$(TARGET).hex
-	batchisp -hardware usb -device $(MCU) -operation erase f
-	batchisp -hardware usb -device $(MCU) -operation loadbuffer $(BUILD_DIR)/$(TARGET).hex program
-	batchisp -hardware usb -device $(MCU) -operation start reset 0
-
-dfu: $(BUILD_DIR)/$(TARGET).hex sizeafter
-ifneq (, $(findstring 0.7, $(shell dfu-programmer --version 2>&1)))
-	dfu-programmer $(MCU) erase --force
-else
-	dfu-programmer $(MCU) erase
-endif
-	dfu-programmer $(MCU) flash $(BUILD_DIR)/$(TARGET).hex
-	dfu-programmer $(MCU) reset
-
-dfu-start:
-	dfu-programmer $(MCU) reset
-	dfu-programmer $(MCU) start
-
-flip-ee: $(BUILD_DIR)/$(TARGET).hex $(BUILD_DIR)/$(TARGET).eep
-	$(COPY) $(BUILD_DIR)/$(TARGET).eep $(BUILD_DIR)/$(TARGET)eep.hex
-	batchisp -hardware usb -device $(MCU) -operation memory EEPROM erase
-	batchisp -hardware usb -device $(MCU) -operation memory EEPROM loadbuffer $(BUILD_DIR)/$(TARGET)eep.hex program
-	batchisp -hardware usb -device $(MCU) -operation start reset 0
-	$(REMOVE) $(BUILD_DIR)/$(TARGET)eep.hex
-
-dfu-ee: $(BUILD_DIR)/$(TARGET).hex $(BUILD_DIR)/$(TARGET).eep
-ifneq (, $(findstring 0.7, $(shell dfu-programmer --version 2>&1)))
-	dfu-programmer $(MCU) flash --eeprom $(BUILD_DIR)/$(TARGET).eep
-else
-	dfu-programmer $(MCU) flash-eeprom $(BUILD_DIR)/$(TARGET).eep
-endif
-	dfu-programmer $(MCU) reset
-
-
-# Generate avr-gdb config/init file which does the following:
-#     define the reset signal, load the target file, connect to target, and set
-#     a breakpoint at main().
-gdb-config:
-	@$(REMOVE) $(GDBINIT_FILE)
-	@echo define reset >> $(GDBINIT_FILE)
-	@echo SIGNAL SIGHUP >> $(GDBINIT_FILE)
-	@echo end >> $(GDBINIT_FILE)
-	@echo file $(BUILD_DIR)/$(TARGET).elf >> $(GDBINIT_FILE)
-	@echo target remote $(DEBUG_HOST):$(DEBUG_PORT)  >> $(GDBINIT_FILE)
-ifeq ($(DEBUG_BACKEND),simulavr)
-	@echo load  >> $(GDBINIT_FILE)
-endif
-	@echo break main >> $(GDBINIT_FILE)
-
-debug: gdb-config $(BUILD_DIR)/$(TARGET).elf
-ifeq ($(DEBUG_BACKEND), avarice)
-	@echo Starting AVaRICE - Press enter when "waiting to connect" message displays.
-	@$(WINSHELL) /c start avarice --jtag $(JTAG_DEV) --erase --program --file \
-	$(BUILD_DIR)/$(TARGET).elf $(DEBUG_HOST):$(DEBUG_PORT)
-	@$(WINSHELL) /c pause
-
-else
-	@$(WINSHELL) /c start simulavr --gdbserver --device $(MCU) --clock-freq \
-	$(DEBUG_MFREQ) --port $(DEBUG_PORT)
-endif
-	@$(WINSHELL) /c start avr-$(DEBUG_UI) --command=$(GDBINIT_FILE)
-
-
-
-
-# Convert ELF to COFF for use in debugging / simulating in AVR Studio or VMLAB.
-COFFCONVERT = $(OBJCOPY) --debugging
-COFFCONVERT += --change-section-address .data-0x800000
-COFFCONVERT += --change-section-address .bss-0x800000
-COFFCONVERT += --change-section-address .noinit-0x800000
-COFFCONVERT += --change-section-address .eeprom-0x810000
-
-
-
-coff: $(BUILD_DIR)/$(TARGET).elf
-	@$(SECHO) $(MSG_COFF) $(BUILD_DIR)/$(TARGET).cof
-	$(COFFCONVERT) -O coff-avr $< $(BUILD_DIR)/$(TARGET).cof
-
-
-extcoff: $(BUILD_DIR)/$(TARGET).elf
-	@$(SECHO) $(MSG_EXTENDED_COFF) $(BUILD_DIR)/$(TARGET).cof
-	$(COFFCONVERT) -O coff-ext-avr $< $(BUILD_DIR)/$(TARGET).cof
-
-
-
 # Create final output files (.hex, .eep) from ELF output file.
 %.hex: %.elf
 	@$(SILENT) || printf "$(MSG_FLASH) $@" | $(AWK_CMD)
-	$(eval CMD=$(OBJCOPY) -O $(FORMAT) -R .eeprom -R .fuse -R .lock -R .signature $< $@)
+	$(eval CMD=$(HEX) $< $@)
 	@$(BUILD_CMD)
 	@if $(AUTOGEN); then \
 		$(SILENT) || printf "Copying $(TARGET).hex to keymaps/$(KEYMAP)/$(KEYBOARD)_$(KEYMAP).hex\n"; \
@@ -540,7 +354,7 @@ extcoff: $(BUILD_DIR)/$(TARGET).elf
 
 %.eep: %.elf
 	@$(SILENT) || printf "$(MSG_EEPROM) $@" | $(AWK_CMD)
-	$(eval CMD=$(OBJCOPY) -j .eeprom --set-section-flags=.eeprom="alloc,load" --change-section-lma .eeprom=0 --no-change-warnings -O $(FORMAT) $< $@ || exit 0)
+	$(eval CMD=$(EEP) $< $@ || exit 0)
 	@$(BUILD_CMD)
 
 # Create extended listing file from ELF output file.
@@ -622,7 +436,7 @@ show_path:
 	@echo VPATH=$(VPATH)
 	@echo SRC=$(SRC)
 
-SUBDIRS := $(filter-out %/util/ %/doc/ %/keymaps/ %/old_keymap_files/,$(dir $(wildcard $(TOP_DIR)/keyboards/**/*/.)))
+SUBDIRS := $(filter-out %/util/ %/doc/ %/keymaps/ %/old_keymap_files/,$(dir $(wildcard $(TOP_DIR)/keyboards/**/*/Makefile)))
 SUBDIRS := $(SUBDIRS) $(dir $(wildcard $(TOP_DIR)/keyboards/*/.))
 SUBDIRS := $(sort $(SUBDIRS))
 # $(error $(SUBDIRS))
diff --git a/tmk_core/tool/chibios/.gitignore b/tmk_core/tool/chibios/.gitignore
new file mode 100644
index 0000000000..88bbafe34f
--- /dev/null
+++ b/tmk_core/tool/chibios/.gitignore
@@ -0,0 +1,2 @@
+chibios
+chibios-contrib
diff --git a/tmk_core/tool/chibios/ch-bootloader-jump.patch b/tmk_core/tool/chibios/ch-bootloader-jump.patch
new file mode 100644
index 0000000000..d886576214
--- /dev/null
+++ b/tmk_core/tool/chibios/ch-bootloader-jump.patch
@@ -0,0 +1,116 @@
+diff --git a/os/common/ports/ARMCMx/compilers/GCC/crt0_v6m.s b/os/common/ports/ARMCMx/compilers/GCC/crt0_v6m.s
+index 51a79bb..42d07bd 100644
+--- a/os/common/ports/ARMCMx/compilers/GCC/crt0_v6m.s
++++ b/os/common/ports/ARMCMx/compilers/GCC/crt0_v6m.s
+@@ -105,6 +105,13 @@
+ #define CRT0_CALL_DESTRUCTORS               TRUE

+ #endif

+ 

++/**

++ * @brief   Magic number for jumping to bootloader.

++ */

++#if !defined(MAGIC_BOOTLOADER_NUMBER) || defined(__DOXYGEN__)

++#define MAGIC_BOOTLOADER_NUMBER 0xDEADBEEF

++#endif

++

+ /*===========================================================================*/

+ /* Code section.                                                             */

+ /*===========================================================================*/

+@@ -124,6 +131,17 @@
+                 .thumb_func

+                 .global Reset_Handler

+ Reset_Handler:

++

++#ifdef STM32_BOOTLOADER_ADDRESS

++                /* jump to bootloader code */

++                ldr        r0, =__ram0_end__-4

++                ldr        r1, =MAGIC_BOOTLOADER_NUMBER

++                ldr        r2, [r0, #0]

++                str        r0, [r0, #0] /* erase stored magic */

++                cmp        r2, r1

++                beq        Bootloader_Jump

++#endif /* STM32_BOOTLOADER_ADDRESS */

++

+                 /* Interrupts are globally masked initially.*/

+                 cpsid   i

+ 

+@@ -242,6 +260,21 @@ endfiniloop:
+                 ldr     r1, =__default_exit

+                 bx      r1

+ 

++#ifdef STM32_BOOTLOADER_ADDRESS

++/*

++ * Jump-to-bootloader function.

++ */

++

++                .align  2

++                .thumb_func

++Bootloader_Jump:

++                ldr     r0, =STM32_BOOTLOADER_ADDRESS

++                ldr     r1, [r0, #0]

++                mov     sp, r1

++                ldr     r0, [r0, #4]

++                bx      r0

++#endif /* STM32_BOOTLOADER_ADDRESS */

++

+ #endif

+ 

+ /** @} */

+diff --git a/os/common/ports/ARMCMx/compilers/GCC/crt0_v7m.s b/os/common/ports/ARMCMx/compilers/GCC/crt0_v7m.s
+index 4812a29..dca9f88 100644
+--- a/os/common/ports/ARMCMx/compilers/GCC/crt0_v7m.s
++++ b/os/common/ports/ARMCMx/compilers/GCC/crt0_v7m.s
+@@ -140,6 +140,13 @@
+ #define CRT0_CPACR_INIT                     0x00F00000

+ #endif

+ 

++/**

++ * @brief   Magic number for jumping to bootloader.

++ */

++#if !defined(MAGIC_BOOTLOADER_NUMBER) || defined(__DOXYGEN__)

++#define MAGIC_BOOTLOADER_NUMBER 0xDEADBEEF

++#endif

++

+ /*===========================================================================*/

+ /* Code section.                                                             */

+ /*===========================================================================*/

+@@ -164,6 +171,17 @@
+                 .thumb_func

+                 .global Reset_Handler

+ Reset_Handler:

++

++#ifdef STM32_BOOTLOADER_ADDRESS

++                /* jump to bootloader code */

++                ldr        r0, =__ram0_end__-4

++                ldr        r1, =MAGIC_BOOTLOADER_NUMBER

++                ldr        r2, [r0, #0]

++                str        r0, [r0, #0] /* erase stored magic */

++                cmp        r2, r1

++                beq        Bootloader_Jump

++#endif /* STM32_BOOTLOADER_ADDRESS */

++

+                 /* Interrupts are globally masked initially.*/

+                 cpsid   i

+ 

+@@ -305,6 +323,21 @@ endfiniloop:
+                 /* Branching to the defined exit handler.*/

+                 b       __default_exit

+ 

++#ifdef STM32_BOOTLOADER_ADDRESS

++/*

++ * Jump-to-bootloader function.

++ */

++

++                .align  2

++                .thumb_func

++Bootloader_Jump:

++                ldr     r0, =STM32_BOOTLOADER_ADDRESS

++                ldr     r1, [r0, #0]

++                mov     sp, r1

++                ldr     r0, [r0, #4]

++                bx      r0

++#endif /* STM32_BOOTLOADER_ADDRESS */

++

+ #endif /* !defined(__DOXYGEN__) */

+ 

+ /** @} */