Merge branch 'master' into to_push

36 files changed, 1948 insertions, 328 deletions

diff --git a/tmk_core/avr.mk b/tmk_core/avr.mk
index b48173341..5df539def 100644
--- a/tmk_core/avr.mk
+++ b/tmk_core/avr.mk
@@ -26,7 +26,7 @@ CFLAGS += -fno-inline-small-functions
 CFLAGS += -fno-strict-aliasing
 
 CPPFLAGS += $(COMPILEFLAGS)
-CPPFLAGS += -fno-exceptions
+CPPFLAGS += -fno-exceptions -std=c++11
 
 LDFLAGS +=-Wl,--gc-sections
 
diff --git a/tmk_core/common.mk b/tmk_core/common.mk
index f826a7b54..47f6fc571 100644
--- a/tmk_core/common.mk
+++ b/tmk_core/common.mk
@@ -50,6 +50,10 @@ ifeq ($(strip $(EXTRAKEY_ENABLE)), yes)
     TMK_COMMON_DEFS += -DEXTRAKEY_ENABLE
 endif
 
+ifeq ($(strip $(RAW_ENABLE)), yes)
+    TMK_COMMON_DEFS += -DRAW_ENABLE
+endif
+
 ifeq ($(strip $(CONSOLE_ENABLE)), yes)
     TMK_COMMON_DEFS += -DCONSOLE_ENABLE
 else
@@ -76,6 +80,14 @@ ifeq ($(strip $(SLEEP_LED_ENABLE)), yes)
     TMK_COMMON_DEFS += -DNO_SUSPEND_POWER_DOWN
 endif
 
+ifeq ($(strip $(NO_UART)), yes)
+    TMK_COMMON_DEFS += -DNO_UART
+endif
+
+ifeq ($(strip $(NO_SUSPEND_POWER_DOWN)), yes)
+    TMK_COMMON_DEFS += -DNO_SUSPEND_POWER_DOWN
+endif
+
 ifeq ($(strip $(BACKLIGHT_ENABLE)), yes)
     TMK_COMMON_SRC += $(COMMON_DIR)/backlight.c
     TMK_COMMON_DEFS += -DBACKLIGHT_ENABLE
@@ -85,6 +97,16 @@ ifeq ($(strip $(BLUETOOTH_ENABLE)), yes)
     TMK_COMMON_DEFS += -DBLUETOOTH_ENABLE
 endif
 
+ifeq ($(strip $(BLUETOOTH)), AdafruitBLE)
+                TMK_COMMON_DEFS += -DBLUETOOTH_ENABLE
+                TMK_COMMON_DEFS += -DMODULE_ADAFRUIT_BLE
+endif
+
+ifeq ($(strip $(BLUETOOTH)), AdafruitEZKey)
+                TMK_COMMON_DEFS += -DBLUETOOTH_ENABLE
+                TMK_COMMON_DEFS += -DMODULE_ADAFRUIT_EZKEY
+endif
+
 ifeq ($(strip $(ONEHAND_ENABLE)), yes)
     TMK_COMMON_DEFS += -DONEHAND_ENABLE
 endif
@@ -110,4 +132,4 @@ endif
 VPATH += $(TMK_PATH)/$(COMMON_DIR)
 ifeq ($(PLATFORM),CHIBIOS)
 VPATH += $(TMK_PATH)/$(COMMON_DIR)/chibios
-endif
\ No newline at end of file
+endif
diff --git a/tmk_core/common/action.c b/tmk_core/common/action.c
index d485b46c7..94de36918 100644
--- a/tmk_core/common/action.c
+++ b/tmk_core/common/action.c
@@ -33,6 +33,9 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include "nodebug.h"
 #endif
 
+#ifdef FAUXCLICKY_ENABLE
+#include <fauxclicky.h>
+#endif
 
 void action_exec(keyevent_t event)
 {
@@ -41,6 +44,16 @@ void action_exec(keyevent_t event)
         dprint("EVENT: "); debug_event(event); dprintln();
     }
 
+#ifdef FAUXCLICKY_ENABLE
+    if (IS_PRESSED(event)) {
+        FAUXCLICKY_ACTION_PRESS;
+    }
+    if (IS_RELEASED(event)) {
+        FAUXCLICKY_ACTION_RELEASE;
+    }
+    fauxclicky_check();
+#endif
+
 #ifdef ONEHAND_ENABLE
     if (!IS_NOEVENT(event)) {
         process_hand_swap(&event);
@@ -49,6 +62,13 @@ void action_exec(keyevent_t event)
 
     keyrecord_t record = { .event = event };
 
+#if (defined(ONESHOT_TIMEOUT) && (ONESHOT_TIMEOUT > 0))
+    if (has_oneshot_layer_timed_out()) {
+        dprintf("Oneshot layer: timeout\n");
+        clear_oneshot_layer_state(ONESHOT_OTHER_KEY_PRESSED);
+    }
+#endif
+
 #ifndef NO_ACTION_TAPPING
     action_tapping_process(record);
 #else
@@ -100,7 +120,7 @@ bool process_record_quantum(keyrecord_t *record) {
     return true;
 }
 
-void process_record(keyrecord_t *record) 
+void process_record(keyrecord_t *record)
 {
     if (IS_NOEVENT(record->event)) { return; }
 
@@ -126,13 +146,6 @@ void process_action(keyrecord_t *record, action_t action)
     uint8_t tap_count = record->tap.count;
 #endif
 
-#if (defined(ONESHOT_TIMEOUT) && (ONESHOT_TIMEOUT > 0))
-    if (has_oneshot_layer_timed_out()) {
-        dprintf("Oneshot layer: timeout\n");
-        clear_oneshot_layer_state(ONESHOT_OTHER_KEY_PRESSED);
-    }
-#endif
-
     if (event.pressed) {
         // clear the potential weak mods left by previously pressed keys
         clear_weak_mods();
diff --git a/tmk_core/common/action_code.h b/tmk_core/common/action_code.h
index 33da35f35..b15aaa0eb 100644
--- a/tmk_core/common/action_code.h
+++ b/tmk_core/common/action_code.h
@@ -47,10 +47,15 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
  * 0100|10| usage(10)     (reserved)
  * 0100|11| usage(10)     (reserved)
  *
- * ACT_MOUSEKEY(0110): TODO: Not needed?
+ *
+ * ACT_MOUSEKEY(0101): TODO: Merge these two actions to conserve space?
  * 0101|xxxx| keycode     Mouse key
  *
- * 011x|xxxx xxxx xxxx    (reseved)
+ * ACT_SWAP_HANDS(0110):
+ * 0110|xxxx| keycode     Swap hands (keycode on tap, or options)
+ *
+ *
+ * 0111|xxxx xxxx xxxx    (reserved)
  *
  *
  * Layer Actions(10xx)
@@ -67,7 +72,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *   ee:    on event(01:press, 10:release, 11:both)
  *
  * 1001|xxxx|xxxx xxxx   (reserved)
- * 1001|oopp|BBBB BBBB   8-bit Bitwise Operation???
  *
  * ACT_LAYER_TAP(101x):
  * 101E|LLLL| keycode    On/Off with tap key    (0x00-DF)[TAP]
diff --git a/tmk_core/common/action_layer.c b/tmk_core/common/action_layer.c
index a3c757964..58d919a04 100644
--- a/tmk_core/common/action_layer.c
+++ b/tmk_core/common/action_layer.c
@@ -16,8 +16,14 @@
  */
 uint32_t default_layer_state = 0;
 
+__attribute__((weak))
+uint32_t default_layer_state_set_kb(uint32_t state) {
+    return state;
+}
+
 static void default_layer_state_set(uint32_t state)
 {
+    state = default_layer_state_set_kb(state);
     debug("default_layer_state: ");
     default_layer_debug(); debug(" to ");
     default_layer_state = state;
@@ -57,8 +63,14 @@ void default_layer_xor(uint32_t state)
  */
 uint32_t layer_state = 0;
 
+__attribute__((weak))
+uint32_t layer_state_set_kb(uint32_t state) {
+    return state;
+}
+
 static void layer_state_set(uint32_t state)
 {
+    state = layer_state_set_kb(state);
     dprint("layer_state: ");
     layer_debug(); dprint(" to ");
     layer_state = state;
diff --git a/tmk_core/common/action_layer.h b/tmk_core/common/action_layer.h
index 025cf5420..d89ed6e5c 100644
--- a/tmk_core/common/action_layer.h
+++ b/tmk_core/common/action_layer.h
@@ -29,6 +29,9 @@ extern uint32_t default_layer_state;
 void default_layer_debug(void);
 void default_layer_set(uint32_t state);
 
+__attribute__((weak))
+uint32_t default_layer_state_set_kb(uint32_t state);
+
 #ifndef NO_ACTION_LAYER
 /* bitwise operation */
 void default_layer_or(uint32_t state);
@@ -69,6 +72,8 @@ void layer_xor(uint32_t state);
 #define layer_xor(state)
 #define layer_debug()
 
+__attribute__((weak))
+uint32_t layer_state_set_kb(uint32_t state);
 #endif
 
 /* pressed actions cache */
diff --git a/tmk_core/common/action_macro.h b/tmk_core/common/action_macro.h
index aedc32ec6..f373f5068 100644
--- a/tmk_core/common/action_macro.h
+++ b/tmk_core/common/action_macro.h
@@ -20,11 +20,33 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include "progmem.h"
 
 
-#define MACRO_NONE      0
+
+typedef uint8_t macro_t;
+
+#define MACRO_NONE      (macro_t*)0
 #define MACRO(...)      ({ static const macro_t __m[] PROGMEM = { __VA_ARGS__ }; &__m[0]; })
 #define MACRO_GET(p)    pgm_read_byte(p)
 
-typedef uint8_t macro_t;
+// Sends press when the macro key is pressed, release when release, or tap_macro when the key has been tapped
+#define MACRO_TAP_HOLD(record, press, release, tap_macro) ( ((record)->event.pressed) ? \
+     ( ((record)->tap.count <= 0 || (record)->tap.interrupted) ? (press) : MACRO_NONE ) : \
+     ( ((record)->tap.count > 0 && !((record)->tap.interrupted)) ? (tap_macro) : (release) ) )
+
+// Holds down the modifier mod when the macro key is held, or sends macro instead when tapped
+#define MACRO_TAP_HOLD_MOD(record, macro, mod) MACRO_TAP_HOLD(record, (MACRO(D(mod), END)), MACRO(U(mod), END), macro)
+
+// Holds down the modifier mod when the macro key is held, or pressed a shifted key when tapped (eg: shift+3 for #)
+#define MACRO_TAP_SHFT_KEY_HOLD_MOD(record, key, mod) MACRO_TAP_HOLD_MOD(record, (MACRO(I(10), D(LSFT), T(key), U(LSFT), END)), mod)
+
+
+// Momentary switch layer when held, sends macro if tapped
+#define MACRO_TAP_HOLD_LAYER(record, macro, layer) ( ((record)->event.pressed) ? \
+     ( ((record)->tap.count <= 0 || (record)->tap.interrupted) ? ({layer_on((layer)); MACRO_NONE; }) : MACRO_NONE ) : \
+     ( ((record)->tap.count > 0 && !((record)->tap.interrupted)) ? (macro) : ({layer_off((layer)); MACRO_NONE; }) ) )
+
+// Momentary switch layer when held, presses a shifted key when tapped (eg: shift+3 for #)
+#define MACRO_TAP_SHFT_KEY_HOLD_LAYER(record, key, layer) MACRO_TAP_HOLD_LAYER(record, MACRO(I(10), D(LSFT), T(key), U(LSFT), END), layer)
+     
 
 
 #ifndef NO_ACTION_MACRO
diff --git a/tmk_core/common/action_tapping.c b/tmk_core/common/action_tapping.c
index e16e11be7..bd9a69ae0 100644
--- a/tmk_core/common/action_tapping.c
+++ b/tmk_core/common/action_tapping.c
@@ -228,6 +228,7 @@ bool process_tapping(keyrecord_t *keyp)
         if (WITHIN_TAPPING_TERM(event)) {
             if (event.pressed) {
                 if (IS_TAPPING_KEY(event.key)) {
+#ifndef TAPPING_FORCE_HOLD
                     if (!tapping_key.tap.interrupted && tapping_key.tap.count > 0) {
                         // sequential tap.
                         keyp->tap = tapping_key.tap;
@@ -237,11 +238,11 @@ bool process_tapping(keyrecord_t *keyp)
                         tapping_key = *keyp;
                         debug_tapping_key();
                         return true;
-                    } else {
-                        // FIX: start new tap again
-                        tapping_key = *keyp;
-                        return true;
                     }
+#endif
+                    // FIX: start new tap again
+                    tapping_key = *keyp;
+                    return true;
                 } else if (is_tap_key(event.key)) {
                     // Sequential tap can be interfered with other tap key.
                     debug("Tapping: Start with interfering other tap.\n");
@@ -257,7 +258,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/avr/bootloader.c b/tmk_core/common/avr/bootloader.c
index ad547b985..34db8d0b0 100644
--- a/tmk_core/common/avr/bootloader.c
+++ b/tmk_core/common/avr/bootloader.c
@@ -1,6 +1,7 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include <avr/io.h>
+#include <avr/eeprom.h>
 #include <avr/interrupt.h>
 #include <avr/wdt.h>
 #include <util/delay.h>
@@ -89,6 +90,12 @@ void bootloader_jump(void) {
             _delay_ms(5);
         #endif
 
+        #ifdef BOOTLOADHID_BOOTLOADER
+            // force bootloadHID to stay in bootloader mode, so that it waits
+            // for a new firmware to be flashed
+            eeprom_write_byte((uint8_t *)1, 0x00);
+        #endif
+
         // watchdog reset
         reset_key = BOOTLOADER_RESET_KEY;
         wdt_enable(WDTO_250MS);
@@ -114,6 +121,11 @@ void bootloader_jump(void) {
     #endif
 }
 
+#ifdef __AVR_ATmega32A__
+// MCUSR is actually called MCUCSR in ATmega32A
+#define MCUSR MCUCSR
+#endif
+
 /* this runs before main() */
 void bootloader_jump_after_watchdog_reset(void) __attribute__ ((used, naked, section (".init3")));
 void bootloader_jump_after_watchdog_reset(void)
diff --git a/tmk_core/common/avr/suspend.c b/tmk_core/common/avr/suspend.c
index 8a7272bbc..0c81e8361 100644
--- a/tmk_core/common/avr/suspend.c
+++ b/tmk_core/common/avr/suspend.c
@@ -47,6 +47,7 @@ void suspend_idle(uint8_t time)
     sleep_disable();
 }
 
+#ifndef NO_SUSPEND_POWER_DOWN
 /* Power down MCU with watchdog timer
  * wdto: watchdog timer timeout defined in <avr/wdt.h>
  *          WDTO_15MS
@@ -61,6 +62,7 @@ void suspend_idle(uint8_t time)
  *          WDTO_8S
  */
 static uint8_t wdt_timeout = 0;
+
 static void power_down(uint8_t wdto)
 {
 #ifdef PROTOCOL_LUFA
@@ -98,19 +100,19 @@ static void power_down(uint8_t wdto)
     // Disable watchdog after sleep
     wdt_disable();
 }
+#endif
 
 void suspend_power_down(void)
 {
+#ifndef NO_SUSPEND_POWER_DOWN
     power_down(WDTO_15MS);
+#endif
 }
 
 __attribute__ ((weak)) void matrix_power_up(void) {}
 __attribute__ ((weak)) void matrix_power_down(void) {}
 bool suspend_wakeup_condition(void)
 {
-#ifdef BACKLIGHT_ENABLE
-    backlight_set(0);
-#endif
     matrix_power_up();
     matrix_scan();
     matrix_power_down();
@@ -126,10 +128,9 @@ void suspend_wakeup_init(void)
     // clear keyboard state
     clear_keyboard();
 #ifdef BACKLIGHT_ENABLE
-    backlight_set(0);
     backlight_init();
 #endif
-led_set(host_keyboard_leds());
+        led_set(host_keyboard_leds());
 }
 
 #ifndef NO_SUSPEND_POWER_DOWN
diff --git a/tmk_core/common/avr/timer.c b/tmk_core/common/avr/timer.c
index 292b41c3a..369015200 100644
--- a/tmk_core/common/avr/timer.c
+++ b/tmk_core/common/avr/timer.c
@@ -17,6 +17,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 #include <avr/io.h>
 #include <avr/interrupt.h>
+#include <util/atomic.h>
 #include <stdint.h>
 #include "timer_avr.h"
 #include "timer.h"
@@ -24,38 +25,47 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 // counter resolution 1ms
 // NOTE: union { uint32_t timer32; struct { uint16_t dummy; uint16_t timer16; }}
-volatile uint32_t timer_count = 0;
+volatile uint32_t timer_count;
 
 void timer_init(void)
 {
-    // Timer0 CTC mode
-    TCCR0A = 0x02;
-
 #if TIMER_PRESCALER == 1
-    TCCR0B = 0x01;
+    uint8_t prescaler = 0x01;
 #elif TIMER_PRESCALER == 8
-    TCCR0B = 0x02;
+    uint8_t prescaler = 0x02;
 #elif TIMER_PRESCALER == 64
-    TCCR0B = 0x03;
+    uint8_t prescaler = 0x03;
 #elif TIMER_PRESCALER == 256
-    TCCR0B = 0x04;
+    uint8_t prescaler = 0x04;
 #elif TIMER_PRESCALER == 1024
-    TCCR0B = 0x05;
+    uint8_t prescaler = 0x05;
 #else
 #   error "Timer prescaler value is NOT vaild."
 #endif
 
+#ifndef __AVR_ATmega32A__
+    // Timer0 CTC mode
+    TCCR0A = 0x02;
+
+    TCCR0B = prescaler;
+
     OCR0A = TIMER_RAW_TOP;
     TIMSK0 = (1<<OCIE0A);
+#else
+    // Timer0 CTC mode
+    TCCR0 = (1 << WGM01) | prescaler;
+
+    OCR0 = TIMER_RAW_TOP;
+    TIMSK = (1 << OCIE0);
+#endif
 }
 
 inline
 void timer_clear(void)
 {
-    uint8_t sreg = SREG;
-    cli();
+  ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
     timer_count = 0;
-    SREG = sreg;
+  }
 }
 
 inline
@@ -63,10 +73,9 @@ uint16_t timer_read(void)
 {
     uint32_t t;
 
-    uint8_t sreg = SREG;
-    cli();
-    t = timer_count;
-    SREG = sreg;
+    ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
+      t = timer_count;
+    }
 
     return (t & 0xFFFF);
 }
@@ -76,10 +85,9 @@ uint32_t timer_read32(void)
 {
     uint32_t t;
 
-    uint8_t sreg = SREG;
-    cli();
-    t = timer_count;
-    SREG = sreg;
+    ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
+      t = timer_count;
+    }
 
     return t;
 }
@@ -89,10 +97,9 @@ uint16_t timer_elapsed(uint16_t last)
 {
     uint32_t t;
 
-    uint8_t sreg = SREG;
-    cli();
-    t = timer_count;
-    SREG = sreg;
+    ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
+      t = timer_count;
+    }
 
     return TIMER_DIFF_16((t & 0xFFFF), last);
 }
@@ -102,16 +109,20 @@ uint32_t timer_elapsed32(uint32_t last)
 {
     uint32_t t;
 
-    uint8_t sreg = SREG;
-    cli();
-    t = timer_count;
-    SREG = sreg;
+    ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
+      t = timer_count;
+    }
 
     return TIMER_DIFF_32(t, last);
 }
 
 // excecuted once per 1ms.(excess for just timer count?)
-ISR(TIMER0_COMPA_vect)
+#ifndef __AVR_ATmega32A__
+#define TIMER_INTERRUPT_VECTOR TIMER0_COMPA_vect
+#else
+#define TIMER_INTERRUPT_VECTOR TIMER0_COMP_vect
+#endif
+ISR(TIMER_INTERRUPT_VECTOR, ISR_NOBLOCK)
 {
     timer_count++;
 }
diff --git a/tmk_core/common/backlight.c b/tmk_core/common/backlight.c
index c9e8fd3fd..0e0ad2d15 100644
--- a/tmk_core/common/backlight.c
+++ b/tmk_core/common/backlight.c
@@ -36,9 +36,9 @@ void backlight_increase(void)
     if(backlight_config.level < BACKLIGHT_LEVELS)
     {
         backlight_config.level++;
-        backlight_config.enable = 1;
-        eeconfig_update_backlight(backlight_config.raw);
     }
+    backlight_config.enable = 1;
+    eeconfig_update_backlight(backlight_config.raw);
     dprintf("backlight increase: %u\n", backlight_config.level);
     backlight_set(backlight_config.level);
 }
diff --git a/tmk_core/common/command.c b/tmk_core/common/command.c
index f3e1bf623..f79d5a257 100644
--- a/tmk_core/common/command.c
+++ b/tmk_core/common/command.c
@@ -235,8 +235,11 @@ static void print_status(void)
     print("\n\t- Status -\n");
 
     print_val_hex8(host_keyboard_leds());
+#ifndef PROTOCOL_VUSB
+    // these aren't set on the V-USB protocol, so we just ignore them for now
     print_val_hex8(keyboard_protocol);
     print_val_hex8(keyboard_idle);
+#endif
 #ifdef NKRO_ENABLE
     print_val_hex8(keymap_config.nkro);
 #endif
@@ -379,11 +382,11 @@ static bool command_common(uint8_t code)
             debug_enable = !debug_enable;
             if (debug_enable) {
                 print("\ndebug: on\n");
-                debug_matrix   = true;
-                debug_keyboard = true;
-                debug_mouse    = true;
             } else {
                 print("\ndebug: off\n");
+                debug_matrix   = false;
+                debug_keyboard = false;
+                debug_mouse    = false;
             }
             break;
 
diff --git a/tmk_core/common/host_driver.h b/tmk_core/common/host_driver.h
index edb9e5dd9..588d1c0be 100644
--- a/tmk_core/common/host_driver.h
+++ b/tmk_core/common/host_driver.h
@@ -20,7 +20,9 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 #include <stdint.h>
 #include "report.h"
-
+#ifdef MIDI_ENABLE
+        #include "midi.h"
+#endif
 
 typedef struct {
     uint8_t (*keyboard_leds)(void);
@@ -28,6 +30,11 @@ typedef struct {
     void (*send_mouse)(report_mouse_t *);
     void (*send_system)(uint16_t);
     void (*send_consumer)(uint16_t);
+#ifdef MIDI_ENABLE
+    void (*usb_send_func)(MidiDevice *, uint16_t, uint8_t, uint8_t, uint8_t);
+    void (*usb_get_midi)(MidiDevice *);
+    void (*midi_usb_init)(MidiDevice *);
+#endif
 } host_driver_t;
 
 #endif
diff --git a/tmk_core/common/keyboard.c b/tmk_core/common/keyboard.c
index 371d93f3e..eac1f1dd8 100644
--- a/tmk_core/common/keyboard.c
+++ b/tmk_core/common/keyboard.c
@@ -14,6 +14,7 @@ GNU General Public License for more details.
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
+
 #include <stdint.h>
 #include "keyboard.h"
 #include "matrix.h"
@@ -50,6 +51,9 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #ifdef RGBLIGHT_ENABLE
 #   include "rgblight.h"
 #endif
+#ifdef FAUXCLICKY_ENABLE
+#   include "fauxclicky.h"
+#endif
 #ifdef SERIAL_LINK_ENABLE
 #   include "serial_link/system/serial_link.h"
 #endif
@@ -107,6 +111,9 @@ void keyboard_init(void) {
 #ifdef RGBLIGHT_ENABLE
     rgblight_init();
 #endif
+#ifdef FAUXCLICKY_ENABLE
+    fauxclicky_init();
+#endif
 #if defined(NKRO_ENABLE) && defined(FORCE_NKRO)
     keymap_config.nkro = 1;
 #endif
@@ -188,7 +195,7 @@ MATRIX_LOOP_END:
 #endif
 
 #ifdef VISUALIZER_ENABLE
-    visualizer_update(default_layer_state, layer_state, host_keyboard_leds());
+    visualizer_update(default_layer_state, layer_state, visualizer_get_mods(), host_keyboard_leds());
 #endif
 
     // update LED
diff --git a/tmk_core/common/keycode.h b/tmk_core/common/keycode.h
index 2f208c54e..54e9c322c 100644
--- a/tmk_core/common/keycode.h
+++ b/tmk_core/common/keycode.h
@@ -85,7 +85,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define KC_LCAP KC_LOCKING_CAPS
 #define KC_LNUM KC_LOCKING_NUM
 #define KC_LSCR KC_LOCKING_SCROLL
-#define KC_ERAS KC_ALT_ERASE,
+#define KC_ERAS KC_ALT_ERASE
 #define KC_CLR  KC_CLEAR
 /* Japanese specific */
 #define KC_ZKHK KC_GRAVE
diff --git a/tmk_core/common/matrix.h b/tmk_core/common/matrix.h
index cee3593ee..2543f5abc 100644
--- a/tmk_core/common/matrix.h
+++ b/tmk_core/common/matrix.h
@@ -50,7 +50,7 @@ void matrix_init(void);
 uint8_t matrix_scan(void);
 /* whether modified from previous scan. used after matrix_scan. */
 bool matrix_is_modified(void) __attribute__ ((deprecated));
-/* whether a swtich is on */
+/* whether a switch is on */
 bool matrix_is_on(uint8_t row, uint8_t col);
 /* matrix state on row */
 matrix_row_t matrix_get_row(uint8_t row);
diff --git a/tmk_core/common/raw_hid.h b/tmk_core/common/raw_hid.h
new file mode 100644
index 000000000..86da02fd1
--- /dev/null
+++ b/tmk_core/common/raw_hid.h
@@ -0,0 +1,8 @@
+#ifndef _RAW_HID_H_
+#define _RAW_HID_H_
+
+void raw_hid_receive( uint8_t *data, uint8_t length );
+
+void raw_hid_send( uint8_t *data, uint8_t length );
+
+#endif
diff --git a/tmk_core/common/report.h b/tmk_core/common/report.h
index 0c799eca3..8fb28b6ce 100644
--- a/tmk_core/common/report.h
+++ b/tmk_core/common/report.h
@@ -134,13 +134,6 @@ typedef union {
     } nkro;
 #endif
 } __attribute__ ((packed)) report_keyboard_t;
-/*
-typedef struct {
-    uint8_t mods;
-    uint8_t reserved;
-    uint8_t keys[REPORT_KEYS];
-} __attribute__ ((packed)) report_keyboard_t;
-*/
 
 typedef struct {
     uint8_t buttons;
diff --git a/tmk_core/protocol/lufa.mk b/tmk_core/protocol/lufa.mk
index 5b1e3d19d..5b1577972 100644
--- a/tmk_core/protocol/lufa.mk
+++ b/tmk_core/protocol/lufa.mk
@@ -8,13 +8,14 @@ LUFA_PATH ?= $(LUFA_DIR)/LUFA-git
 ifneq (, $(wildcard $(TMK_PATH)/$(LUFA_PATH)/LUFA/Build/lufa_sources.mk))
     # New build system from 20120730
     LUFA_ROOT_PATH = $(LUFA_PATH)/LUFA
-    include $(TMK_PATH)/$(LUFA_PATH)/LUFA/Build/lufa_sources.mk 
+    include $(TMK_PATH)/$(LUFA_PATH)/LUFA/Build/lufa_sources.mk
 else
     include $(TMK_PATH)/$(LUFA_PATH)/LUFA/makefile
 endif
 
 LUFA_SRC = lufa.c \
            descriptor.c \
+           outputselect.c \
            $(LUFA_SRC_USB)
 
 ifeq ($(strip $(MIDI_ENABLE)), yes)
@@ -26,6 +27,15 @@ ifeq ($(strip $(BLUETOOTH_ENABLE)), yes)
         $(TMK_DIR)/protocol/serial_uart.c
 endif
 
+ifeq ($(strip $(BLUETOOTH)), AdafruitBLE)
+                LUFA_SRC += $(LUFA_DIR)/adafruit_ble.cpp
+endif
+
+ifeq ($(strip $(BLUETOOTH)), AdafruitEZKey)
+        LUFA_SRC += $(LUFA_DIR)/bluetooth.c \
+        $(TMK_DIR)/protocol/serial_uart.c
+endif
+
 ifeq ($(strip $(VIRTSER_ENABLE)), yes)
         LUFA_SRC += $(LUFA_ROOT_PATH)/Drivers/USB/Class/Device/CDCClassDevice.c
 endif
@@ -49,6 +59,7 @@ LUFA_OPTS += -DUSE_FLASH_DESCRIPTORS
 LUFA_OPTS += -DUSE_STATIC_OPTIONS="(USB_DEVICE_OPT_FULLSPEED | USB_OPT_REG_ENABLED | USB_OPT_AUTO_PLL)"
 #LUFA_OPTS += -DINTERRUPT_CONTROL_ENDPOINT
 LUFA_OPTS += -DFIXED_CONTROL_ENDPOINT_SIZE=8 
+LUFA_OPTS += -DFIXED_CONTROL_ENDPOINT_SIZE=8
 LUFA_OPTS += -DFIXED_NUM_CONFIGURATIONS=1
 
 # Remote wakeup fix for ATmega32U2        https://github.com/tmk/tmk_keyboard/issues/361
diff --git a/tmk_core/protocol/lufa/adafruit_ble.cpp b/tmk_core/protocol/lufa/adafruit_ble.cpp
new file mode 100644
index 000000000..fd6edd42c
--- /dev/null
+++ b/tmk_core/protocol/lufa/adafruit_ble.cpp
@@ -0,0 +1,805 @@
+#include "adafruit_ble.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <alloca.h>
+#include <util/delay.h>
+#include <util/atomic.h>
+#include "debug.h"
+#include "pincontrol.h"
+#include "timer.h"
+#include "action_util.h"
+#include "ringbuffer.hpp"
+#include <string.h>
+
+// These are the pin assignments for the 32u4 boards.
+// You may define them to something else in your config.h
+// if yours is wired up differently.
+#ifndef AdafruitBleResetPin
+#define AdafruitBleResetPin D4
+#endif
+
+#ifndef AdafruitBleCSPin
+#define AdafruitBleCSPin    B4
+#endif
+
+#ifndef AdafruitBleIRQPin
+#define AdafruitBleIRQPin   E6
+#endif
+
+
+#define SAMPLE_BATTERY
+#define ConnectionUpdateInterval 1000 /* milliseconds */
+
+static struct {
+  bool is_connected;
+  bool initialized;
+  bool configured;
+
+#define ProbedEvents 1
+#define UsingEvents 2
+  bool event_flags;
+
+#ifdef SAMPLE_BATTERY
+  uint16_t last_battery_update;
+  uint32_t vbat;
+#endif
+  uint16_t last_connection_update;
+} state;
+
+// Commands are encoded using SDEP and sent via SPI
+// https://github.com/adafruit/Adafruit_BluefruitLE_nRF51/blob/master/SDEP.md
+
+#define SdepMaxPayload 16
+struct sdep_msg {
+  uint8_t type;
+  uint8_t cmd_low;
+  uint8_t cmd_high;
+  struct __attribute__((packed)) {
+    uint8_t len:7;
+    uint8_t more:1;
+  };
+  uint8_t payload[SdepMaxPayload];
+} __attribute__((packed));
+
+// The recv latency is relatively high, so when we're hammering keys quickly,
+// we want to avoid waiting for the responses in the matrix loop.  We maintain
+// a short queue for that.  Since there is quite a lot of space overhead for
+// the AT command representation wrapped up in SDEP, we queue the minimal
+// information here.
+
+enum queue_type {
+  QTKeyReport, // 1-byte modifier + 6-byte key report
+  QTConsumer,  // 16-bit key code
+#ifdef MOUSE_ENABLE
+  QTMouseMove, // 4-byte mouse report
+#endif
+};
+
+struct queue_item {
+  enum queue_type queue_type;
+  uint16_t added;
+  union __attribute__((packed)) {
+    struct __attribute__((packed)) {
+      uint8_t modifier;
+      uint8_t keys[6];
+    } key;
+
+    uint16_t consumer;
+    struct __attribute__((packed)) {
+      int8_t x, y, scroll, pan;
+    } mousemove;
+  };
+};
+
+// Items that we wish to send
+static RingBuffer<queue_item, 40> send_buf;
+// Pending response; while pending, we can't send any more requests.
+// This records the time at which we sent the command for which we
+// are expecting a response.
+static RingBuffer<uint16_t, 2> resp_buf;
+
+static bool process_queue_item(struct queue_item *item, uint16_t timeout);
+
+enum sdep_type {
+  SdepCommand = 0x10,
+  SdepResponse = 0x20,
+  SdepAlert = 0x40,
+  SdepError = 0x80,
+  SdepSlaveNotReady = 0xfe, // Try again later
+  SdepSlaveOverflow = 0xff, // You read more data than is available
+};
+
+enum ble_cmd {
+  BleInitialize = 0xbeef,
+  BleAtWrapper = 0x0a00,
+  BleUartTx = 0x0a01,
+  BleUartRx = 0x0a02,
+};
+
+enum ble_system_event_bits {
+  BleSystemConnected = 0,
+  BleSystemDisconnected = 1,
+  BleSystemUartRx = 8,
+  BleSystemMidiRx = 10,
+};
+
+// The SDEP.md file says 2MHz but the web page and the sample driver
+// both use 4MHz
+#define SpiBusSpeed 4000000
+
+#define SdepTimeout 150 /* milliseconds */
+#define SdepShortTimeout 10 /* milliseconds */
+#define SdepBackOff 25 /* microseconds */
+#define BatteryUpdateInterval 10000 /* milliseconds */
+
+static bool at_command(const char *cmd, char *resp, uint16_t resplen,
+                       bool verbose, uint16_t timeout = SdepTimeout);
+static bool at_command_P(const char *cmd, char *resp, uint16_t resplen,
+                         bool verbose = false);
+
+struct SPI_Settings {
+  uint8_t spcr, spsr;
+};
+
+static struct SPI_Settings spi;
+
+// Initialize 4Mhz MSBFIRST MODE0
+void SPI_init(struct SPI_Settings *spi) {
+  spi->spcr = _BV(SPE) | _BV(MSTR);
+  spi->spsr = _BV(SPI2X);
+
+  static_assert(SpiBusSpeed == F_CPU / 2, "hard coded at 4Mhz");
+
+  ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
+    // Ensure that SS is OUTPUT High
+    digitalWrite(B0, PinLevelHigh);
+    pinMode(B0, PinDirectionOutput);
+
+    SPCR |= _BV(MSTR);
+    SPCR |= _BV(SPE);
+    pinMode(B1 /* SCK */, PinDirectionOutput);
+    pinMode(B2 /* MOSI */, PinDirectionOutput);
+  }
+}
+
+static inline void SPI_begin(struct SPI_Settings*spi) {
+  SPCR = spi->spcr;
+  SPSR = spi->spsr;
+}
+
+static inline uint8_t SPI_TransferByte(uint8_t data) {
+  SPDR = data;
+  asm volatile("nop");
+  while (!(SPSR & _BV(SPIF))) {
+    ; // wait
+  }
+  return SPDR;
+}
+
+static inline void spi_send_bytes(const uint8_t *buf, uint8_t len) {
+  if (len == 0) return;
+  const uint8_t *end = buf + len;
+  while (buf < end) {
+    SPDR = *buf;
+    while (!(SPSR & _BV(SPIF))) {
+      ; // wait
+    }
+    ++buf;
+  }
+}
+
+static inline uint16_t spi_read_byte(void) {
+  return SPI_TransferByte(0x00 /* dummy */);
+}
+
+static inline void spi_recv_bytes(uint8_t *buf, uint8_t len) {
+  const uint8_t *end = buf + len;
+  if (len == 0) return;
+  while (buf < end) {
+    SPDR = 0; // write a dummy to initiate read
+    while (!(SPSR & _BV(SPIF))) {
+      ; // wait
+    }
+    *buf = SPDR;
+    ++buf;
+  }
+}
+
+#if 0
+static void dump_pkt(const struct sdep_msg *msg) {
+  print("pkt: type=");
+  print_hex8(msg->type);
+  print(" cmd=");
+  print_hex8(msg->cmd_high);
+  print_hex8(msg->cmd_low);
+  print(" len=");
+  print_hex8(msg->len);
+  print(" more=");
+  print_hex8(msg->more);
+  print("\n");
+}
+#endif
+
+// Send a single SDEP packet
+static bool sdep_send_pkt(const struct sdep_msg *msg, uint16_t timeout) {
+  SPI_begin(&spi);
+
+  digitalWrite(AdafruitBleCSPin, PinLevelLow);
+  uint16_t timerStart = timer_read();
+  bool success = false;
+  bool ready = false;
+
+  do {
+    ready = SPI_TransferByte(msg->type) != SdepSlaveNotReady;
+    if (ready) {
+      break;
+    }
+
+    // Release it and let it initialize
+    digitalWrite(AdafruitBleCSPin, PinLevelHigh);
+    _delay_us(SdepBackOff);
+    digitalWrite(AdafruitBleCSPin, PinLevelLow);
+  } while (timer_elapsed(timerStart) < timeout);
+
+  if (ready) {
+    // Slave is ready; send the rest of the packet
+    spi_send_bytes(&msg->cmd_low,
+                   sizeof(*msg) - (1 + sizeof(msg->payload)) + msg->len);
+    success = true;
+  }
+
+  digitalWrite(AdafruitBleCSPin, PinLevelHigh);
+
+  return success;
+}
+
+static inline void sdep_build_pkt(struct sdep_msg *msg, uint16_t command,
+                                  const uint8_t *payload, uint8_t len,
+                                  bool moredata) {
+  msg->type = SdepCommand;
+  msg->cmd_low = command & 0xff;
+  msg->cmd_high = command >> 8;
+  msg->len = len;
+  msg->more = (moredata && len == SdepMaxPayload) ? 1 : 0;
+
+  static_assert(sizeof(*msg) == 20, "msg is correctly packed");
+
+  memcpy(msg->payload, payload, len);
+}
+
+// Read a single SDEP packet
+static bool sdep_recv_pkt(struct sdep_msg *msg, uint16_t timeout) {
+  bool success = false;
+  uint16_t timerStart = timer_read();
+  bool ready = false;
+
+  do {
+    ready = digitalRead(AdafruitBleIRQPin);
+    if (ready) {
+      break;
+    }
+    _delay_us(1);
+  } while (timer_elapsed(timerStart) < timeout);
+
+  if (ready) {
+    SPI_begin(&spi);
+
+    digitalWrite(AdafruitBleCSPin, PinLevelLow);
+
+    do {
+      // Read the command type, waiting for the data to be ready
+      msg->type = spi_read_byte();
+      if (msg->type == SdepSlaveNotReady || msg->type == SdepSlaveOverflow) {
+        // Release it and let it initialize
+        digitalWrite(AdafruitBleCSPin, PinLevelHigh);
+        _delay_us(SdepBackOff);
+        digitalWrite(AdafruitBleCSPin, PinLevelLow);
+        continue;
+      }
+
+      // Read the rest of the header
+      spi_recv_bytes(&msg->cmd_low, sizeof(*msg) - (1 + sizeof(msg->payload)));
+
+      // and get the payload if there is any
+      if (msg->len <= SdepMaxPayload) {
+        spi_recv_bytes(msg->payload, msg->len);
+      }
+      success = true;
+      break;
+    } while (timer_elapsed(timerStart) < timeout);
+
+    digitalWrite(AdafruitBleCSPin, PinLevelHigh);
+  }
+  return success;
+}
+
+static void resp_buf_read_one(bool greedy) {
+  uint16_t last_send;
+  if (!resp_buf.peek(last_send)) {
+    return;
+  }
+
+  if (digitalRead(AdafruitBleIRQPin)) {
+    struct sdep_msg msg;
+
+again:
+    if (sdep_recv_pkt(&msg, SdepTimeout)) {
+      if (!msg.more) {
+        // We got it; consume this entry
+        resp_buf.get(last_send);
+        dprintf("recv latency %dms\n", TIMER_DIFF_16(timer_read(), last_send));
+      }
+
+      if (greedy && resp_buf.peek(last_send) && digitalRead(AdafruitBleIRQPin)) {
+        goto again;
+      }
+    }
+
+  } else if (timer_elapsed(last_send) > SdepTimeout * 2) {
+    dprintf("waiting_for_result: timeout, resp_buf size %d\n",
+            (int)resp_buf.size());
+
+    // Timed out: consume this entry
+    resp_buf.get(last_send);
+  }
+}
+
+static void send_buf_send_one(uint16_t timeout = SdepTimeout) {
+  struct queue_item item;
+
+  // Don't send anything more until we get an ACK
+  if (!resp_buf.empty()) {
+    return;
+  }
+
+  if (!send_buf.peek(item)) {
+    return;
+  }
+  if (process_queue_item(&item, timeout)) {
+    // commit that peek
+    send_buf.get(item);
+    dprintf("send_buf_send_one: have %d remaining\n", (int)send_buf.size());
+  } else {
+    dprint("failed to send, will retry\n");
+    _delay_ms(SdepTimeout);
+    resp_buf_read_one(true);
+  }
+}
+
+static void resp_buf_wait(const char *cmd) {
+  bool didPrint = false;
+  while (!resp_buf.empty()) {
+    if (!didPrint) {
+      dprintf("wait on buf for %s\n", cmd);
+      didPrint = true;
+    }
+    resp_buf_read_one(true);
+  }
+}
+
+static bool ble_init(void) {
+  state.initialized = false;
+  state.configured = false;
+  state.is_connected = false;
+
+  pinMode(AdafruitBleIRQPin, PinDirectionInput);
+  pinMode(AdafruitBleCSPin, PinDirectionOutput);
+  digitalWrite(AdafruitBleCSPin, PinLevelHigh);
+
+  SPI_init(&spi);
+
+  // Perform a hardware reset
+  pinMode(AdafruitBleResetPin, PinDirectionOutput);
+  digitalWrite(AdafruitBleResetPin, PinLevelHigh);
+  digitalWrite(AdafruitBleResetPin, PinLevelLow);
+  _delay_ms(10);
+  digitalWrite(AdafruitBleResetPin, PinLevelHigh);
+
+  _delay_ms(1000); // Give it a second to initialize
+
+  state.initialized = true;
+  return state.initialized;
+}
+
+static inline uint8_t min(uint8_t a, uint8_t b) {
+  return a < b ? a : b;
+}
+
+static bool read_response(char *resp, uint16_t resplen, bool verbose) {
+  char *dest = resp;
+  char *end = dest + resplen;
+
+  while (true) {
+    struct sdep_msg msg;
+
+    if (!sdep_recv_pkt(&msg, 2 * SdepTimeout)) {
+      dprint("sdep_recv_pkt failed\n");
+      return false;
+    }
+
+    if (msg.type != SdepResponse) {
+      *resp = 0;
+      return false;
+    }
+
+    uint8_t len = min(msg.len, end - dest);
+    if (len > 0) {
+      memcpy(dest, msg.payload, len);
+      dest += len;
+    }
+
+    if (!msg.more) {
+      // No more data is expected!
+      break;
+    }
+  }
+
+  // Ensure the response is NUL terminated
+  *dest = 0;
+
+  // "Parse" the result text; we want to snip off the trailing OK or ERROR line
+  // Rewind past the possible trailing CRLF so that we can strip it
+  --dest;
+  while (dest > resp && (dest[0] == '\n' || dest[0] == '\r')) {
+    *dest = 0;
+    --dest;
+  }
+
+  // Look back for start of preceeding line
+  char *last_line = strrchr(resp, '\n');
+  if (last_line) {
+    ++last_line;
+  } else {
+    last_line = resp;
+  }
+
+  bool success = false;
+  static const char kOK[] PROGMEM = "OK";
+
+  success = !strcmp_P(last_line, kOK );
+
+  if (verbose || !success) {
+    dprintf("result: %s\n", resp);
+  }
+  return success;
+}
+
+static bool at_command(const char *cmd, char *resp, uint16_t resplen,
+                       bool verbose, uint16_t timeout) {
+  const char *end = cmd + strlen(cmd);
+  struct sdep_msg msg;
+
+  if (verbose) {
+    dprintf("ble send: %s\n", cmd);
+  }
+
+  if (resp) {
+    // They want to decode the response, so we need to flush and wait
+    // for all pending I/O to finish before we start this one, so
+    // that we don't confuse the results
+    resp_buf_wait(cmd);
+    *resp = 0;
+  }
+
+  // Fragment the command into a series of SDEP packets
+  while (end - cmd > SdepMaxPayload) {
+    sdep_build_pkt(&msg, BleAtWrapper, (uint8_t *)cmd, SdepMaxPayload, true);
+    if (!sdep_send_pkt(&msg, timeout)) {
+      return false;
+    }
+    cmd += SdepMaxPayload;
+  }
+
+  sdep_build_pkt(&msg, BleAtWrapper, (uint8_t *)cmd, end - cmd, false);
+  if (!sdep_send_pkt(&msg, timeout)) {
+    return false;
+  }
+
+  if (resp == NULL) {
+    auto now = timer_read();
+    while (!resp_buf.enqueue(now)) {
+      resp_buf_read_one(false);
+    }
+    auto later = timer_read();
+    if (TIMER_DIFF_16(later, now) > 0) {
+      dprintf("waited %dms for resp_buf\n", TIMER_DIFF_16(later, now));
+    }
+    return true;
+  }
+
+  return read_response(resp, resplen, verbose);
+}
+
+bool at_command_P(const char *cmd, char *resp, uint16_t resplen, bool verbose) {
+  auto cmdbuf = (char *)alloca(strlen_P(cmd) + 1);
+  strcpy_P(cmdbuf, cmd);
+  return at_command(cmdbuf, resp, resplen, verbose);
+}
+
+bool adafruit_ble_is_connected(void) {
+  return state.is_connected;
+}
+
+bool adafruit_ble_enable_keyboard(void) {
+  char resbuf[128];
+
+  if (!state.initialized && !ble_init()) {
+    return false;
+  }
+
+  state.configured = false;
+
+  // Disable command echo
+  static const char kEcho[] PROGMEM = "ATE=0";
+  // Make the advertised name match the keyboard
+  static const char kGapDevName[] PROGMEM =
+      "AT+GAPDEVNAME=" STR(PRODUCT) " " STR(DESCRIPTION);
+  // Turn on keyboard support
+  static const char kHidEnOn[] PROGMEM = "AT+BLEHIDEN=1";
+
+  // Adjust intervals to improve latency.  This causes the "central"
+  // system (computer/tablet) to poll us every 10-30 ms.  We can't
+  // set a smaller value than 10ms, and 30ms seems to be the natural
+  // processing time on my macbook.  Keeping it constrained to that
+  // feels reasonable to type to.
+  static const char kGapIntervals[] PROGMEM = "AT+GAPINTERVALS=10,30,,";
+
+  // Reset the device so that it picks up the above changes
+  static const char kATZ[] PROGMEM = "ATZ";
+
+  // Turn down the power level a bit
+  static const char kPower[] PROGMEM = "AT+BLEPOWERLEVEL=-12";
+  static PGM_P const configure_commands[] PROGMEM = {
+    kEcho,
+    kGapIntervals,
+    kGapDevName,
+    kHidEnOn,
+    kPower,
+    kATZ,
+  };
+
+  uint8_t i;
+  for (i = 0; i < sizeof(configure_commands) / sizeof(configure_commands[0]);
+       ++i) {
+    PGM_P cmd;
+    memcpy_P(&cmd, configure_commands + i, sizeof(cmd));
+
+    if (!at_command_P(cmd, resbuf, sizeof(resbuf))) {
+      dprintf("failed BLE command: %S: %s\n", cmd, resbuf);
+      goto fail;
+    }
+  }
+
+  state.configured = true;
+
+  // Check connection status in a little while; allow the ATZ time
+  // to kick in.
+  state.last_connection_update = timer_read();
+fail:
+  return state.configured;
+}
+
+static void set_connected(bool connected) {
+  if (connected != state.is_connected) {
+    if (connected) {
+      print("****** BLE CONNECT!!!!\n");
+    } else {
+      print("****** BLE DISCONNECT!!!!\n");
+    }
+    state.is_connected = connected;
+
+    // TODO: if modifiers are down on the USB interface and
+    // we cut over to BLE or vice versa, they will remain stuck.
+    // This feels like a good point to do something like clearing
+    // the keyboard and/or generating a fake all keys up message.
+    // However, I've noticed that it takes a couple of seconds
+    // for macOS to to start recognizing key presses after BLE
+    // is in the connected state, so I worry that doing that
+    // here may not be good enough.
+  }
+}
+
+void adafruit_ble_task(void) {
+  char resbuf[48];
+
+  if (!state.configured && !adafruit_ble_enable_keyboard()) {
+    return;
+  }
+  resp_buf_read_one(true);
+  send_buf_send_one(SdepShortTimeout);
+
+  if (resp_buf.empty() && (state.event_flags & UsingEvents) &&
+      digitalRead(AdafruitBleIRQPin)) {
+    // Must be an event update
+    if (at_command_P(PSTR("AT+EVENTSTATUS"), resbuf, sizeof(resbuf))) {
+      uint32_t mask = strtoul(resbuf, NULL, 16);
+
+      if (mask & BleSystemConnected) {
+        set_connected(true);
+      } else if (mask & BleSystemDisconnected) {
+        set_connected(false);
+      }
+    }
+  }
+
+  if (timer_elapsed(state.last_connection_update) > ConnectionUpdateInterval) {
+    bool shouldPoll = true;
+    if (!(state.event_flags & ProbedEvents)) {
+      // Request notifications about connection status changes.
+      // This only works in SPIFRIEND firmware > 0.6.7, which is why
+      // we check for this conditionally here.
+      // Note that at the time of writing, HID reports only work correctly
+      // with Apple products on firmware version 0.6.7!
+      // https://forums.adafruit.com/viewtopic.php?f=8&t=104052
+      if (at_command_P(PSTR("AT+EVENTENABLE=0x1"), resbuf, sizeof(resbuf))) {
+        at_command_P(PSTR("AT+EVENTENABLE=0x2"), resbuf, sizeof(resbuf));
+        state.event_flags |= UsingEvents;
+      }
+      state.event_flags |= ProbedEvents;
+
+      // leave shouldPoll == true so that we check at least once
+      // before relying solely on events
+    } else {
+      shouldPoll = false;
+    }
+
+    static const char kGetConn[] PROGMEM = "AT+GAPGETCONN";
+    state.last_connection_update = timer_read();
+
+    if (at_command_P(kGetConn, resbuf, sizeof(resbuf))) {
+      set_connected(atoi(resbuf));
+    }
+  }
+
+#ifdef SAMPLE_BATTERY
+  // I don't know if this really does anything useful yet; the reported
+  // voltage level always seems to be around 3200mV.  We may want to just rip
+  // this code out.
+  if (timer_elapsed(state.last_battery_update) > BatteryUpdateInterval &&
+      resp_buf.empty()) {
+    state.last_battery_update = timer_read();
+
+    if (at_command_P(PSTR("AT+HWVBAT"), resbuf, sizeof(resbuf))) {
+      state.vbat = atoi(resbuf);
+    }
+  }
+#endif
+}
+
+static bool process_queue_item(struct queue_item *item, uint16_t timeout) {
+  char cmdbuf[48];
+  char fmtbuf[64];
+
+  // Arrange to re-check connection after keys have settled
+  state.last_connection_update = timer_read();
+
+#if 1
+  if (TIMER_DIFF_16(state.last_connection_update, item->added) > 0) {
+    dprintf("send latency %dms\n",
+            TIMER_DIFF_16(state.last_connection_update, item->added));
+  }
+#endif
+
+  switch (item->queue_type) {
+    case QTKeyReport:
+      strcpy_P(fmtbuf,
+          PSTR("AT+BLEKEYBOARDCODE=%02x-00-%02x-%02x-%02x-%02x-%02x-%02x"));
+      snprintf(cmdbuf, sizeof(cmdbuf), fmtbuf, item->key.modifier,
+               item->key.keys[0], item->key.keys[1], item->key.keys[2],
+               item->key.keys[3], item->key.keys[4], item->key.keys[5]);
+      return at_command(cmdbuf, NULL, 0, true, timeout);
+
+    case QTConsumer:
+      strcpy_P(fmtbuf, PSTR("AT+BLEHIDCONTROLKEY=0x%04x"));
+      snprintf(cmdbuf, sizeof(cmdbuf), fmtbuf, item->consumer);
+      return at_command(cmdbuf, NULL, 0, true, timeout);
+
+#ifdef MOUSE_ENABLE
+    case QTMouseMove:
+      strcpy_P(fmtbuf, PSTR("AT+BLEHIDMOUSEMOVE=%d,%d,%d,%d"));
+      snprintf(cmdbuf, sizeof(cmdbuf), fmtbuf, item->mousemove.x,
+          item->mousemove.y, item->mousemove.scroll, item->mousemove.pan);
+      return at_command(cmdbuf, NULL, 0, true, timeout);
+#endif
+    default:
+      return true;
+  }
+}
+
+bool adafruit_ble_send_keys(uint8_t hid_modifier_mask, uint8_t *keys,
+                            uint8_t nkeys) {
+  struct queue_item item;
+  bool didWait = false;
+
+  item.queue_type = QTKeyReport;
+  item.key.modifier = hid_modifier_mask;
+  item.added = timer_read();
+
+  while (nkeys >= 0) {
+    item.key.keys[0] = keys[0];
+    item.key.keys[1] = nkeys >= 1 ? keys[1] : 0;
+    item.key.keys[2] = nkeys >= 2 ? keys[2] : 0;
+    item.key.keys[3] = nkeys >= 3 ? keys[3] : 0;
+    item.key.keys[4] = nkeys >= 4 ? keys[4] : 0;
+    item.key.keys[5] = nkeys >= 5 ? keys[5] : 0;
+
+    if (!send_buf.enqueue(item)) {
+      if (!didWait) {
+        dprint("wait for buf space\n");
+        didWait = true;
+      }
+      send_buf_send_one();
+      continue;
+    }
+
+    if (nkeys <= 6) {
+      return true;
+    }
+
+    nkeys -= 6;
+    keys += 6;
+  }
+
+  return true;
+}
+
+bool adafruit_ble_send_consumer_key(uint16_t keycode, int hold_duration) {
+  struct queue_item item;
+
+  item.queue_type = QTConsumer;
+  item.consumer = keycode;
+
+  while (!send_buf.enqueue(item)) {
+    send_buf_send_one();
+  }
+  return true;
+}
+
+#ifdef MOUSE_ENABLE
+bool adafruit_ble_send_mouse_move(int8_t x, int8_t y, int8_t scroll,
+                                  int8_t pan) {
+  struct queue_item item;
+
+  item.queue_type = QTMouseMove;
+  item.mousemove.x = x;
+  item.mousemove.y = y;
+  item.mousemove.scroll = scroll;
+  item.mousemove.pan = pan;
+
+  while (!send_buf.enqueue(item)) {
+    send_buf_send_one();
+  }
+  return true;
+}
+#endif
+
+uint32_t adafruit_ble_read_battery_voltage(void) {
+  return state.vbat;
+}
+
+bool adafruit_ble_set_mode_leds(bool on) {
+  if (!state.configured) {
+    return false;
+  }
+
+  // The "mode" led is the red blinky one
+  at_command_P(on ? PSTR("AT+HWMODELED=1") : PSTR("AT+HWMODELED=0"), NULL, 0);
+
+  // Pin 19 is the blue "connected" LED; turn that off too.
+  // When turning LEDs back on, don't turn that LED on if we're
+  // not connected, as that would be confusing.
+  at_command_P(on && state.is_connected ? PSTR("AT+HWGPIO=19,1")
+                                        : PSTR("AT+HWGPIO=19,0"),
+               NULL, 0);
+  return true;
+}
+
+// https://learn.adafruit.com/adafruit-feather-32u4-bluefruit-le/ble-generic#at-plus-blepowerlevel
+bool adafruit_ble_set_power_level(int8_t level) {
+  char cmd[46];
+  if (!state.configured) {
+    return false;
+  }
+  snprintf(cmd, sizeof(cmd), "AT+BLEPOWERLEVEL=%d", level);
+  return at_command(cmd, NULL, 0, false);
+}
diff --git a/tmk_core/protocol/lufa/adafruit_ble.h b/tmk_core/protocol/lufa/adafruit_ble.h
new file mode 100644
index 000000000..b3bab3ca0
--- /dev/null
+++ b/tmk_core/protocol/lufa/adafruit_ble.h
@@ -0,0 +1,60 @@
+/* Bluetooth Low Energy Protocol for QMK.
+ * Author: Wez Furlong, 2016
+ * Supports the Adafruit BLE board built around the nRF51822 chip.
+ */
+#pragma once
+#ifdef MODULE_ADAFRUIT_BLE
+#include <stdbool.h>
+#include <stdint.h>
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Instruct the module to enable HID keyboard support and reset */
+extern bool adafruit_ble_enable_keyboard(void);
+
+/* Query to see if the BLE module is connected */
+extern bool adafruit_ble_query_is_connected(void);
+
+/* Returns true if we believe that the BLE module is connected.
+ * This uses our cached understanding that is maintained by
+ * calling ble_task() periodically. */
+extern bool adafruit_ble_is_connected(void);
+
+/* Call this periodically to process BLE-originated things */
+extern void adafruit_ble_task(void);
+
+/* Generates keypress events for a set of keys.
+ * The hid modifier mask specifies the state of the modifier keys for
+ * this set of keys.
+ * Also sends a key release indicator, so that the keys do not remain
+ * held down. */
+extern bool adafruit_ble_send_keys(uint8_t hid_modifier_mask, uint8_t *keys,
+                                   uint8_t nkeys);
+
+/* Send a consumer keycode, holding it down for the specified duration
+ * (milliseconds) */
+extern bool adafruit_ble_send_consumer_key(uint16_t keycode, int hold_duration);
+
+#ifdef MOUSE_ENABLE
+/* Send a mouse/wheel movement report.
+ * The parameters are signed and indicate positive of negative direction
+ * change. */
+extern bool adafruit_ble_send_mouse_move(int8_t x, int8_t y, int8_t scroll,
+                                         int8_t pan);
+#endif
+
+/* Compute battery voltage by reading an analog pin.
+ * Returns the integer number of millivolts */
+extern uint32_t adafruit_ble_read_battery_voltage(void);
+
+extern bool adafruit_ble_set_mode_leds(bool on);
+extern bool adafruit_ble_set_power_level(int8_t level);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // MODULE_ADAFRUIT_BLE
diff --git a/tmk_core/protocol/lufa/descriptor.c b/tmk_core/protocol/lufa/descriptor.c
index 6f2407f58..feeea76df 100644
--- a/tmk_core/protocol/lufa/descriptor.c
+++ b/tmk_core/protocol/lufa/descriptor.c
@@ -40,6 +40,9 @@
 #include "report.h"
 #include "descriptor.h"
 
+#ifndef USB_MAX_POWER_CONSUMPTION
+#define USB_MAX_POWER_CONSUMPTION 500
+#endif
 
 /*******************************************************************************
  * HID Report Descriptors
@@ -140,10 +143,10 @@ const USB_Descriptor_HIDReport_Datatype_t PROGMEM ExtrakeyReport[] =
     HID_RI_USAGE(8, 0x80), /* System Control */
     HID_RI_COLLECTION(8, 0x01), /* Application */
         HID_RI_REPORT_ID(8, REPORT_ID_SYSTEM),
-        HID_RI_LOGICAL_MINIMUM(16, 0x0081),
-        HID_RI_LOGICAL_MAXIMUM(16, 0x00B7),
+        HID_RI_LOGICAL_MINIMUM(16, 0x0001),
+        HID_RI_LOGICAL_MAXIMUM(16, 0x0003),
         HID_RI_USAGE_MINIMUM(16, 0x0081), /* System Power Down */
-        HID_RI_USAGE_MAXIMUM(16, 0x00B7), /* System Display LCD Autoscale */
+        HID_RI_USAGE_MAXIMUM(16, 0x0083), /* System Wake Up */
         HID_RI_REPORT_SIZE(8, 16),
         HID_RI_REPORT_COUNT(8, 1),
         HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_ARRAY | HID_IOF_ABSOLUTE),
@@ -164,6 +167,28 @@ const USB_Descriptor_HIDReport_Datatype_t PROGMEM ExtrakeyReport[] =
 };
 #endif
 
+#ifdef RAW_ENABLE
+const USB_Descriptor_HIDReport_Datatype_t PROGMEM RawReport[] =
+{
+    HID_RI_USAGE_PAGE(16, 0xFF60), /* Vendor Page 0xFF60 */
+    HID_RI_USAGE(8, 0x61), /* Vendor Usage 0x61 */
+    HID_RI_COLLECTION(8, 0x01), /* Application */
+        HID_RI_USAGE(8, 0x62), /* Vendor Usage 0x62 */
+        HID_RI_LOGICAL_MINIMUM(8, 0x00),
+        HID_RI_LOGICAL_MAXIMUM(16, 0x00FF),
+        HID_RI_REPORT_COUNT(8, RAW_EPSIZE),
+        HID_RI_REPORT_SIZE(8, 0x08),
+        HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
+        HID_RI_USAGE(8, 0x63), /* Vendor Usage 0x63 */
+        HID_RI_LOGICAL_MINIMUM(8, 0x00),
+        HID_RI_LOGICAL_MAXIMUM(16, 0x00FF),
+        HID_RI_REPORT_COUNT(8, RAW_EPSIZE),
+        HID_RI_REPORT_SIZE(8, 0x08),
+        HID_RI_OUTPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE | HID_IOF_NON_VOLATILE),
+    HID_RI_END_COLLECTION(0),
+};
+#endif
+
 #ifdef CONSOLE_ENABLE
 const USB_Descriptor_HIDReport_Datatype_t PROGMEM ConsoleReport[] =
 {
@@ -272,7 +297,7 @@ const USB_Descriptor_Configuration_t PROGMEM ConfigurationDescriptor =
 
             .ConfigAttributes       = (USB_CONFIG_ATTR_RESERVED | USB_CONFIG_ATTR_REMOTEWAKEUP),
 
-            .MaxPowerConsumption    = USB_CONFIG_POWER_MA(500)
+            .MaxPowerConsumption    = USB_CONFIG_POWER_MA(USB_MAX_POWER_CONSUMPTION)
         },
 
     /*
@@ -399,6 +424,58 @@ const USB_Descriptor_Configuration_t PROGMEM ConfigurationDescriptor =
         },
 #endif
 
+                /*
+             * Raw
+             */
+        #ifdef RAW_ENABLE
+            .Raw_Interface =
+                {
+                    .Header                 = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},
+
+                    .InterfaceNumber        = RAW_INTERFACE,
+                    .AlternateSetting       = 0x00,
+
+                    .TotalEndpoints         = 2,
+
+                    .Class                  = HID_CSCP_HIDClass,
+                    .SubClass               = HID_CSCP_NonBootSubclass,
+                    .Protocol               = HID_CSCP_NonBootProtocol,
+
+                    .InterfaceStrIndex      = NO_DESCRIPTOR
+                },
+
+            .Raw_HID =
+                {
+                    .Header                 = {.Size = sizeof(USB_HID_Descriptor_HID_t), .Type = HID_DTYPE_HID},
+
+                    .HIDSpec                = VERSION_BCD(1,1,1),
+                    .CountryCode            = 0x00,
+                    .TotalReportDescriptors = 1,
+                    .HIDReportType          = HID_DTYPE_Report,
+                    .HIDReportLength        = sizeof(RawReport)
+                },
+
+            .Raw_INEndpoint =
+                {
+                    .Header                 = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
+
+                    .EndpointAddress        = (ENDPOINT_DIR_IN | RAW_IN_EPNUM),
+                    .Attributes             = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
+                    .EndpointSize           = RAW_EPSIZE,
+                    .PollingIntervalMS      = 0x01
+                },
+
+            .Raw_OUTEndpoint =
+                {
+                    .Header                 = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
+
+                    .EndpointAddress        = (ENDPOINT_DIR_OUT | RAW_OUT_EPNUM),
+                    .Attributes             = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
+                    .EndpointSize           = RAW_EPSIZE,
+                    .PollingIntervalMS      = 0x01
+                },
+        #endif
+
     /*
      * Console
      */
@@ -754,7 +831,6 @@ const USB_Descriptor_Configuration_t PROGMEM ConfigurationDescriptor =
                     .PollingIntervalMS      = 0x05
             },
 #endif
-
 };
 
 
@@ -846,6 +922,12 @@ uint16_t CALLBACK_USB_GetDescriptor(const uint16_t wValue,
                 Size    = sizeof(USB_HID_Descriptor_HID_t);
                 break;
 #endif
+#ifdef RAW_ENABLE
+            case RAW_INTERFACE:
+                Address = &ConfigurationDescriptor.Raw_HID;
+                Size    = sizeof(USB_HID_Descriptor_HID_t);
+                break;
+#endif
 #ifdef CONSOLE_ENABLE
             case CONSOLE_INTERFACE:
                 Address = &ConfigurationDescriptor.Console_HID;
@@ -878,6 +960,12 @@ uint16_t CALLBACK_USB_GetDescriptor(const uint16_t wValue,
                 Size    = sizeof(ExtrakeyReport);
                 break;
 #endif
+#ifdef RAW_ENABLE
+            case RAW_INTERFACE:
+                Address = &RawReport;
+                Size    = sizeof(RawReport);
+                break;
+#endif
 #ifdef CONSOLE_ENABLE
             case CONSOLE_INTERFACE:
                 Address = &ConsoleReport;
diff --git a/tmk_core/protocol/lufa/descriptor.h b/tmk_core/protocol/lufa/descriptor.h
index c6c94e361..24ce420e6 100644
--- a/tmk_core/protocol/lufa/descriptor.h
+++ b/tmk_core/protocol/lufa/descriptor.h
@@ -71,6 +71,14 @@ typedef struct
     USB_Descriptor_Endpoint_t             Extrakey_INEndpoint;
 #endif
 
+#ifdef RAW_ENABLE
+    // Raw HID Interface
+    USB_Descriptor_Interface_t            Raw_Interface;
+    USB_HID_Descriptor_HID_t              Raw_HID;
+    USB_Descriptor_Endpoint_t             Raw_INEndpoint;
+    USB_Descriptor_Endpoint_t             Raw_OUTEndpoint;
+#endif
+
 #ifdef CONSOLE_ENABLE
     // Console HID Interface
     USB_Descriptor_Interface_t            Console_Interface;
@@ -137,10 +145,16 @@ typedef struct
 #   define EXTRAKEY_INTERFACE       MOUSE_INTERFACE
 #endif
 
+#ifdef RAW_ENABLE
+#   define RAW_INTERFACE                (EXTRAKEY_INTERFACE + 1)
+#else
+#   define RAW_INTERFACE                EXTRAKEY_INTERFACE
+#endif
+
 #ifdef CONSOLE_ENABLE
-#   define CONSOLE_INTERFACE        (EXTRAKEY_INTERFACE + 1)
+#   define CONSOLE_INTERFACE        (RAW_INTERFACE + 1)
 #else
-#   define CONSOLE_INTERFACE        EXTRAKEY_INTERFACE
+#   define CONSOLE_INTERFACE        RAW_INTERFACE
 #endif
 
 #ifdef NKRO_ENABLE
@@ -182,12 +196,19 @@ typedef struct
 #   define EXTRAKEY_IN_EPNUM        MOUSE_IN_EPNUM
 #endif
 
+#ifdef RAW_ENABLE
+#   define RAW_IN_EPNUM         (EXTRAKEY_IN_EPNUM + 1)
+#   define RAW_OUT_EPNUM        (EXTRAKEY_IN_EPNUM + 2)
+#else
+#   define RAW_OUT_EPNUM        EXTRAKEY_IN_EPNUM
+#endif
+
 #ifdef CONSOLE_ENABLE
-#   define CONSOLE_IN_EPNUM         (EXTRAKEY_IN_EPNUM + 1)
-#   define CONSOLE_OUT_EPNUM        (EXTRAKEY_IN_EPNUM + 1)
-//#   define CONSOLE_OUT_EPNUM        (EXTRAKEY_IN_EPNUM + 2)
+#   define CONSOLE_IN_EPNUM         (RAW_OUT_EPNUM + 1)
+//#   define CONSOLE_OUT_EPNUM        (RAW_OUT_EPNUM + 2)
+#   define CONSOLE_OUT_EPNUM        (RAW_OUT_EPNUM + 1)
 #else
-#   define CONSOLE_OUT_EPNUM        EXTRAKEY_IN_EPNUM
+#   define CONSOLE_OUT_EPNUM        RAW_OUT_EPNUM
 #endif
 
 #ifdef NKRO_ENABLE
@@ -217,7 +238,6 @@ typedef struct
 #   define CDC_OUT_EPNUM        MIDI_STREAM_OUT_EPNUM
 #endif
 
-
 #if defined(__AVR_ATmega32U2__) && CDC_OUT_EPNUM > 4
 # error "Endpoints are not available enough to support all functions. Remove some in Makefile.(MOUSEKEY, EXTRAKEY, CONSOLE, NKRO, MIDI, SERIAL)"
 #endif
@@ -225,6 +245,7 @@ typedef struct
 #define KEYBOARD_EPSIZE             8
 #define MOUSE_EPSIZE                8
 #define EXTRAKEY_EPSIZE             8
+#define RAW_EPSIZE                      32
 #define CONSOLE_EPSIZE              32
 #define NKRO_EPSIZE                 32
 #define MIDI_STREAM_EPSIZE          64
diff --git a/tmk_core/protocol/lufa/lufa.c b/tmk_core/protocol/lufa/lufa.c
index 01c0e45b0..60cba8d2a 100644
--- a/tmk_core/protocol/lufa/lufa.c
+++ b/tmk_core/protocol/lufa/lufa.c
@@ -51,6 +51,9 @@
 
 #include "descriptor.h"
 #include "lufa.h"
+#include "quantum.h"
+#include <util/atomic.h>
+#include "outputselect.h"
 
 #ifdef NKRO_ENABLE
   #include "keycode_config.h"
@@ -64,13 +67,29 @@
 #endif
 
 #ifdef BLUETOOTH_ENABLE
+  #ifdef MODULE_ADAFRUIT_BLE
+    #include "adafruit_ble.h"
+  #else
     #include "bluetooth.h"
+  #endif
 #endif
 
 #ifdef VIRTSER_ENABLE
     #include "virtser.h"
 #endif
 
+#if (defined(RGB_MIDI) | defined(RGBLIGHT_ANIMATIONS)) & defined(RGBLIGHT_ENABLE)
+    #include "rgblight.h"
+#endif
+
+#ifdef MIDI_ENABLE
+  #include "sysex_tools.h"
+#endif
+
+#ifdef RAW_ENABLE
+        #include "raw_hid.h"
+#endif
+
 uint8_t keyboard_idle = 0;
 /* 0: Boot Protocol, 1: Report Protocol(default) */
 uint8_t keyboard_protocol = 1;
@@ -79,9 +98,9 @@ static uint8_t keyboard_led_stats = 0;
 static report_keyboard_t keyboard_report_sent;
 
 #ifdef MIDI_ENABLE
-void usb_send_func(MidiDevice * device, uint16_t cnt, uint8_t byte0, uint8_t byte1, uint8_t byte2);
-void usb_get_midi(MidiDevice * device);
-void midi_usb_init(MidiDevice * device);
+static void usb_send_func(MidiDevice * device, uint16_t cnt, uint8_t byte0, uint8_t byte1, uint8_t byte2);
+static void usb_get_midi(MidiDevice * device);
+static void midi_usb_init(MidiDevice * device);
 #endif
 
 /* Host driver */
@@ -166,6 +185,80 @@ USB_ClassInfo_CDC_Device_t cdc_device =
 };
 #endif
 
+#ifdef RAW_ENABLE
+
+void raw_hid_send( uint8_t *data, uint8_t length )
+{
+        // TODO: implement variable size packet
+        if ( length != RAW_EPSIZE )
+        {
+                return;
+        }
+
+        if (USB_DeviceState != DEVICE_STATE_Configured)
+        {
+                return;
+        }
+
+        // TODO: decide if we allow calls to raw_hid_send() in the middle
+        // of other endpoint usage.
+        uint8_t ep = Endpoint_GetCurrentEndpoint();
+
+        Endpoint_SelectEndpoint(RAW_IN_EPNUM);
+
+        // Check to see if the host is ready to accept another packet
+        if (Endpoint_IsINReady())
+        {
+                // Write data
+                Endpoint_Write_Stream_LE(data, RAW_EPSIZE, NULL);
+                // Finalize the stream transfer to send the last packet
+                Endpoint_ClearIN();
+        }
+
+        Endpoint_SelectEndpoint(ep);
+}
+
+__attribute__ ((weak))
+void raw_hid_receive( uint8_t *data, uint8_t length )
+{
+        // Users should #include "raw_hid.h" in their own code
+        // and implement this function there. Leave this as weak linkage
+        // so users can opt to not handle data coming in.
+}
+
+static void raw_hid_task(void)
+{
+        // Create a temporary buffer to hold the read in data from the host
+        uint8_t data[RAW_EPSIZE];
+        bool data_read = false;
+
+        // Device must be connected and configured for the task to run
+        if (USB_DeviceState != DEVICE_STATE_Configured)
+        return;
+
+        Endpoint_SelectEndpoint(RAW_OUT_EPNUM);
+
+        // Check to see if a packet has been sent from the host
+        if (Endpoint_IsOUTReceived())
+        {
+                // Check to see if the packet contains data
+                if (Endpoint_IsReadWriteAllowed())
+                {
+                        /* Read data */
+                        Endpoint_Read_Stream_LE(data, sizeof(data), NULL);
+                        data_read = true;
+                }
+
+                // Finalize the stream transfer to receive the last packet
+                Endpoint_ClearOUT();
+
+                if ( data_read )
+                {
+                        raw_hid_receive( data, sizeof(data) );
+                }
+        }
+}
+#endif
 
 /*******************************************************************************
  * Console
@@ -285,10 +378,14 @@ void EVENT_USB_Device_WakeUp()
 #endif
 }
 
+
+
 #ifdef CONSOLE_ENABLE
 static bool console_flush = false;
 #define CONSOLE_FLUSH_SET(b)   do { \
-    uint8_t sreg = SREG; cli(); console_flush = b; SREG = sreg; \
+  ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {\
+    console_flush = b; \
+  } \
 } while (0)
 
 // called every 1ms
@@ -302,6 +399,7 @@ void EVENT_USB_Device_StartOfFrame(void)
     Console_Task();
     console_flush = false;
 }
+
 #endif
 
 /** Event handler for the USB_ConfigurationChanged event.
@@ -330,6 +428,14 @@ void EVENT_USB_Device_ConfigurationChanged(void)
                                      EXTRAKEY_EPSIZE, ENDPOINT_BANK_SINGLE);
 #endif
 
+#ifdef RAW_ENABLE
+    /* Setup Raw HID Report Endpoints */
+    ConfigSuccess &= ENDPOINT_CONFIG(RAW_IN_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_IN,
+                                                                         RAW_EPSIZE, ENDPOINT_BANK_SINGLE);
+    ConfigSuccess &= ENDPOINT_CONFIG(RAW_OUT_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_OUT,
+                                                                         RAW_EPSIZE, ENDPOINT_BANK_SINGLE);
+#endif
+
 #ifdef CONSOLE_ENABLE
     /* Setup Console HID Report Endpoints */
     ConfigSuccess &= ENDPOINT_CONFIG(CONSOLE_IN_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_IN,
@@ -485,7 +591,6 @@ void EVENT_USB_Device_ControlRequest(void)
 
 /*******************************************************************************
  * Host driver
-p
  ******************************************************************************/
 static uint8_t keyboard_leds(void)
 {
@@ -494,18 +599,25 @@ static uint8_t keyboard_leds(void)
 
 static void send_keyboard(report_keyboard_t *report)
 {
+    uint8_t timeout = 255;
+    uint8_t where = where_to_send();
 
 #ifdef BLUETOOTH_ENABLE
-    bluefruit_serial_send(0xFD);
-    for (uint8_t i = 0; i < KEYBOARD_EPSIZE; i++) {
+  if (where == OUTPUT_BLUETOOTH || where == OUTPUT_USB_AND_BT) {
+    #ifdef MODULE_ADAFRUIT_BLE
+      adafruit_ble_send_keys(report->mods, report->keys, sizeof(report->keys));
+    #else
+      bluefruit_serial_send(0xFD);
+      for (uint8_t i = 0; i < KEYBOARD_EPSIZE; i++) {
         bluefruit_serial_send(report->raw[i]);
-    }
+      }
+    #endif
+  }
 #endif
 
-    uint8_t timeout = 255;
-
-    if (USB_DeviceState != DEVICE_STATE_Configured)
-        return;
+    if (where != OUTPUT_USB && where != OUTPUT_USB_AND_BT) {
+      return;
+    }
 
     /* Select the Keyboard Report Endpoint */
 #ifdef NKRO_ENABLE
@@ -543,23 +655,31 @@ static void send_keyboard(report_keyboard_t *report)
 static void send_mouse(report_mouse_t *report)
 {
 #ifdef MOUSE_ENABLE
+    uint8_t timeout = 255;
+    uint8_t where = where_to_send();
 
 #ifdef BLUETOOTH_ENABLE
-    bluefruit_serial_send(0xFD);
-    bluefruit_serial_send(0x00);
-    bluefruit_serial_send(0x03);
-    bluefruit_serial_send(report->buttons);
-    bluefruit_serial_send(report->x);
-    bluefruit_serial_send(report->y);
-    bluefruit_serial_send(report->v); // should try sending the wheel v here
-    bluefruit_serial_send(report->h); // should try sending the wheel h here
-    bluefruit_serial_send(0x00);
+  if (where == OUTPUT_BLUETOOTH || where == OUTPUT_USB_AND_BT) {
+    #ifdef MODULE_ADAFRUIT_BLE
+      // FIXME: mouse buttons
+      adafruit_ble_send_mouse_move(report->x, report->y, report->v, report->h);
+    #else
+      bluefruit_serial_send(0xFD);
+      bluefruit_serial_send(0x00);
+      bluefruit_serial_send(0x03);
+      bluefruit_serial_send(report->buttons);
+      bluefruit_serial_send(report->x);
+      bluefruit_serial_send(report->y);
+      bluefruit_serial_send(report->v); // should try sending the wheel v here
+      bluefruit_serial_send(report->h); // should try sending the wheel h here
+      bluefruit_serial_send(0x00);
+    #endif
+  }
 #endif
 
-    uint8_t timeout = 255;
-
-    if (USB_DeviceState != DEVICE_STATE_Configured)
-        return;
+    if (where != OUTPUT_USB && where != OUTPUT_USB_AND_BT) {
+      return;
+    }
 
     /* Select the Mouse Report Endpoint */
     Endpoint_SelectEndpoint(MOUSE_IN_EPNUM);
@@ -585,7 +705,7 @@ static void send_system(uint16_t data)
 
     report_extra_t r = {
         .report_id = REPORT_ID_SYSTEM,
-        .usage = data
+        .usage = data - SYSTEM_POWER_DOWN + 1
     };
     Endpoint_SelectEndpoint(EXTRAKEY_IN_EPNUM);
 
@@ -599,27 +719,34 @@ static void send_system(uint16_t data)
 
 static void send_consumer(uint16_t data)
 {
+    uint8_t timeout = 255;
+    uint8_t where = where_to_send();
 
 #ifdef BLUETOOTH_ENABLE
-    static uint16_t last_data = 0;
-    if (data == last_data) return;
-    last_data = data;
-    uint16_t bitmap = CONSUMER2BLUEFRUIT(data);
-    bluefruit_serial_send(0xFD);
-    bluefruit_serial_send(0x00);
-    bluefruit_serial_send(0x02);
-    bluefruit_serial_send((bitmap>>8)&0xFF);
-    bluefruit_serial_send(bitmap&0xFF);
-    bluefruit_serial_send(0x00);
-    bluefruit_serial_send(0x00);
-    bluefruit_serial_send(0x00);
-    bluefruit_serial_send(0x00);
+    if (where == OUTPUT_BLUETOOTH || where == OUTPUT_USB_AND_BT) {
+      #ifdef MODULE_ADAFRUIT_BLE
+        adafruit_ble_send_consumer_key(data, 0);
+      #else
+        static uint16_t last_data = 0;
+        if (data == last_data) return;
+        last_data = data;
+        uint16_t bitmap = CONSUMER2BLUEFRUIT(data);
+        bluefruit_serial_send(0xFD);
+        bluefruit_serial_send(0x00);
+        bluefruit_serial_send(0x02);
+        bluefruit_serial_send((bitmap>>8)&0xFF);
+        bluefruit_serial_send(bitmap&0xFF);
+        bluefruit_serial_send(0x00);
+        bluefruit_serial_send(0x00);
+        bluefruit_serial_send(0x00);
+        bluefruit_serial_send(0x00);
+      #endif
+    }
 #endif
 
-    uint8_t timeout = 255;
-
-    if (USB_DeviceState != DEVICE_STATE_Configured)
-        return;
+    if (where != OUTPUT_USB && where != OUTPUT_USB_AND_BT) {
+      return;
+    }
 
     report_extra_t r = {
         .report_id = REPORT_ID_CONSUMER,
@@ -709,7 +836,7 @@ int8_t sendchar(uint8_t c)
  ******************************************************************************/
 
 #ifdef MIDI_ENABLE
-void usb_send_func(MidiDevice * device, uint16_t cnt, uint8_t byte0, uint8_t byte1, uint8_t byte2) {
+static void usb_send_func(MidiDevice * device, uint16_t cnt, uint8_t byte0, uint8_t byte1, uint8_t byte2) {
   MIDI_EventPacket_t event;
   event.Data1 = byte0;
   event.Data2 = byte1;
@@ -769,7 +896,7 @@ void usb_send_func(MidiDevice * device, uint16_t cnt, uint8_t byte0, uint8_t byt
   USB_USBTask();
 }
 
-void usb_get_midi(MidiDevice * device) {
+static void usb_get_midi(MidiDevice * device) {
   MIDI_EventPacket_t event;
   while (MIDI_Device_ReceiveEventPacket(&USB_MIDI_Interface, &event)) {
 
@@ -799,12 +926,12 @@ void usb_get_midi(MidiDevice * device) {
   USB_USBTask();
 }
 
-void midi_usb_init(MidiDevice * device){
+static void midi_usb_init(MidiDevice * device){
   midi_device_init(device);
   midi_device_set_send_func(device, usb_send_func);
   midi_device_set_pre_input_process_func(device, usb_get_midi);
 
-  SetupHardware();
+  // SetupHardware();
   sei();
 }
 
@@ -969,16 +1096,23 @@ void cc_callback(MidiDevice * device,
     uint8_t chan, uint8_t num, uint8_t val);
 void sysex_callback(MidiDevice * device,
     uint16_t start, uint8_t length, uint8_t * data);
+
+void setup_midi(void)
+{
+#ifdef MIDI_ADVANCED
+        midi_init();
+#endif
+        midi_device_init(&midi_device);
+    midi_device_set_send_func(&midi_device, usb_send_func);
+    midi_device_set_pre_input_process_func(&midi_device, usb_get_midi);
+}
 #endif
 
 int main(void)  __attribute__ ((weak));
 int main(void)
 {
-
 #ifdef MIDI_ENABLE
-    midi_device_init(&midi_device);
-    midi_device_set_send_func(&midi_device, usb_send_func);
-    midi_device_set_pre_input_process_func(&midi_device, usb_get_midi);
+    setup_midi();
 #endif
 
     setup_mcu();
@@ -998,7 +1132,7 @@ int main(void)
     // midi_send_noteoff(&midi_device, 0, 64, 127);
 #endif
 
-#ifdef BLUETOOTH_ENABLE
+#ifdef MODULE_ADAFRUIT_EZKEY
     serial_init();
 #endif
 
@@ -1029,7 +1163,7 @@ int main(void)
 
     print("Keyboard start.\n");
     while (1) {
-        #ifndef BLUETOOTH_ENABLE
+        #if !defined(BLUETOOTH_ENABLE)
         while (USB_DeviceState == DEVICE_STATE_Suspended) {
             print("[s]");
             suspend_power_down();
@@ -1039,20 +1173,36 @@ int main(void)
         }
         #endif
 
+        keyboard_task();
+
 #ifdef MIDI_ENABLE
         midi_device_process(&midi_device);
-        // MIDI_Task();
+#ifdef MIDI_ADVANCED
+        midi_task();
+#endif
+#endif
+
+#if defined(RGBLIGHT_ANIMATIONS) & defined(RGBLIGHT_ENABLE)
+        rgblight_task();
+#endif
+
+#ifdef MODULE_ADAFRUIT_BLE
+        adafruit_ble_task();
 #endif
-        keyboard_task();
 
 #ifdef VIRTSER_ENABLE
         virtser_task();
         CDC_Device_USBTask(&cdc_device);
 #endif
 
+#ifdef RAW_ENABLE
+        raw_hid_task();
+#endif
+
 #if !defined(INTERRUPT_CONTROL_ENDPOINT)
         USB_USBTask();
 #endif
+
     }
 }
 
@@ -1077,15 +1227,50 @@ void fallthrough_callback(MidiDevice * device,
 #endif
 }
 
+
 void cc_callback(MidiDevice * device,
     uint8_t chan, uint8_t num, uint8_t val) {
   //sending it back on the next channel
-  midi_send_cc(device, (chan + 1) % 16, num, val);
+  // midi_send_cc(device, (chan + 1) % 16, num, val);
 }
 
-void sysex_callback(MidiDevice * device,
-    uint16_t start, uint8_t length, uint8_t * data) {
-  for (int i = 0; i < length; i++)
-    midi_send_cc(device, 15, 0x7F & data[i], 0x7F & (start + i));
+#ifdef API_SYSEX_ENABLE
+uint8_t midi_buffer[MIDI_SYSEX_BUFFER] = {0};
+#endif
+
+void sysex_callback(MidiDevice * device, uint16_t start, uint8_t length, uint8_t * data) {
+    #ifdef API_SYSEX_ENABLE
+        // SEND_STRING("\n");
+        // send_word(start);
+        // SEND_STRING(": ");
+        // Don't store the header
+        int16_t pos = start - 4;
+        for (uint8_t place = 0; place < length; place++) {
+            // send_byte(*data);
+            if (pos >= 0) {
+                if (*data == 0xF7) {
+                    // SEND_STRING("\nRD: ");
+                    // for (uint8_t i = 0; i < start + place + 1; i++){
+                    //     send_byte(midi_buffer[i]);
+                    // SEND_STRING(" ");
+                    // }
+                    const unsigned decoded_length = sysex_decoded_length(pos);
+                    uint8_t decoded[API_SYSEX_MAX_SIZE];
+                    sysex_decode(decoded, midi_buffer, pos);
+                    process_api(decoded_length, decoded);
+                    return;
+                }
+                else if (pos >= MIDI_SYSEX_BUFFER) {
+                    return;
+                }
+                midi_buffer[pos] = *data;
+            }
+            // SEND_STRING(" ");
+            data++;
+            pos++;
+        }
+    #endif
 }
+
+
 #endif
diff --git a/tmk_core/protocol/lufa/lufa.h b/tmk_core/protocol/lufa/lufa.h
index aad08d640..a51573786 100644
--- a/tmk_core/protocol/lufa/lufa.h
+++ b/tmk_core/protocol/lufa/lufa.h
@@ -49,7 +49,7 @@
 #include <LUFA/Drivers/USB/USB.h>
 #include "host.h"
 #ifdef MIDI_ENABLE
-  #include "midi.h"
+  #include "process_midi.h"
 #endif
 #ifdef __cplusplus
 extern "C" {
@@ -68,8 +68,19 @@ typedef struct {
 } __attribute__ ((packed)) report_extra_t;
 
 #ifdef MIDI_ENABLE
-void MIDI_Task(void);
-MidiDevice midi_device;
+  void MIDI_Task(void);
+  MidiDevice midi_device;
+#endif
+
+#ifdef API_ENABLE
+  #include "api.h"
+#endif
+
+#ifdef API_SYSEX_ENABLE
+  #include "api_sysex.h"
+  // Allocate space for encoding overhead.
+  //The header and terminator are not stored to save a few bytes of precious ram
+  #define MIDI_SYSEX_BUFFER (API_SYSEX_MAX_SIZE + API_SYSEX_MAX_SIZE / 7 + (API_SYSEX_MAX_SIZE % 7 ? 1 : 0))
 #endif
 
 // #if LUFA_VERSION_INTEGER < 0x120730
diff --git a/tmk_core/protocol/lufa/outputselect.c b/tmk_core/protocol/lufa/outputselect.c
new file mode 100644
index 000000000..0df5d3b75
--- /dev/null
+++ b/tmk_core/protocol/lufa/outputselect.c
@@ -0,0 +1,56 @@
+/*
+Copyright 2017 Priyadi Iman Nurcahyo
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "lufa.h"
+#include "outputselect.h"
+#ifdef MODULE_ADAFRUIT_BLE
+    #include "adafruit_ble.h"
+#endif
+
+uint8_t desired_output = OUTPUT_DEFAULT;
+
+void set_output(uint8_t output) {
+    set_output_user(output);
+    desired_output = output;
+}
+
+__attribute__((weak))
+void set_output_user(uint8_t output) {
+}
+
+uint8_t auto_detect_output(void) {
+    if (USB_DeviceState == DEVICE_STATE_Configured) {
+        return OUTPUT_USB;
+    }
+
+#ifdef MODULE_ADAFRUIT_BLE
+    if (adafruit_ble_is_connected()) {
+        return OUTPUT_BLUETOOTH;
+    }
+#endif
+
+#ifdef BLUETOOTH_ENABLE
+    return OUTPUT_BLUETOOTH; // should check if BT is connected here
+#endif
+
+    return OUTPUT_NONE;
+}
+
+uint8_t where_to_send(void) {
+    if (desired_output == OUTPUT_AUTO) {
+        return auto_detect_output();
+    }
+    return desired_output;
+}
+
diff --git a/tmk_core/protocol/lufa/outputselect.h b/tmk_core/protocol/lufa/outputselect.h
new file mode 100644
index 000000000..28cc3298e
--- /dev/null
+++ b/tmk_core/protocol/lufa/outputselect.h
@@ -0,0 +1,40 @@
+/*
+Copyright 2017 Priyadi Iman Nurcahyo
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+enum outputs {
+    OUTPUT_AUTO,
+
+    OUTPUT_NONE,
+    OUTPUT_USB,
+    OUTPUT_BLUETOOTH,
+
+    // backward compatibility
+    OUTPUT_USB_AND_BT
+};
+
+/**
+ * backward compatibility for BLUETOOTH_ENABLE, send to BT and USB by default
+ */
+#ifndef OUTPUT_DEFAULT
+    #ifdef BLUETOOTH_ENABLE
+        #define OUTPUT_DEFAULT OUTPUT_USB_AND_BT
+    #else
+        #define OUTPUT_DEFAULT OUTPUT_AUTO
+    #endif
+#endif
+
+void set_output(uint8_t output);
+void set_output_user(uint8_t output);
+uint8_t auto_detect_output(void);
+uint8_t where_to_send(void);
\ No newline at end of file
diff --git a/tmk_core/protocol/lufa/ringbuffer.hpp b/tmk_core/protocol/lufa/ringbuffer.hpp
new file mode 100644
index 000000000..70a3c4881
--- /dev/null
+++ b/tmk_core/protocol/lufa/ringbuffer.hpp
@@ -0,0 +1,66 @@
+#pragma once
+// A simple ringbuffer holding Size elements of type T
+template <typename T, uint8_t Size>
+class RingBuffer {
+ protected:
+  T buf_[Size];
+  uint8_t head_{0}, tail_{0};
+ public:
+  inline uint8_t nextPosition(uint8_t position) {
+    return (position + 1) % Size;
+  }
+
+  inline uint8_t prevPosition(uint8_t position) {
+    if (position == 0) {
+      return Size - 1;
+    }
+    return position - 1;
+  }
+
+  inline bool enqueue(const T &item) {
+    static_assert(Size > 1, "RingBuffer size must be > 1");
+    uint8_t next = nextPosition(head_);
+    if (next == tail_) {
+      // Full
+      return false;
+    }
+
+    buf_[head_] = item;
+    head_ = next;
+    return true;
+  }
+
+  inline bool get(T &dest, bool commit = true) {
+    auto tail = tail_;
+    if (tail == head_) {
+      // No more data
+      return false;
+    }
+
+    dest = buf_[tail];
+    tail = nextPosition(tail);
+
+    if (commit) {
+      tail_ = tail;
+    }
+    return true;
+  }
+
+  inline bool empty() const { return head_ == tail_; }
+
+  inline uint8_t size() const {
+    int diff = head_ - tail_;
+    if (diff >= 0) {
+      return diff;
+    }
+    return Size + diff;
+  }
+
+  inline T& front() {
+    return buf_[tail_];
+  }
+
+  inline bool peek(T &item) {
+    return get(item, false);
+  }
+};
diff --git a/tmk_core/protocol/midi.mk b/tmk_core/protocol/midi.mk
index c85ae42ff..4855b23d3 100644
--- a/tmk_core/protocol/midi.mk
+++ b/tmk_core/protocol/midi.mk
@@ -4,6 +4,7 @@ SRC += midi.c \
            midi_device.c \
            bytequeue/bytequeue.c \
            bytequeue/interrupt_setting.c \
+           sysex_tools.c \
            $(LUFA_SRC_USBCLASS)
 
 VPATH += $(TMK_PATH)/$(MIDI_DIR)
\ No newline at end of file
diff --git a/tmk_core/protocol/ps2_mouse.c b/tmk_core/protocol/ps2_mouse.c
index c3e8b3c1c..d9ccbecb4 100644
--- a/tmk_core/protocol/ps2_mouse.c
+++ b/tmk_core/protocol/ps2_mouse.c
@@ -18,60 +18,59 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include <stdbool.h>
 #include<avr/io.h>
 #include<util/delay.h>
-#include "ps2.h"
 #include "ps2_mouse.h"
-#include "report.h"
 #include "host.h"
 #include "timer.h"
 #include "print.h"
+#include "report.h"
 #include "debug.h"
+#include "ps2.h"
 
+/* ============================= MACROS ============================ */
 
 static report_mouse_t mouse_report = {};
 
+static inline void ps2_mouse_print_report(report_mouse_t *mouse_report);
+static inline void ps2_mouse_convert_report_to_hid(report_mouse_t *mouse_report);
+static inline void ps2_mouse_clear_report(report_mouse_t *mouse_report);
+static inline void ps2_mouse_enable_scrolling(void);
+static inline void ps2_mouse_scroll_button_task(report_mouse_t *mouse_report);
 
-static void print_usb_data(void);
-
+/* ============================= IMPLEMENTATION ============================ */
 
 /* supports only 3 button mouse at this time */
-uint8_t ps2_mouse_init(void) {
-    uint8_t rcv;
-
+void ps2_mouse_init(void) {
     ps2_host_init();
 
-    _delay_ms(1000);    // wait for powering up
+    _delay_ms(PS2_MOUSE_INIT_DELAY);    // wait for powering up
 
-    // send Reset
-    rcv = ps2_host_send(0xFF);
-    print("ps2_mouse_init: send Reset: ");
-    phex(rcv); phex(ps2_error); print("\n");
+    PS2_MOUSE_SEND(PS2_MOUSE_RESET, "ps2_mouse_init: sending reset");
 
-    // read completion code of BAT
-    rcv = ps2_host_recv_response();
-    print("ps2_mouse_init: read BAT: ");
-    phex(rcv); phex(ps2_error); print("\n");
+    PS2_MOUSE_RECEIVE("ps2_mouse_init: read BAT");
+    PS2_MOUSE_RECEIVE("ps2_mouse_init: read DevID");
 
-    // read Device ID
-    rcv = ps2_host_recv_response();
-    print("ps2_mouse_init: read DevID: ");
-    phex(rcv); phex(ps2_error); print("\n");
+#ifdef PS2_MOUSE_USE_REMOTE_MODE
+    ps2_mouse_set_remote_mode();
+#else
+    ps2_mouse_enable_data_reporting();
+#endif
+
+#ifdef PS2_MOUSE_ENABLE_SCROLLING
+    ps2_mouse_enable_scrolling();
+#endif
 
-    // send Set Remote mode
-    rcv = ps2_host_send(0xF0);
-    print("ps2_mouse_init: send 0xF0: ");
-    phex(rcv); phex(ps2_error); print("\n");
+#ifdef PS2_MOUSE_USE_2_1_SCALING
+    ps2_mouse_set_scaling_2_1();
+#endif
 
-    return 0;
+    ps2_mouse_init_user();
 }
 
-#define X_IS_NEG  (mouse_report.buttons & (1<<PS2_MOUSE_X_SIGN))
-#define Y_IS_NEG  (mouse_report.buttons & (1<<PS2_MOUSE_Y_SIGN))
-#define X_IS_OVF  (mouse_report.buttons & (1<<PS2_MOUSE_X_OVFLW))
-#define Y_IS_OVF  (mouse_report.buttons & (1<<PS2_MOUSE_Y_OVFLW))
-void ps2_mouse_task(void)
-{
-    enum { SCROLL_NONE, SCROLL_BTN, SCROLL_SENT };
-    static uint8_t scroll_state = SCROLL_NONE;
+__attribute__((weak))
+void ps2_mouse_init_user(void) {
+}
+
+void ps2_mouse_task(void) {
     static uint8_t buttons_prev = 0;
 
     /* receives packet from mouse */
@@ -79,142 +78,169 @@ void ps2_mouse_task(void)
     rcv = ps2_host_send(PS2_MOUSE_READ_DATA);
     if (rcv == PS2_ACK) {
         mouse_report.buttons = ps2_host_recv_response();
-        mouse_report.x = ps2_host_recv_response();
-        mouse_report.y = ps2_host_recv_response();
+        mouse_report.x = ps2_host_recv_response() * PS2_MOUSE_X_MULTIPLIER;
+        mouse_report.y = ps2_host_recv_response() * PS2_MOUSE_Y_MULTIPLIER;
+#ifdef PS2_MOUSE_ENABLE_SCROLLING
+        mouse_report.v = -(ps2_host_recv_response() & PS2_MOUSE_SCROLL_MASK) * PS2_MOUSE_V_MULTIPLIER;
+#endif
     } else {
         if (debug_mouse) print("ps2_mouse: fail to get mouse packet\n");
         return;
     }
-        xprintf("%ud ", timer_read());
-        print("ps2_mouse raw: [");
-        phex(mouse_report.buttons); print("|");
-        print_hex8((uint8_t)mouse_report.x); print(" ");
-        print_hex8((uint8_t)mouse_report.y); print("]\n");
 
     /* if mouse moves or buttons state changes */
-    if (mouse_report.x || mouse_report.y ||
+    if (mouse_report.x || mouse_report.y || mouse_report.v ||
             ((mouse_report.buttons ^ buttons_prev) & PS2_MOUSE_BTN_MASK)) {
-
-#ifdef PS2_MOUSE_DEBUG
-        print("ps2_mouse raw: [");
-        phex(mouse_report.buttons); print("|");
-        print_hex8((uint8_t)mouse_report.x); print(" ");
-        print_hex8((uint8_t)mouse_report.y); print("]\n");
+#ifdef PS2_MOUSE_DEBUG_RAW
+        // Used to debug raw ps2 bytes from mouse
+        ps2_mouse_print_report(&mouse_report);
 #endif
-
         buttons_prev = mouse_report.buttons;
+        ps2_mouse_convert_report_to_hid(&mouse_report);
+#if PS2_MOUSE_SCROLL_BTN_MASK
+        ps2_mouse_scroll_button_task(&mouse_report);
+#endif
+#ifdef PS2_MOUSE_DEBUG_HID
+        // Used to debug the bytes sent to the host
+        ps2_mouse_print_report(&mouse_report);
+#endif
+        host_mouse_send(&mouse_report);
+    }
+    
+    ps2_mouse_clear_report(&mouse_report);
+}
 
-        // PS/2 mouse data is '9-bit integer'(-256 to 255) which is comprised of sign-bit and 8-bit value.
-        // bit: 8    7 ... 0
-        //      sign \8-bit/
-        //
-        // Meanwhile USB HID mouse indicates 8bit data(-127 to 127), note that -128 is not used.
-        //
-        // This converts PS/2 data into HID value. Use only -127-127 out of PS/2 9-bit.
-        mouse_report.x = X_IS_NEG ?
-                          ((!X_IS_OVF && -127 <= mouse_report.x && mouse_report.x <= -1) ?  mouse_report.x : -127) :
-                          ((!X_IS_OVF && 0 <= mouse_report.x && mouse_report.x <= 127) ? mouse_report.x : 127);
-        mouse_report.y = Y_IS_NEG ?
-                          ((!Y_IS_OVF && -127 <= mouse_report.y && mouse_report.y <= -1) ?  mouse_report.y : -127) :
-                          ((!Y_IS_OVF && 0 <= mouse_report.y && mouse_report.y <= 127) ? mouse_report.y : 127);
+void ps2_mouse_disable_data_reporting(void) {
+    PS2_MOUSE_SEND(PS2_MOUSE_DISABLE_DATA_REPORTING, "ps2 mouse disable data reporting"); 
+}
 
-        // remove sign and overflow flags
-        mouse_report.buttons &= PS2_MOUSE_BTN_MASK;
+void ps2_mouse_enable_data_reporting(void) {
+    PS2_MOUSE_SEND(PS2_MOUSE_ENABLE_DATA_REPORTING, "ps2 mouse enable data reporting");
+}
 
-        // invert coordinate of y to conform to USB HID mouse
-        mouse_report.y = -mouse_report.y;
+void ps2_mouse_set_remote_mode(void) { 
+    PS2_MOUSE_SEND_SAFE(PS2_MOUSE_SET_REMOTE_MODE, "ps2 mouse set remote mode"); 
+    ps2_mouse_mode = PS2_MOUSE_REMOTE_MODE;
+}
 
+void ps2_mouse_set_stream_mode(void) { 
+    PS2_MOUSE_SEND_SAFE(PS2_MOUSE_SET_STREAM_MODE, "ps2 mouse set stream mode"); 
+    ps2_mouse_mode = PS2_MOUSE_STREAM_MODE;
+}
 
-#if PS2_MOUSE_SCROLL_BTN_MASK
-        static uint16_t scroll_button_time = 0;
-        if ((mouse_report.buttons & (PS2_MOUSE_SCROLL_BTN_MASK)) == (PS2_MOUSE_SCROLL_BTN_MASK)) {
-            if (scroll_state == SCROLL_NONE) {
-                scroll_button_time = timer_read();
-                scroll_state = SCROLL_BTN;
-            }
-
-            // doesn't send Scroll Button
-            //mouse_report.buttons &= ~(PS2_MOUSE_SCROLL_BTN_MASK);
-
-            if (mouse_report.x || mouse_report.y) {
-                scroll_state = SCROLL_SENT;
-
-                mouse_report.v = -mouse_report.y/(PS2_MOUSE_SCROLL_DIVISOR_V);
-                mouse_report.h =  mouse_report.x/(PS2_MOUSE_SCROLL_DIVISOR_H);
-                mouse_report.x = 0;
-                mouse_report.y = 0;
-                //host_mouse_send(&mouse_report);
-            }
+void ps2_mouse_set_scaling_2_1(void) {
+    PS2_MOUSE_SEND_SAFE(PS2_MOUSE_SET_SCALING_2_1, "ps2 mouse set scaling 2:1"); 
+}
+
+void ps2_mouse_set_scaling_1_1(void) {
+    PS2_MOUSE_SEND_SAFE(PS2_MOUSE_SET_SCALING_1_1, "ps2 mouse set scaling 1:1"); 
+}
+
+void ps2_mouse_set_resolution(ps2_mouse_resolution_t resolution) {
+    PS2_MOUSE_SET_SAFE(PS2_MOUSE_SET_RESOLUTION, resolution, "ps2 mouse set resolution");
+}
+
+void ps2_mouse_set_sample_rate(ps2_mouse_sample_rate_t sample_rate) {
+    PS2_MOUSE_SET_SAFE(PS2_MOUSE_SET_SAMPLE_RATE, sample_rate, "ps2 mouse set sample rate");
+}
+
+/* ============================= HELPERS ============================ */
+
+#define X_IS_NEG  (mouse_report->buttons & (1<<PS2_MOUSE_X_SIGN))
+#define Y_IS_NEG  (mouse_report->buttons & (1<<PS2_MOUSE_Y_SIGN))
+#define X_IS_OVF  (mouse_report->buttons & (1<<PS2_MOUSE_X_OVFLW))
+#define Y_IS_OVF  (mouse_report->buttons & (1<<PS2_MOUSE_Y_OVFLW))
+static inline void ps2_mouse_convert_report_to_hid(report_mouse_t *mouse_report) {
+    // PS/2 mouse data is '9-bit integer'(-256 to 255) which is comprised of sign-bit and 8-bit value.
+    // bit: 8    7 ... 0
+    //      sign \8-bit/
+    //
+    // Meanwhile USB HID mouse indicates 8bit data(-127 to 127), note that -128 is not used.
+    //
+    // This converts PS/2 data into HID value. Use only -127-127 out of PS/2 9-bit.
+    mouse_report->x = X_IS_NEG ?
+        ((!X_IS_OVF && -127 <= mouse_report->x && mouse_report->x <= -1) ?  mouse_report->x : -127) :
+        ((!X_IS_OVF && 0 <= mouse_report->x && mouse_report->x <= 127) ? mouse_report->x : 127);
+    mouse_report->y = Y_IS_NEG ?
+        ((!Y_IS_OVF && -127 <= mouse_report->y && mouse_report->y <= -1) ?  mouse_report->y : -127) :
+        ((!Y_IS_OVF && 0 <= mouse_report->y && mouse_report->y <= 127) ? mouse_report->y : 127);
+
+    // remove sign and overflow flags
+    mouse_report->buttons &= PS2_MOUSE_BTN_MASK;
+
+    // invert coordinate of y to conform to USB HID mouse
+    mouse_report->y = -mouse_report->y;
+}
+
+static inline void ps2_mouse_clear_report(report_mouse_t *mouse_report) {
+    mouse_report->x = 0;
+    mouse_report->y = 0;
+    mouse_report->v = 0;
+    mouse_report->h = 0;
+    mouse_report->buttons = 0;
+}
+
+static inline void ps2_mouse_print_report(report_mouse_t *mouse_report) {
+    if (!debug_mouse) return;
+    print("ps2_mouse: [");
+    phex(mouse_report->buttons); print("|");
+    print_hex8((uint8_t)mouse_report->x); print(" ");
+    print_hex8((uint8_t)mouse_report->y); print(" ");
+    print_hex8((uint8_t)mouse_report->v); print(" ");
+    print_hex8((uint8_t)mouse_report->h); print("]\n");
+}
+
+static inline void ps2_mouse_enable_scrolling(void) {
+    PS2_MOUSE_SEND(PS2_MOUSE_SET_SAMPLE_RATE, "Initiaing scroll wheel enable: Set sample rate");
+    PS2_MOUSE_SEND(200, "200");
+    PS2_MOUSE_SEND(PS2_MOUSE_SET_SAMPLE_RATE, "Set sample rate");
+    PS2_MOUSE_SEND(100, "100");
+    PS2_MOUSE_SEND(PS2_MOUSE_SET_SAMPLE_RATE, "Set sample rate");
+    PS2_MOUSE_SEND(80, "80");
+    PS2_MOUSE_SEND(PS2_MOUSE_GET_DEVICE_ID, "Finished enabling scroll wheel");
+    _delay_ms(20);
+}
+
+#define PRESS_SCROLL_BUTTONS    mouse_report->buttons |= (PS2_MOUSE_SCROLL_BTN_MASK)
+#define RELEASE_SCROLL_BUTTONS  mouse_report->buttons &= ~(PS2_MOUSE_SCROLL_BTN_MASK)
+static inline void ps2_mouse_scroll_button_task(report_mouse_t *mouse_report) {
+    static enum { 
+        SCROLL_NONE, 
+        SCROLL_BTN, 
+        SCROLL_SENT,
+    } scroll_state = SCROLL_NONE;
+    static uint16_t scroll_button_time = 0;
+
+    if (PS2_MOUSE_SCROLL_BTN_MASK == (mouse_report->buttons & (PS2_MOUSE_SCROLL_BTN_MASK))) {
+        // All scroll buttons are pressed
+
+        if (scroll_state == SCROLL_NONE) {
+            scroll_button_time = timer_read();
+            scroll_state = SCROLL_BTN;
         }
-        else if ((mouse_report.buttons & (PS2_MOUSE_SCROLL_BTN_MASK)) == 0) {
+
+        // If the mouse has moved, update the report to scroll instead of move the mouse
+        if (mouse_report->x || mouse_report->y) {
+            scroll_state = SCROLL_SENT;
+            mouse_report->v = -mouse_report->y/(PS2_MOUSE_SCROLL_DIVISOR_V);
+            mouse_report->h =  mouse_report->x/(PS2_MOUSE_SCROLL_DIVISOR_H);
+            mouse_report->x = 0;
+            mouse_report->y = 0;
+        }
+    } else if (0 == (PS2_MOUSE_SCROLL_BTN_MASK & mouse_report->buttons)) {
+        // None of the scroll buttons are pressed 
+
 #if PS2_MOUSE_SCROLL_BTN_SEND
-            if (scroll_state == SCROLL_BTN &&
-                    TIMER_DIFF_16(timer_read(), scroll_button_time) < PS2_MOUSE_SCROLL_BTN_SEND) {
-                // send Scroll Button(down and up at once) when not scrolled
-                mouse_report.buttons |= (PS2_MOUSE_SCROLL_BTN_MASK);
-                host_mouse_send(&mouse_report);
-                _delay_ms(100);
-                mouse_report.buttons &= ~(PS2_MOUSE_SCROLL_BTN_MASK);
-            }
-#endif
-            scroll_state = SCROLL_NONE;
+        if (scroll_state == SCROLL_BTN 
+                && timer_elapsed(scroll_button_time) < PS2_MOUSE_SCROLL_BTN_SEND) {
+            PRESS_SCROLL_BUTTONS;
+            host_mouse_send(mouse_report);
+            _delay_ms(100);
+            RELEASE_SCROLL_BUTTONS;
         }
-        // doesn't send Scroll Button
-        mouse_report.buttons &= ~(PS2_MOUSE_SCROLL_BTN_MASK);
 #endif
-
-
-        host_mouse_send(&mouse_report);
-        print_usb_data();
+        scroll_state = SCROLL_NONE;
     }
-    // clear report
-    mouse_report.x = 0;
-    mouse_report.y = 0;
-    mouse_report.v = 0;
-    mouse_report.h = 0;
-    mouse_report.buttons = 0;
-}
 
-static void print_usb_data(void)
-{
-    if (!debug_mouse) return;
-    print("ps2_mouse usb: [");
-    phex(mouse_report.buttons); print("|");
-    print_hex8((uint8_t)mouse_report.x); print(" ");
-    print_hex8((uint8_t)mouse_report.y); print(" ");
-    print_hex8((uint8_t)mouse_report.v); print(" ");
-    print_hex8((uint8_t)mouse_report.h); print("]\n");
-}
-
-
-/* PS/2 Mouse Synopsis
- * http://www.computer-engineering.org/ps2mouse/
- *
- * Command:
- * 0xFF: Reset
- * 0xF6: Set Defaults Sampling; rate=100, resolution=4cnt/mm, scaling=1:1, reporting=disabled
- * 0xF5: Disable Data Reporting
- * 0xF4: Enable Data Reporting
- * 0xF3: Set Sample Rate
- * 0xF2: Get Device ID
- * 0xF0: Set Remote Mode
- * 0xEB: Read Data
- * 0xEA: Set Stream Mode
- * 0xE9: Status Request
- * 0xE8: Set Resolution
- * 0xE7: Set Scaling 2:1
- * 0xE6: Set Scaling 1:1
- *
- * Mode:
- * Stream Mode: devices sends the data when it changs its state
- * Remote Mode: host polls the data periodically
- *
- * This code uses Remote Mode and polls the data with Read Data(0xEB).
- *
- * Data format:
- * byte|7       6       5       4       3       2       1       0
- * ----+--------------------------------------------------------------
- *    0|Yovflw  Xovflw  Ysign   Xsign   1       Middle  Right   Left
- *    1|                    X movement
- *    2|                    Y movement
- */
+    RELEASE_SCROLL_BUTTONS;
+}
diff --git a/tmk_core/protocol/ps2_mouse.h b/tmk_core/protocol/ps2_mouse.h
index 27d9790d4..eeeffe4d8 100644
--- a/tmk_core/protocol/ps2_mouse.h
+++ b/tmk_core/protocol/ps2_mouse.h
@@ -19,16 +19,62 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define  PS2_MOUSE_H
 
 #include <stdbool.h>
+#include "debug.h"
 
-#define PS2_MOUSE_READ_DATA     0xEB
+#define PS2_MOUSE_SEND(command, message) \
+do { \
+   __attribute__ ((unused)) uint8_t rcv = ps2_host_send(command); \
+   if (debug_mouse) { \
+        print((message)); \
+        xprintf(" command: %X, result: %X, error: %X \n", command, rcv, ps2_error); \
+    } \
+} while(0)
+
+#define PS2_MOUSE_SEND_SAFE(command, message) \
+do { \
+    if (PS2_MOUSE_STREAM_MODE == ps2_mouse_mode) { \
+        ps2_mouse_disable_data_reporting(); \
+    } \
+    PS2_MOUSE_SEND(command, message); \
+    if (PS2_MOUSE_STREAM_MODE == ps2_mouse_mode) { \
+        ps2_mouse_enable_data_reporting(); \
+    } \
+} while(0)
+
+#define PS2_MOUSE_SET_SAFE(command, value, message) \
+do { \
+    if (PS2_MOUSE_STREAM_MODE == ps2_mouse_mode) { \
+        ps2_mouse_disable_data_reporting(); \
+    } \
+    PS2_MOUSE_SEND(command, message); \
+    PS2_MOUSE_SEND(value, "Sending value"); \
+    if (PS2_MOUSE_STREAM_MODE == ps2_mouse_mode) { \
+        ps2_mouse_enable_data_reporting(); \
+    } \
+} while(0)
+
+#define PS2_MOUSE_RECEIVE(message) \
+do { \
+   __attribute__ ((unused)) uint8_t rcv = ps2_host_recv_response(); \
+   if (debug_mouse) { \
+        print((message)); \
+        xprintf(" result: %X, error: %X \n", rcv, ps2_error); \
+    } \
+} while(0)
+
+__attribute__ ((unused))
+static enum ps2_mouse_mode_e {
+    PS2_MOUSE_STREAM_MODE,
+    PS2_MOUSE_REMOTE_MODE,
+} ps2_mouse_mode = PS2_MOUSE_STREAM_MODE;
 
 /*
  * Data format:
  * byte|7       6       5       4       3       2       1       0
- * ----+--------------------------------------------------------------
- *    0|Yovflw  Xovflw  Ysign   Xsign   1       Middle  Right   Left
- *    1|                    X movement(0-255)
- *    2|                    Y movement(0-255)
+ * ----+----------------------------------------------------------------
+ *    0|[Yovflw][Xovflw][Ysign ][Xsign ][ 1    ][Middle][Right ][Left  ]
+ *    1|[                    X movement(0-255)                         ]
+ *    2|[                    Y movement(0-255)                         ]
  */
 #define PS2_MOUSE_BTN_MASK      0x07
 #define PS2_MOUSE_BTN_LEFT      0
@@ -39,10 +85,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define PS2_MOUSE_X_OVFLW       6
 #define PS2_MOUSE_Y_OVFLW       7
 
-
-/*
- * Scroll by mouse move with pressing button
- */
 /* mouse button to start scrolling; set 0 to disable scroll */
 #ifndef PS2_MOUSE_SCROLL_BTN_MASK
 #define PS2_MOUSE_SCROLL_BTN_MASK       (1<<PS2_MOUSE_BTN_MIDDLE)
@@ -58,9 +100,79 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #ifndef PS2_MOUSE_SCROLL_DIVISOR_H
 #define PS2_MOUSE_SCROLL_DIVISOR_H      2
 #endif
+/* multiply reported mouse values by these */
+#ifndef PS2_MOUSE_X_MULTIPLIER
+#define PS2_MOUSE_X_MULTIPLIER          1
+#endif
+#ifndef PS2_MOUSE_Y_MULTIPLIER
+#define PS2_MOUSE_Y_MULTIPLIER          1
+#endif
+#ifndef PS2_MOUSE_V_MULTIPLIER
+#define PS2_MOUSE_V_MULTIPLIER          1
+#endif
+/* For some mice this will need to be 0x0F */
+#ifndef PS2_MOUSE_SCROLL_MASK       
+#define PS2_MOUSE_SCROLL_MASK           0xFF 
+#endif
+#ifndef PS2_MOUSE_INIT_DELAY
+#define PS2_MOUSE_INIT_DELAY            1000
+#endif
 
+enum ps2_mouse_command_e {
+    PS2_MOUSE_RESET = 0xFF,
+    PS2_MOUSE_RESEND = 0xFE,
+    PS2_MOSUE_SET_DEFAULTS = 0xF6,
+    PS2_MOUSE_DISABLE_DATA_REPORTING = 0xF5,
+    PS2_MOUSE_ENABLE_DATA_REPORTING = 0xF4,
+    PS2_MOUSE_SET_SAMPLE_RATE = 0xF3,
+    PS2_MOUSE_GET_DEVICE_ID = 0xF2,
+    PS2_MOUSE_SET_REMOTE_MODE = 0xF0,
+    PS2_MOUSE_SET_WRAP_MODE = 0xEC,
+    PS2_MOUSE_READ_DATA = 0xEB,
+    PS2_MOUSE_SET_STREAM_MODE = 0xEA,
+    PS2_MOUSE_STATUS_REQUEST = 0xE9,
+    PS2_MOUSE_SET_RESOLUTION = 0xE8,
+    PS2_MOUSE_SET_SCALING_2_1 = 0xE7,
+    PS2_MOUSE_SET_SCALING_1_1 = 0xE6,
+};
+
+typedef enum ps2_mouse_resolution_e {
+    PS2_MOUSE_1_COUNT_MM,
+    PS2_MOUSE_2_COUNT_MM,
+    PS2_MOUSE_4_COUNT_MM,
+    PS2_MOUSE_8_COUNT_MM,   
+} ps2_mouse_resolution_t;
+
+typedef enum ps2_mouse_sample_rate_e {
+    PS2_MOUSE_10_SAMPLES_SEC = 10,
+    PS2_MOUSE_20_SAMPLES_SEC = 20,
+    PS2_MOUSE_40_SAMPLES_SEC = 40,
+    PS2_MOUSE_60_SAMPLES_SEC = 60,
+    PS2_MOUSE_80_SAMPLES_SEC = 80,
+    PS2_MOUSE_100_SAMPLES_SEC = 100,
+    PS2_MOUSE_200_SAMPLES_SEC = 200,
+} ps2_mouse_sample_rate_t;
+
+void ps2_mouse_init(void);
+
+void ps2_mouse_init_user(void);
 
-uint8_t ps2_mouse_init(void);
 void ps2_mouse_task(void);
 
+void ps2_mouse_disable_data_reporting(void);
+
+void ps2_mouse_enable_data_reporting(void);
+
+void ps2_mouse_set_remote_mode(void);
+
+void ps2_mouse_set_stream_mode(void);
+
+void ps2_mouse_set_scaling_2_1(void);
+
+void ps2_mouse_set_scaling_1_1(void);
+
+void ps2_mouse_set_resolution(ps2_mouse_resolution_t resolution);
+
+void ps2_mouse_set_sample_rate(ps2_mouse_sample_rate_t sample_rate);
+
 #endif
diff --git a/tmk_core/protocol/vusb.mk b/tmk_core/protocol/vusb.mk
index 3cba3f71a..897b833e1 100644
--- a/tmk_core/protocol/vusb.mk
+++ b/tmk_core/protocol/vusb.mk
@@ -18,4 +18,5 @@ endif
 
 
 # Search Path
-VPATH += $(TMK_DIR)/protocol/vusb:$(TMK_DIR)/protocol/vusb/usbdrv
+VPATH += $(TMK_PATH)/$(VUSB_DIR)
+VPATH += $(TMK_PATH)/$(VUSB_DIR)/usbdrv
diff --git a/tmk_core/protocol/vusb/main.c b/tmk_core/protocol/vusb/main.c
index 8e4a266e9..f6a0c7e9a 100644
--- a/tmk_core/protocol/vusb/main.c
+++ b/tmk_core/protocol/vusb/main.c
@@ -48,8 +48,12 @@ int main(void)
     uint16_t last_timer = timer_read();
 #endif
 
+#ifdef CLKPR
+    // avoid unintentional changes of clock frequency in devices that have a
+    // clock prescaler
     CLKPR = 0x80, CLKPR = 0;
-#ifndef PS2_USE_USART
+#endif
+#ifndef NO_UART
     uart_init(UART_BAUD_RATE);
 #endif
 
diff --git a/tmk_core/protocol/vusb/vusb.c b/tmk_core/protocol/vusb/vusb.c
index eaa1c512d..022ac6f6b 100644
--- a/tmk_core/protocol/vusb/vusb.c
+++ b/tmk_core/protocol/vusb/vusb.c
@@ -15,6 +15,8 @@ You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
+#include <avr/eeprom.h>
+#include <avr/wdt.h>
 #include <stdint.h>
 #include "usbdrv.h"
 #include "usbconfig.h"
@@ -24,6 +26,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include "debug.h"
 #include "host_driver.h"
 #include "vusb.h"
+#include "bootloader.h"
 
 
 static uint8_t vusb_keyboard_leds = 0;
@@ -163,6 +166,7 @@ static struct {
     uint16_t        len;
     enum {
         NONE,
+        BOOTLOADER,
         SET_LED
     }               kind;
 } last_req;
@@ -193,6 +197,11 @@ usbRequest_t    *rq = (void *)data;
                 debug("SET_LED: ");
                 last_req.kind = SET_LED;
                 last_req.len = rq->wLength.word;
+#ifdef BOOTLOADER_SIZE
+            } else if(rq->wValue.word == 0x0301) {
+                last_req.kind = BOOTLOADER;
+                last_req.len = rq->wLength.word;
+#endif
             }
             return USB_NO_MSG; // to get data in usbFunctionWrite
         } else {
@@ -220,6 +229,11 @@ uchar usbFunctionWrite(uchar *data, uchar len)
             last_req.len = 0;
             return 1;
             break;
+        case BOOTLOADER:
+            usbDeviceDisconnect();
+            bootloader_jump();
+            return 1;
+            break;
         case NONE:
         default:
             return -1;
@@ -266,7 +280,7 @@ const PROGMEM uchar keyboard_hid_report[] = {
     0x95, 0x06,          //   Report Count (6),
     0x75, 0x08,          //   Report Size (8),
     0x15, 0x00,          //   Logical Minimum (0),
-    0x25, 0xFF, 0x00     //   Logical Maximum(255),
+    0x26, 0xFF, 0x00,    //   Logical Maximum(255),
     0x05, 0x07,          //   Usage Page (Key Codes),
     0x19, 0x00,          //   Usage Minimum (0),
     0x29, 0xFF,          //   Usage Maximum (255),
@@ -336,7 +350,7 @@ const PROGMEM uchar mouse_hid_report[] = {
     0xa1, 0x01,                    // COLLECTION (Application)
     0x85, REPORT_ID_SYSTEM,        //   REPORT_ID (2)
     0x15, 0x01,                    //   LOGICAL_MINIMUM (0x1)
-    0x25, 0xb7, 0x00               //   LOGICAL_MAXIMUM (0xb7)
+    0x26, 0xb7, 0x00,              //   LOGICAL_MAXIMUM (0xb7)
     0x19, 0x01,                    //   USAGE_MINIMUM (0x1)
     0x29, 0xb7,                    //   USAGE_MAXIMUM (0xb7)
     0x75, 0x10,                    //   REPORT_SIZE (16)
@@ -481,11 +495,11 @@ USB_PUBLIC usbMsgLen_t usbFunctionDescriptor(struct usbRequest *rq)
             /* interface index */
             switch (rq->wIndex.word) {
                 case 0:
-                    usbMsgPtr = keyboard_hid_report;
+                    usbMsgPtr = (unsigned char *)keyboard_hid_report;
                     len = sizeof(keyboard_hid_report);
                     break;
                 case 1:
-                    usbMsgPtr = mouse_hid_report;
+                    usbMsgPtr = (unsigned char *)mouse_hid_report;
                     len = sizeof(mouse_hid_report);
                     break;
             }
diff --git a/tmk_core/ring_buffer.h b/tmk_core/ring_buffer.h
index 7bdebbcf3..005d1be61 100644
--- a/tmk_core/ring_buffer.h
+++ b/tmk_core/ring_buffer.h
@@ -4,13 +4,13 @@
  * Ring buffer to store scan codes from keyboard
  *------------------------------------------------------------------*/
 #define RBUF_SIZE 32
+#include <util/atomic.h>
 static uint8_t rbuf[RBUF_SIZE];
 static uint8_t rbuf_head = 0;
 static uint8_t rbuf_tail = 0;
 static inline void rbuf_enqueue(uint8_t data)
 {
-    uint8_t sreg = SREG;
-    cli();
+  ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
     uint8_t next = (rbuf_head + 1) % RBUF_SIZE;
     if (next != rbuf_tail) {
         rbuf[rbuf_head] = data;
@@ -18,36 +18,34 @@ static inline void rbuf_enqueue(uint8_t data)
     } else {
         print("rbuf: full\n");
     }
-    SREG = sreg;
+  }
 }
 static inline uint8_t rbuf_dequeue(void)
 {
     uint8_t val = 0;
+  ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
 
-    uint8_t sreg = SREG;
-    cli();
     if (rbuf_head != rbuf_tail) {
         val = rbuf[rbuf_tail];
         rbuf_tail = (rbuf_tail + 1) % RBUF_SIZE;
     }
-    SREG = sreg;
+  }
 
     return val;
 }
 static inline bool rbuf_has_data(void)
 {
-    uint8_t sreg = SREG;
-    cli();
-    bool has_data = (rbuf_head != rbuf_tail);
-    SREG = sreg;
-    return has_data;
+  bool has_data;
+  ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
+    has_data = (rbuf_head != rbuf_tail);
+  }
+  return has_data;
 }
 static inline void rbuf_clear(void)
 {
-    uint8_t sreg = SREG;
-    cli();
+  ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
     rbuf_head = rbuf_tail = 0;
-    SREG = sreg;
+  }
 }
 
 #endif  /* RING_BUFFER_H */