Merge remote-tracking branch 'upstream/main' into underglow/state-persistence

36 files changed, 2012 insertions, 1535 deletions

diff --git a/app/src/behaviors/behavior_bt.c b/app/src/behaviors/behavior_bt.c
new file mode 100644
index 0000000..09fadba
--- /dev/null
+++ b/app/src/behaviors/behavior_bt.c
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2020 Peter Johanson <peter@peterjohanson.com>
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#define DT_DRV_COMPAT zmk_behavior_bluetooth
+
+#include <device.h>
+#include <drivers/behavior.h>
+
+#include <dt-bindings/zmk/bt.h>
+
+#include <bluetooth/conn.h>
+
+#include <logging/log.h>
+LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
+
+#include <zmk/ble.h>
+
+static int on_keymap_binding_pressed(struct device *dev, u32_t position, u32_t command, u32_t arg) {
+    switch (command) {
+    case BT_CLR_CMD:
+        return zmk_ble_clear_bonds();
+    case BT_NXT_CMD:
+        return zmk_ble_prof_next();
+    case BT_PRV_CMD:
+        return zmk_ble_prof_prev();
+    case BT_SEL_CMD:
+        return zmk_ble_prof_select(arg);
+    default:
+        LOG_ERR("Unknown BT command: %d", command);
+    }
+
+    return -ENOTSUP;
+}
+
+static int behavior_bt_init(struct device *dev) { return 0; };
+
+static int on_keymap_binding_released(struct device *dev, u32_t position, u32_t command,
+                                      u32_t arg) {
+    return 0;
+}
+
+static const struct behavior_driver_api behavior_bt_driver_api = {
+    .binding_pressed = on_keymap_binding_pressed,
+    .binding_released = on_keymap_binding_released,
+};
+
+DEVICE_AND_API_INIT(behavior_bt, DT_INST_LABEL(0), behavior_bt_init, NULL, NULL, APPLICATION,
+                    CONFIG_KERNEL_INIT_PRIORITY_DEFAULT, &behavior_bt_driver_api);
diff --git a/app/src/behaviors/behavior_hold_tap.c b/app/src/behaviors/behavior_hold_tap.c
new file mode 100644
index 0000000..8f307a6
--- /dev/null
+++ b/app/src/behaviors/behavior_hold_tap.c
@@ -0,0 +1,492 @@
+/*
+ * Copyright (c) 2020 The ZMK Contributors
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#define DT_DRV_COMPAT zmk_behavior_hold_tap
+
+#include <device.h>
+#include <drivers/behavior.h>
+#include <logging/log.h>
+#include <zmk/behavior.h>
+
+#include <zmk/matrix.h>
+#include <zmk/endpoints.h>
+#include <zmk/event-manager.h>
+#include <zmk/events/position-state-changed.h>
+#include <zmk/events/keycode-state-changed.h>
+#include <zmk/events/modifiers-state-changed.h>
+#include <zmk/hid.h>
+
+LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
+
+#if DT_NODE_EXISTS(DT_DRV_INST(0))
+
+#define ZMK_BHV_HOLD_TAP_MAX_HELD 10
+#define ZMK_BHV_HOLD_TAP_MAX_CAPTURED_EVENTS 40
+
+// increase if you have keyboard with more keys.
+#define ZMK_BHV_HOLD_TAP_POSITION_NOT_USED 9999
+
+enum flavor {
+    ZMK_BHV_HOLD_TAP_FLAVOR_HOLD_PREFERRED = 0,
+    ZMK_BHV_HOLD_TAP_FLAVOR_BALANCED = 1,
+    ZMK_BHV_HOLD_TAP_FLAVOR_TAP_PREFERRED = 2,
+};
+
+struct behavior_hold_tap_behaviors {
+    struct zmk_behavior_binding tap;
+    struct zmk_behavior_binding hold;
+};
+
+typedef k_timeout_t (*timer_func)();
+
+struct behavior_hold_tap_config {
+    timer_func tapping_term_ms;
+    struct behavior_hold_tap_behaviors *behaviors;
+    enum flavor flavor;
+};
+
+// this data is specific for each hold-tap
+struct active_hold_tap {
+    s32_t position;
+    u32_t param_hold;
+    u32_t param_tap;
+    bool is_decided;
+    bool is_hold;
+    const struct behavior_hold_tap_config *config;
+    struct k_delayed_work work;
+    bool work_is_cancelled;
+};
+
+// The undecided hold tap is the hold tap that needs to be decided before
+// other keypress events can be released. While the undecided_hold_tap is
+// not NULL, most events are captured in captured_events.
+// After the hold_tap is decided, it will stay in the active_hold_taps until
+// its key-up has been processed and the delayed work is cleaned up.
+struct active_hold_tap *undecided_hold_tap = NULL;
+struct active_hold_tap active_hold_taps[ZMK_BHV_HOLD_TAP_MAX_HELD] = {};
+// We capture most position_state_changed events and some modifiers_state_changed events.
+const struct zmk_event_header *captured_events[ZMK_BHV_HOLD_TAP_MAX_CAPTURED_EVENTS] = {};
+
+static int capture_event(const struct zmk_event_header *event) {
+    for (int i = 0; i < ZMK_BHV_HOLD_TAP_MAX_CAPTURED_EVENTS; i++) {
+        if (captured_events[i] == NULL) {
+            captured_events[i] = event;
+            return 0;
+        }
+    }
+    return -ENOMEM;
+}
+
+static struct position_state_changed *find_captured_keydown_event(u32_t position) {
+    struct position_state_changed *last_match = NULL;
+    for (int i = 0; i < ZMK_BHV_HOLD_TAP_MAX_CAPTURED_EVENTS; i++) {
+        const struct zmk_event_header *eh = captured_events[i];
+        if (eh == NULL) {
+            return last_match;
+        }
+        if (!is_position_state_changed(eh)) {
+            continue;
+        }
+        struct position_state_changed *position_event = cast_position_state_changed(eh);
+        if (position_event->position == position && position_event->state) {
+            last_match = position_event;
+        }
+    }
+    return last_match;
+}
+
+const struct zmk_listener zmk_listener_behavior_hold_tap;
+
+static void release_captured_events() {
+    if (undecided_hold_tap != NULL) {
+        return;
+    }
+
+    // We use a trick to prevent copying the captured_events array.
+    //
+    // Events for different mod-tap instances are separated by a NULL pointer.
+    //
+    // The first event popped will never be catched by the next active hold-tap
+    // because to start capturing a mod-tap-key-down event must first completely
+    // go through the events queue.
+    //
+    // Example of this release process;
+    // [mt2_down, k1_down, k1_up, mt2_up, null, ...]
+    //  ^
+    // mt2_down position event isn't captured because no hold-tap is active.
+    // mt2_down behavior event is handled, now we have an undecided hold-tap
+    // [null, k1_down, k1_up, mt2_up, null, ...]
+    //        ^
+    // k1_down  is captured by the mt2 mod-tap
+    // !note that searches for find_captured_keydown_event by the mt2 behavior will stop at the
+    // first null encountered [mt1_down, null, k1_up, mt2_up, null, ...]
+    //                  ^
+    // k1_up event is captured by the new hold-tap:
+    // [k1_down, k1_up, null, mt2_up, null, ...]
+    //                        ^
+    // mt2_up event is not captured but causes release of mt2 behavior
+    // [k1_down, k1_up, null, null, null, ...]
+    // now mt2 will start releasing it's own captured positions.
+    for (int i = 0; i < ZMK_BHV_HOLD_TAP_MAX_CAPTURED_EVENTS; i++) {
+        const struct zmk_event_header *captured_event = captured_events[i];
+        if (captured_event == NULL) {
+            return;
+        }
+        captured_events[i] = NULL;
+        if (undecided_hold_tap != NULL) {
+            k_msleep(10);
+        }
+        if (is_position_state_changed(captured_event)) {
+            struct position_state_changed *position_event =
+                cast_position_state_changed(captured_event);
+            LOG_DBG("Releasing key position event for position %d %s", position_event->position,
+                    (position_event->state ? "pressed" : "released"));
+        } else {
+            struct keycode_state_changed *modifier_event =
+                cast_keycode_state_changed(captured_event);
+            LOG_DBG("Releasing mods changed event 0x%02X %s", modifier_event->keycode,
+                    (modifier_event->state ? "pressed" : "released"));
+        }
+        ZMK_EVENT_RAISE_AT(captured_event, behavior_hold_tap);
+    }
+}
+
+static struct active_hold_tap *find_hold_tap(u32_t position) {
+    for (int i = 0; i < ZMK_BHV_HOLD_TAP_MAX_HELD; i++) {
+        if (active_hold_taps[i].position == position) {
+            return &active_hold_taps[i];
+        }
+    }
+    return NULL;
+}
+
+static struct active_hold_tap *store_hold_tap(u32_t position, u32_t param_hold, u32_t param_tap,
+                                              const struct behavior_hold_tap_config *config) {
+    for (int i = 0; i < ZMK_BHV_HOLD_TAP_MAX_HELD; i++) {
+        if (active_hold_taps[i].position != ZMK_BHV_HOLD_TAP_POSITION_NOT_USED) {
+            continue;
+        }
+        active_hold_taps[i].position = position;
+        active_hold_taps[i].is_decided = false;
+        active_hold_taps[i].is_hold = false;
+        active_hold_taps[i].config = config;
+        active_hold_taps[i].param_hold = param_hold;
+        active_hold_taps[i].param_tap = param_tap;
+        return &active_hold_taps[i];
+    }
+    return NULL;
+}
+
+static void clear_hold_tap(struct active_hold_tap *hold_tap) {
+    hold_tap->position = ZMK_BHV_HOLD_TAP_POSITION_NOT_USED;
+    hold_tap->is_decided = false;
+    hold_tap->is_hold = false;
+    hold_tap->work_is_cancelled = false;
+}
+
+enum decision_moment {
+    HT_KEY_UP = 0,
+    HT_OTHER_KEY_DOWN = 1,
+    HT_OTHER_KEY_UP = 2,
+    HT_TIMER_EVENT = 3,
+};
+
+static void decide_balanced(struct active_hold_tap *hold_tap, enum decision_moment event) {
+    switch (event) {
+    case HT_KEY_UP:
+        hold_tap->is_hold = 0;
+        hold_tap->is_decided = true;
+        break;
+    case HT_OTHER_KEY_UP:
+    case HT_TIMER_EVENT:
+        hold_tap->is_hold = 1;
+        hold_tap->is_decided = true;
+        break;
+    default:
+        return;
+    }
+}
+
+static void decide_tap_preferred(struct active_hold_tap *hold_tap, enum decision_moment event) {
+    switch (event) {
+    case HT_KEY_UP:
+        hold_tap->is_hold = 0;
+        hold_tap->is_decided = true;
+        break;
+    case HT_TIMER_EVENT:
+        hold_tap->is_hold = 1;
+        hold_tap->is_decided = true;
+        break;
+    default:
+        return;
+    }
+}
+
+static void decide_hold_preferred(struct active_hold_tap *hold_tap, enum decision_moment event) {
+    switch (event) {
+    case HT_KEY_UP:
+        hold_tap->is_hold = 0;
+        hold_tap->is_decided = true;
+        break;
+    case HT_OTHER_KEY_DOWN:
+    case HT_TIMER_EVENT:
+        hold_tap->is_hold = 1;
+        hold_tap->is_decided = true;
+        break;
+    default:
+        return;
+    }
+}
+
+static inline char *flavor_str(enum flavor flavor) {
+    switch (flavor) {
+    case ZMK_BHV_HOLD_TAP_FLAVOR_HOLD_PREFERRED:
+        return "hold-preferred";
+    case ZMK_BHV_HOLD_TAP_FLAVOR_BALANCED:
+        return "balanced";
+    case ZMK_BHV_HOLD_TAP_FLAVOR_TAP_PREFERRED:
+        return "tap-preferred";
+    }
+    return "UNKNOWN FLAVOR";
+}
+
+static void decide_hold_tap(struct active_hold_tap *hold_tap, enum decision_moment event) {
+    if (hold_tap->is_decided) {
+        return;
+    }
+
+    if (hold_tap != undecided_hold_tap) {
+        LOG_DBG("ERROR found undecided tap hold that is not the active tap hold");
+        return;
+    }
+
+    switch (hold_tap->config->flavor) {
+    case ZMK_BHV_HOLD_TAP_FLAVOR_HOLD_PREFERRED:
+        decide_hold_preferred(hold_tap, event);
+    case ZMK_BHV_HOLD_TAP_FLAVOR_BALANCED:
+        decide_balanced(hold_tap, event);
+    case ZMK_BHV_HOLD_TAP_FLAVOR_TAP_PREFERRED:
+        decide_tap_preferred(hold_tap, event);
+    }
+
+    if (!hold_tap->is_decided) {
+        return;
+    }
+
+    LOG_DBG("%d decided %s (%s event %d)", hold_tap->position, hold_tap->is_hold ? "hold" : "tap",
+            flavor_str(hold_tap->config->flavor), event);
+    undecided_hold_tap = NULL;
+
+    struct zmk_behavior_binding *behavior;
+    if (hold_tap->is_hold) {
+        behavior = &hold_tap->config->behaviors->hold;
+        struct device *behavior_device = device_get_binding(behavior->behavior_dev);
+        behavior_keymap_binding_pressed(behavior_device, hold_tap->position, hold_tap->param_hold,
+                                        0);
+    } else {
+        behavior = &hold_tap->config->behaviors->tap;
+        struct device *behavior_device = device_get_binding(behavior->behavior_dev);
+        behavior_keymap_binding_pressed(behavior_device, hold_tap->position, hold_tap->param_tap,
+                                        0);
+    }
+    release_captured_events();
+}
+
+static int on_hold_tap_binding_pressed(struct device *dev, u32_t position, u32_t param_hold,
+                                       u32_t param_tap) {
+    const struct behavior_hold_tap_config *cfg = dev->config_info;
+
+    if (undecided_hold_tap != NULL) {
+        LOG_DBG("ERROR another hold-tap behavior is undecided.");
+        // if this happens, make sure the behavior events occur AFTER other position events.
+        return 0;
+    }
+
+    struct active_hold_tap *hold_tap = store_hold_tap(position, param_hold, param_tap, cfg);
+    if (hold_tap == NULL) {
+        LOG_ERR("unable to store hold-tap info, did you press more than %d hold-taps?",
+                ZMK_BHV_HOLD_TAP_MAX_HELD);
+        return 0;
+    }
+
+    LOG_DBG("%d new undecided hold_tap", position);
+    undecided_hold_tap = hold_tap;
+    k_delayed_work_submit(&hold_tap->work, cfg->tapping_term_ms());
+
+    // todo: once we get timing info for keypresses, start the timer relative to the original
+    // keypress don't forget to simulate a timer-event before the event after that time was handled.
+
+    return 0;
+}
+
+static int on_hold_tap_binding_released(struct device *dev, u32_t position, u32_t _, u32_t __) {
+    struct active_hold_tap *hold_tap = find_hold_tap(position);
+
+    if (hold_tap == NULL) {
+        LOG_ERR("ACTIVE_HOLD_TAP_CLEANED_UP_TOO_EARLY");
+        return 0;
+    }
+
+    int work_cancel_result = k_delayed_work_cancel(&hold_tap->work);
+    decide_hold_tap(hold_tap, HT_KEY_UP);
+
+    struct zmk_behavior_binding *behavior;
+    if (hold_tap->is_hold) {
+        behavior = &hold_tap->config->behaviors->hold;
+        struct device *behavior_device = device_get_binding(behavior->behavior_dev);
+        behavior_keymap_binding_released(behavior_device, hold_tap->position, hold_tap->param_hold,
+                                         0);
+    } else {
+        behavior = &hold_tap->config->behaviors->tap;
+        struct device *behavior_device = device_get_binding(behavior->behavior_dev);
+        behavior_keymap_binding_released(behavior_device, hold_tap->position, hold_tap->param_tap,
+                                         0);
+    }
+
+    if (work_cancel_result == -EINPROGRESS) {
+        // let the timer handler clean up
+        // if we'd clear now, the timer may call back for an uninitialized active_hold_tap.
+        LOG_DBG("%d hold-tap timer work in event queue", position);
+        hold_tap->work_is_cancelled = true;
+    } else {
+        LOG_DBG("%d cleaning up hold-tap", position);
+        clear_hold_tap(hold_tap);
+    }
+
+    return 0;
+}
+
+static const struct behavior_driver_api behavior_hold_tap_driver_api = {
+    .binding_pressed = on_hold_tap_binding_pressed,
+    .binding_released = on_hold_tap_binding_released,
+};
+
+static int position_state_changed_listener(const struct zmk_event_header *eh) {
+    struct position_state_changed *ev = cast_position_state_changed(eh);
+
+    if (undecided_hold_tap == NULL) {
+        LOG_DBG("%d bubble (no undecided hold_tap active)", ev->position);
+        return 0;
+    }
+
+    if (undecided_hold_tap->position == ev->position) {
+        if (ev->state) { // keydown
+            LOG_ERR("hold-tap listener should be called before before most other listeners!");
+            return 0;
+        } else { // keyup
+            LOG_DBG("%d bubble undecided hold-tap keyrelease event", undecided_hold_tap->position);
+            return 0;
+        }
+    }
+
+    if (!ev->state && find_captured_keydown_event(ev->position) == NULL) {
+        // no keydown event has been captured, let it bubble.
+        // we'll catch modifiers later in modifier_state_changed_listener
+        LOG_DBG("%d bubbling %d %s event", undecided_hold_tap->position, ev->position,
+                ev->state ? "down" : "up");
+        return 0;
+    }
+
+    LOG_DBG("%d capturing %d %s event", undecided_hold_tap->position, ev->position,
+            ev->state ? "down" : "up");
+    capture_event(eh);
+    decide_hold_tap(undecided_hold_tap, ev->state ? HT_OTHER_KEY_DOWN : HT_OTHER_KEY_UP);
+    return ZMK_EV_EVENT_CAPTURED;
+}
+
+static bool is_mod(struct keycode_state_changed *ev) {
+    return ev->usage_page == USAGE_KEYPAD && ev->keycode >= LCTL && ev->keycode <= RGUI;
+}
+
+static int keycode_state_changed_listener(const struct zmk_event_header *eh) {
+    // we want to catch layer-up events too... how?
+    struct keycode_state_changed *ev = cast_keycode_state_changed(eh);
+
+    if (undecided_hold_tap == NULL) {
+        // LOG_DBG("0x%02X bubble (no undecided hold_tap active)", ev->keycode);
+        return 0;
+    }
+
+    if (!is_mod(ev)) {
+        // LOG_DBG("0x%02X bubble (not a mod)", ev->keycode);
+        return 0;
+    }
+
+    // only key-up events will bubble through position_state_changed_listener
+    // if a undecided_hold_tap is active.
+    LOG_DBG("%d capturing 0x%02X %s event", undecided_hold_tap->position, ev->keycode,
+            ev->state ? "down" : "up");
+    capture_event(eh);
+    return ZMK_EV_EVENT_CAPTURED;
+}
+
+int behavior_hold_tap_listener(const struct zmk_event_header *eh) {
+    if (is_position_state_changed(eh)) {
+        return position_state_changed_listener(eh);
+    } else if (is_keycode_state_changed(eh)) {
+        return keycode_state_changed_listener(eh);
+    }
+    return 0;
+}
+
+ZMK_LISTENER(behavior_hold_tap, behavior_hold_tap_listener);
+ZMK_SUBSCRIPTION(behavior_hold_tap, position_state_changed);
+// this should be modifiers_state_changed, but unfrotunately that's not implemented yet.
+ZMK_SUBSCRIPTION(behavior_hold_tap, keycode_state_changed);
+
+void behavior_hold_tap_timer_work_handler(struct k_work *item) {
+    struct active_hold_tap *hold_tap = CONTAINER_OF(item, struct active_hold_tap, work);
+
+    if (hold_tap->work_is_cancelled) {
+        clear_hold_tap(hold_tap);
+    } else {
+        decide_hold_tap(hold_tap, HT_TIMER_EVENT);
+    }
+}
+
+static int behavior_hold_tap_init(struct device *dev) {
+    static bool init_first_run = true;
+
+    if (init_first_run) {
+        for (int i = 0; i < ZMK_BHV_HOLD_TAP_MAX_HELD; i++) {
+            k_delayed_work_init(&active_hold_taps[i].work, behavior_hold_tap_timer_work_handler);
+            active_hold_taps[i].position = ZMK_BHV_HOLD_TAP_POSITION_NOT_USED;
+        }
+    }
+    init_first_run = false;
+    return 0;
+}
+
+struct behavior_hold_tap_data {};
+static struct behavior_hold_tap_data behavior_hold_tap_data;
+
+#define _TRANSFORM_ENTRY(idx, node)                                                                \
+    {                                                                                              \
+        .behavior_dev = DT_LABEL(DT_INST_PHANDLE_BY_IDX(node, bindings, idx)),                     \
+        .param1 = COND_CODE_0(DT_INST_PHA_HAS_CELL_AT_IDX(node, bindings, idx, param1), (0),       \
+                              (DT_INST_PHA_BY_IDX(node, bindings, idx, param1))),                  \
+        .param2 = COND_CODE_0(DT_INST_PHA_HAS_CELL_AT_IDX(node, bindings, idx, param2), (0),       \
+                              (DT_INST_PHA_BY_IDX(node, bindings, idx, param2))),                  \
+    },
+
+#define KP_INST(n)                                                                                 \
+    static k_timeout_t behavior_hold_tap_config_##n##_gettime() {                                  \
+        return K_MSEC(DT_INST_PROP(n, tapping_term_ms));                                           \
+    }                                                                                              \
+    static struct behavior_hold_tap_behaviors behavior_hold_tap_behaviors_##n = {                  \
+        .hold = _TRANSFORM_ENTRY(0, n).tap = _TRANSFORM_ENTRY(1, n)};                              \
+    static struct behavior_hold_tap_config behavior_hold_tap_config_##n = {                        \
+        .behaviors = &behavior_hold_tap_behaviors_##n,                                             \
+        .tapping_term_ms = &behavior_hold_tap_config_##n##_gettime,                                \
+        .flavor = DT_ENUM_IDX(DT_DRV_INST(n), flavor),                                             \
+    };                                                                                             \
+    DEVICE_AND_API_INIT(behavior_hold_tap_##n, DT_INST_LABEL(n), behavior_hold_tap_init,           \
+                        &behavior_hold_tap_data, &behavior_hold_tap_config_##n, APPLICATION,       \
+                        CONFIG_KERNEL_INIT_PRIORITY_DEFAULT, &behavior_hold_tap_driver_api);
+
+DT_INST_FOREACH_STATUS_OKAY(KP_INST)
+
+#endif
\ No newline at end of file
diff --git a/app/src/behaviors/behavior_key_press.c b/app/src/behaviors/behavior_key_press.c
index 7404c79..bbfbe36 100644
--- a/app/src/behaviors/behavior_key_press.c
+++ b/app/src/behaviors/behavior_key_press.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Peter Johanson <peter@peterjohanson.com>
+ * Copyright (c) 2020 The ZMK Contributors
  *
  * SPDX-License-Identifier: MIT
  */
@@ -16,45 +16,35 @@
 LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
 
 struct behavior_key_press_config {
-  u8_t usage_page;
+    u8_t usage_page;
 };
-struct behavior_key_press_data { };
+struct behavior_key_press_data {};
 
-static int behavior_key_press_init(struct device *dev)
-{
-	return 0;
-};
+static int behavior_key_press_init(struct device *dev) { return 0; };
 
-static int on_keymap_binding_pressed(struct device *dev, u32_t position, u32_t keycode, u32_t _)
-{
-  const struct behavior_key_press_config *cfg = dev->config_info;
-  LOG_DBG("position %d usage_page 0x%02X keycode 0x%02X", position, cfg->usage_page, keycode);
+static int on_keymap_binding_pressed(struct device *dev, u32_t position, u32_t keycode, u32_t _) {
+    const struct behavior_key_press_config *cfg = dev->config_info;
+    LOG_DBG("position %d usage_page 0x%02X keycode 0x%02X", position, cfg->usage_page, keycode);
 
-  return ZMK_EVENT_RAISE(create_keycode_state_changed(cfg->usage_page, keycode, true));
+    return ZMK_EVENT_RAISE(create_keycode_state_changed(cfg->usage_page, keycode, true));
 }
 
-static int on_keymap_binding_released(struct device *dev, u32_t position, u32_t keycode, u32_t _)
-{
-  const struct behavior_key_press_config *cfg = dev->config_info;
-  LOG_DBG("position %d usage_page 0x%02X keycode 0x%02X", position, cfg->usage_page, keycode);
+static int on_keymap_binding_released(struct device *dev, u32_t position, u32_t keycode, u32_t _) {
+    const struct behavior_key_press_config *cfg = dev->config_info;
+    LOG_DBG("position %d usage_page 0x%02X keycode 0x%02X", position, cfg->usage_page, keycode);
 
-  return ZMK_EVENT_RAISE(create_keycode_state_changed(cfg->usage_page, keycode, false));
+    return ZMK_EVENT_RAISE(create_keycode_state_changed(cfg->usage_page, keycode, false));
 }
 
 static const struct behavior_driver_api behavior_key_press_driver_api = {
-  .binding_pressed = on_keymap_binding_pressed,
-  .binding_released = on_keymap_binding_released
-};
-
-#define KP_INST(n) \
-  static const struct behavior_key_press_config behavior_key_press_config_##n = { \
-    .usage_page = DT_INST_PROP(n, usage_page) \
-  }; \
-  static struct behavior_key_press_data behavior_key_press_data_##n; \
-  DEVICE_AND_API_INIT(behavior_key_press_##n, DT_INST_LABEL(n), behavior_key_press_init, \
-                      &behavior_key_press_data_##n, \
-                      &behavior_key_press_config_##n, \
-                      APPLICATION, CONFIG_KERNEL_INIT_PRIORITY_DEFAULT, \
-                      &behavior_key_press_driver_api);
+    .binding_pressed = on_keymap_binding_pressed, .binding_released = on_keymap_binding_released};
+
+#define KP_INST(n)                                                                                 \
+    static const struct behavior_key_press_config behavior_key_press_config_##n = {                \
+        .usage_page = DT_INST_PROP(n, usage_page)};                                                \
+    static struct behavior_key_press_data behavior_key_press_data_##n;                             \
+    DEVICE_AND_API_INIT(behavior_key_press_##n, DT_INST_LABEL(n), behavior_key_press_init,         \
+                        &behavior_key_press_data_##n, &behavior_key_press_config_##n, APPLICATION, \
+                        CONFIG_KERNEL_INIT_PRIORITY_DEFAULT, &behavior_key_press_driver_api);
 
 DT_INST_FOREACH_STATUS_OKAY(KP_INST)
\ No newline at end of file
diff --git a/app/src/behaviors/behavior_mod_tap.c b/app/src/behaviors/behavior_mod_tap.c
deleted file mode 100644
index 6151f7e..0000000
--- a/app/src/behaviors/behavior_mod_tap.c
+++ /dev/null
@@ -1,252 +0,0 @@
-/*
- * Copyright (c) 2020 Peter Johanson <peter@peterjohanson.com>
- *
- * SPDX-License-Identifier: MIT
- */
-
-#define DT_DRV_COMPAT zmk_behavior_mod_tap
-
-#include <device.h>
-#include <drivers/behavior.h>
-#include <logging/log.h>
-
-#include <zmk/matrix.h>
-#include <zmk/endpoints.h>
-#include <zmk/event-manager.h>
-#include <zmk/events/keycode-state-changed.h>
-#include <zmk/events/modifiers-state-changed.h>
-#include <zmk/hid.h>
-
-LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
-
-#define ZMK_BHV_MOD_TAP_MAX_HELD 4
-#define ZMK_BHV_MOD_TAP_MAX_PENDING_KC 4
-
-struct active_mod_tap_item {
-  u32_t keycode;
-  u8_t mods;
-  bool pending;
-  zmk_mod_flags active_mods;
-};
-
-struct captured_keycode_state_change_item {
-  struct keycode_state_changed* event;
-  zmk_mod_flags active_mods;
-};
-
-struct behavior_mod_tap_config { };
-struct behavior_mod_tap_data {
-  struct active_mod_tap_item active_mod_taps[ZMK_BHV_MOD_TAP_MAX_HELD];
-  struct captured_keycode_state_change_item captured_keycode_events[ZMK_BHV_MOD_TAP_MAX_PENDING_KC];
-};
-
-bool have_pending_mods(char *label) {
-  struct device *dev = device_get_binding(label);
-  struct behavior_mod_tap_data *data = dev->driver_data;
-
-  for (int i = 0; i < ZMK_BHV_MOD_TAP_MAX_HELD; i++) {
-    if (data->active_mod_taps[i].mods) {
-      LOG_DBG("Found pending mods for %d and keycode 0x%02X", data->active_mod_taps[i].mods, data->active_mod_taps[i].keycode);
-      return true;
-    }
-  }
-
-  return false;
-}
-
-struct captured_keycode_state_change_item* find_pending_keycode(struct behavior_mod_tap_data *data, u32_t keycode)
-{
-  for (int i = 0; i < ZMK_BHV_MOD_TAP_MAX_PENDING_KC; i++) {
-    if (data->captured_keycode_events[i].event == NULL) {
-      continue;
-    }
-
-    if (data->captured_keycode_events[i].event->keycode == keycode) {
-      return &data->captured_keycode_events[i];
-    }
-  }
-
-  return NULL;
-}
-
-zmk_mod_flags behavior_mod_tap_active_mods(struct behavior_mod_tap_data *data)
-{
-  zmk_mod_flags mods = 0;
-
-  for (int i = 0; i < ZMK_BHV_MOD_TAP_MAX_HELD; i++) {
-    mods |= data->active_mod_taps[i].mods;
-  }
-
-  return mods;
-}
-
-int behavior_mod_tap_capture_keycode_event(struct behavior_mod_tap_data *data, struct keycode_state_changed *ev)
-{
-  for (int i = 0; i < ZMK_BHV_MOD_TAP_MAX_PENDING_KC; i++) {
-    if (data->captured_keycode_events[i].event != NULL) {
-      continue;
-    }
-
-    data->captured_keycode_events[i].event = ev;
-    data->captured_keycode_events[i].active_mods = behavior_mod_tap_active_mods(data);
-    return 0;
-  }
-
-  return -ENOMEM;
-}
-
-void behavior_mod_tap_update_active_mods_state(struct behavior_mod_tap_data *data, zmk_mod_flags used_flags)
-{
-  for (int i = 0; i < ZMK_BHV_MOD_TAP_MAX_HELD; i++) {
-    if ((data->active_mod_taps[i].mods & used_flags) == data->active_mod_taps[i].mods) {
-      data->active_mod_taps[i].pending = false;
-    }
-  }
-}
-
-// How to pass context to subscription?!
-int behavior_mod_tap_listener(const struct zmk_event_header *eh)
-{
-  if (is_keycode_state_changed(eh) && have_pending_mods(DT_INST_LABEL(0))) {
-    struct device *dev = device_get_binding(DT_INST_LABEL(0));
-    struct keycode_state_changed *ev = cast_keycode_state_changed(eh);
-    struct behavior_mod_tap_data *data = dev->driver_data;
-    struct captured_keycode_state_change_item* pending_keycode;
-    if (ev->state) {
-      LOG_DBG("Have pending mods, capturing keycode 0x%02X event to ressend later", ev->keycode);
-      behavior_mod_tap_capture_keycode_event(data, ev);
-      return ZMK_EV_EVENT_CAPTURED;
-    } else if ((pending_keycode = find_pending_keycode(data, ev->keycode)) != NULL) {
-      LOG_DBG("Key released, going to activate mods 0x%02X then send pending key press for keycode 0x%02X",
-              pending_keycode->active_mods, pending_keycode->event->keycode);
-
-      zmk_hid_register_mods(pending_keycode->active_mods);
-      behavior_mod_tap_update_active_mods_state(data, pending_keycode->active_mods);
-
-      ZMK_EVENT_RELEASE(pending_keycode->event);
-      k_msleep(10);
-
-      pending_keycode->event = NULL;
-      pending_keycode->active_mods = 0;
-    }
-  }
-  return 0;
-}
-
-ZMK_LISTENER(behavior_mod_tap, behavior_mod_tap_listener);
-ZMK_SUBSCRIPTION(behavior_mod_tap, keycode_state_changed);
-
-static int behavior_mod_tap_init(struct device *dev)
-{
-	return 0;
-};
-
-
-static int on_keymap_binding_pressed(struct device *dev, u32_t position, u32_t mods, u32_t keycode)
-{
-  struct behavior_mod_tap_data *data = dev->driver_data;
-  LOG_DBG("mods: %d, keycode: 0x%02X", mods, keycode);
-  for (int i = 0; i < ZMK_BHV_MOD_TAP_MAX_HELD; i++) {
-    if (data->active_mod_taps[i].mods != 0) {
-      continue;
-    }
-
-    zmk_mod_flags active_mods = behavior_mod_tap_active_mods(data);
-
-    data->active_mod_taps[i].active_mods = active_mods;
-    data->active_mod_taps[i].mods = mods;
-    data->active_mod_taps[i].keycode = keycode;
-    data->active_mod_taps[i].pending = true;
-
-    return 0;
-  }
-
-  LOG_WRN("Failed to record mod-tap activation, at maximum concurrent mod-tap activations");
-
-  return -ENOMEM;
-}
-
-static int on_keymap_binding_released(struct device *dev, u32_t position, u32_t mods, u32_t keycode)
-{
-  struct behavior_mod_tap_data *data = dev->driver_data;
-  LOG_DBG("mods: %d, keycode: %d", mods, keycode);
-  
-  for (int i = 0; i < ZMK_BHV_MOD_TAP_MAX_HELD; i++) {
-    struct active_mod_tap_item *item = &data->active_mod_taps[i];
-    if (item->mods == mods && item->keycode == keycode) {
-      if (item->pending) {
-        LOG_DBG("Sending un-triggered mod-tap for keycode: 0x%02X", keycode);
-
-        if (item->active_mods) {
-          LOG_DBG("Registering recorded active mods captured when mod-tap initially activated: 0x%02X", item->active_mods);
-          behavior_mod_tap_update_active_mods_state(data, item->active_mods);
-          zmk_hid_register_mods(item->active_mods);
-        }
-
-        struct keycode_state_changed *key_press = create_keycode_state_changed(USAGE_KEYPAD, item->keycode, true);
-        ZMK_EVENT_RAISE_AFTER(key_press, behavior_mod_tap);
-        k_msleep(10);
-
-        for (int j = 0; j < ZMK_BHV_MOD_TAP_MAX_PENDING_KC; j++) {
-          if (data->captured_keycode_events[j].event == NULL) {
-            continue;
-          }
-
-          struct keycode_state_changed *ev = data->captured_keycode_events[j].event;
-          data->captured_keycode_events[i].event = NULL;
-          data->captured_keycode_events[i].active_mods = 0;
-          LOG_DBG("Re-sending latched key press for usage page 0x%02X keycode 0x%02X state %s", ev->usage_page, ev->keycode, (ev->state ? "pressed" : "released"));
-          ZMK_EVENT_RELEASE(ev);
-          k_msleep(10);
-        }
-
-        struct keycode_state_changed *key_release = create_keycode_state_changed(USAGE_KEYPAD, keycode, false);
-        LOG_DBG("Sending un-triggered mod-tap release for keycode: 0x%02X", keycode);
-        ZMK_EVENT_RAISE_AFTER(key_release, behavior_mod_tap);
-        k_msleep(10);
-
-        if (item->active_mods) {
-          LOG_DBG("Unregistering recorded active mods captured when mod-tap initially activated: 0x%02X", item->active_mods);
-          zmk_hid_unregister_mods(item->active_mods);
-          zmk_endpoints_send_report(USAGE_KEYPAD);
-        }
-
-        
-      } else {
-        LOG_DBG("Releasing triggered mods: %d", mods);
-        zmk_hid_unregister_mods(mods);
-        zmk_endpoints_send_report(USAGE_KEYPAD);
-      }
-
-      item->mods = 0;
-      item->keycode = 0;
-      item->active_mods = 0;
-
-      LOG_DBG("Removing mods %d from active_mods for other held mod-taps", mods);
-      for (int j = 0; j < ZMK_BHV_MOD_TAP_MAX_HELD; j++) {
-        if (data->active_mod_taps[j].active_mods & mods) {
-          LOG_DBG("Removing 0x%02X from active mod tap mods 0x%02X keycode 0x%02X", mods, data->active_mod_taps[j].mods, data->active_mod_taps[j].keycode);
-          data->active_mod_taps[j].active_mods &= ~mods;
-        }
-      }
-      break;
-    }
-  }
-
-  return 0;
-}
-
-static const struct behavior_driver_api behavior_mod_tap_driver_api = {
-  .binding_pressed = on_keymap_binding_pressed,
-  .binding_released = on_keymap_binding_released,
-};
-
-static const struct behavior_mod_tap_config behavior_mod_tap_config = {};
-
-static struct behavior_mod_tap_data behavior_mod_tap_data;
-
-DEVICE_AND_API_INIT(behavior_mod_tap, DT_INST_LABEL(0), behavior_mod_tap_init,
-                    &behavior_mod_tap_data,
-                    &behavior_mod_tap_config,
-                    APPLICATION, CONFIG_KERNEL_INIT_PRIORITY_DEFAULT,
-                    &behavior_mod_tap_driver_api);
diff --git a/app/src/behaviors/behavior_momentary_layer.c b/app/src/behaviors/behavior_momentary_layer.c
index 8a8584a..80b7165 100644
--- a/app/src/behaviors/behavior_momentary_layer.c
+++ b/app/src/behaviors/behavior_momentary_layer.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Peter Johanson <peter@peterjohanson.com>
+ * Copyright (c) 2020 The ZMK Contributors
  *
  * SPDX-License-Identifier: MIT
  */
@@ -14,41 +14,30 @@
 
 LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
 
-struct behavior_mo_config { };
-struct behavior_mo_data { };
+struct behavior_mo_config {};
+struct behavior_mo_data {};
 
-static int behavior_mo_init(struct device *dev)
-{
-	return 0;
-};
+static int behavior_mo_init(struct device *dev) { return 0; };
 
+static int mo_keymap_binding_pressed(struct device *dev, u32_t position, u32_t layer, u32_t _) {
+    LOG_DBG("position %d layer %d", position, layer);
 
-static int mo_keymap_binding_pressed(struct device *dev, u32_t position, u32_t layer, u32_t _)
-{
-  LOG_DBG("position %d layer %d", position, layer);
-
-  return zmk_keymap_layer_activate(layer);
+    return zmk_keymap_layer_activate(layer);
 }
 
-static int mo_keymap_binding_released(struct device *dev, u32_t position, u32_t layer, u32_t _)
-{
-  LOG_DBG("position %d layer %d", position, layer);
+static int mo_keymap_binding_released(struct device *dev, u32_t position, u32_t layer, u32_t _) {
+    LOG_DBG("position %d layer %d", position, layer);
 
-  return zmk_keymap_layer_deactivate(layer);
+    return zmk_keymap_layer_deactivate(layer);
 }
 
 static const struct behavior_driver_api behavior_mo_driver_api = {
-  .binding_pressed = mo_keymap_binding_pressed,
-  .binding_released = mo_keymap_binding_released
-};
-
+    .binding_pressed = mo_keymap_binding_pressed, .binding_released = mo_keymap_binding_released};
 
 static const struct behavior_mo_config behavior_mo_config = {};
 
 static struct behavior_mo_data behavior_mo_data;
 
-DEVICE_AND_API_INIT(behavior_mo, DT_INST_LABEL(0), behavior_mo_init,
-                    &behavior_mo_data,
-                    &behavior_mo_config,
-                    APPLICATION, CONFIG_KERNEL_INIT_PRIORITY_DEFAULT,
+DEVICE_AND_API_INIT(behavior_mo, DT_INST_LABEL(0), behavior_mo_init, &behavior_mo_data,
+                    &behavior_mo_config, APPLICATION, CONFIG_KERNEL_INIT_PRIORITY_DEFAULT,
                     &behavior_mo_driver_api);
diff --git a/app/src/behaviors/behavior_none.c b/app/src/behaviors/behavior_none.c
index 7e77e54..b548e6f 100644
--- a/app/src/behaviors/behavior_none.c
+++ b/app/src/behaviors/behavior_none.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Peter Johanson <peter@peterjohanson.com>
+ * Copyright (c) 2020 The ZMK Contributors
  *
  * SPDX-License-Identifier: MIT
  */
@@ -13,36 +13,30 @@
 
 LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
 
-struct behavior_none_config { };
-struct behavior_none_data { };
+struct behavior_none_config {};
+struct behavior_none_data {};
 
-static int behavior_none_init(struct device *dev)
-{
-	return 0;
-};
+static int behavior_none_init(struct device *dev) { return 0; };
 
-static int on_keymap_binding_pressed(struct device *dev, u32_t position, u32_t _param1, u32_t _param2)
-{
-  return 1;
+static int on_keymap_binding_pressed(struct device *dev, u32_t position, u32_t _param1,
+                                     u32_t _param2) {
+    return 0;
 }
 
-static int on_keymap_binding_released(struct device *dev, u32_t position, u32_t _param1, u32_t _param2)
-{
-  return 1;
+static int on_keymap_binding_released(struct device *dev, u32_t position, u32_t _param1,
+                                      u32_t _param2) {
+    return 0;
 }
 
 static const struct behavior_driver_api behavior_none_driver_api = {
-  .binding_pressed = on_keymap_binding_pressed,
-  .binding_released = on_keymap_binding_released,
+    .binding_pressed = on_keymap_binding_pressed,
+    .binding_released = on_keymap_binding_released,
 };
 
-
 static const struct behavior_none_config behavior_none_config = {};
 
 static struct behavior_none_data behavior_none_data;
 
-DEVICE_AND_API_INIT(behavior_none, DT_INST_LABEL(0), behavior_none_init,
-                    &behavior_none_data,
-                    &behavior_none_config,
-                    APPLICATION, CONFIG_KERNEL_INIT_PRIORITY_DEFAULT,
+DEVICE_AND_API_INIT(behavior_none, DT_INST_LABEL(0), behavior_none_init, &behavior_none_data,
+                    &behavior_none_config, APPLICATION, CONFIG_KERNEL_INIT_PRIORITY_DEFAULT,
                     &behavior_none_driver_api);
\ No newline at end of file
diff --git a/app/src/behaviors/behavior_reset.c b/app/src/behaviors/behavior_reset.c
index 44cbc21..90de20b 100644
--- a/app/src/behaviors/behavior_reset.c
+++ b/app/src/behaviors/behavior_reset.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Peter Johanson <peter@peterjohanson.com>
+ * Copyright (c) 2020 The ZMK Contributors
  *
  * SPDX-License-Identifier: MIT
  */
@@ -13,33 +13,32 @@
 
 LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
 
-struct behavior_reset_config { };
-struct behavior_reset_data { };
-
-static int behavior_reset_init(struct device *dev)
-{
-	return 0;
+struct behavior_reset_config {
+    int type;
 };
 
-static int on_keymap_binding_pressed(struct device *dev, u32_t position, u32_t _param1, u32_t _param2)
-{
-  // TODO: Correct magic code for going into DFU?
-  // See https://github.com/adafruit/Adafruit_nRF52_Bootloader/blob/d6b28e66053eea467166f44875e3c7ec741cb471/src/main.c#L107
-  sys_reboot(0);
-  return 0;
+static int behavior_reset_init(struct device *dev) { return 0; };
+
+static int on_keymap_binding_pressed(struct device *dev, u32_t position, u32_t _param1,
+                                     u32_t _param2) {
+    const struct behavior_reset_config *cfg = dev->config_info;
+
+    // TODO: Correct magic code for going into DFU?
+    // See
+    // https://github.com/adafruit/Adafruit_nRF52_Bootloader/blob/d6b28e66053eea467166f44875e3c7ec741cb471/src/main.c#L107
+    sys_reboot(cfg->type);
+    return 0;
 }
 
 static const struct behavior_driver_api behavior_reset_driver_api = {
-  .binding_pressed = on_keymap_binding_pressed,
+    .binding_pressed = on_keymap_binding_pressed,
 };
 
+#define RST_INST(n)                                                                                \
+    static const struct behavior_reset_config behavior_reset_config_##n = {                        \
+        .type = DT_INST_PROP(n, type)};                                                            \
+    DEVICE_AND_API_INIT(behavior_reset_##n, DT_INST_LABEL(n), behavior_reset_init, NULL,           \
+                        &behavior_reset_config_##n, APPLICATION,                                   \
+                        CONFIG_KERNEL_INIT_PRIORITY_DEFAULT, &behavior_reset_driver_api);
 
-static const struct behavior_reset_config behavior_reset_config = {};
-
-static struct behavior_reset_data behavior_reset_data;
-
-DEVICE_AND_API_INIT(behavior_reset, DT_INST_LABEL(0), behavior_reset_init,
-                    &behavior_reset_data,
-                    &behavior_reset_config,
-                    APPLICATION, CONFIG_KERNEL_INIT_PRIORITY_DEFAULT,
-                    &behavior_reset_driver_api);
\ No newline at end of file
+DT_INST_FOREACH_STATUS_OKAY(RST_INST)
\ No newline at end of file
diff --git a/app/src/behaviors/behavior_rgb_underglow.c b/app/src/behaviors/behavior_rgb_underglow.c
index 7a48e07..621eab5 100644
--- a/app/src/behaviors/behavior_rgb_underglow.c
+++ b/app/src/behaviors/behavior_rgb_underglow.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Nick Winans <nick@winans.codes>
+ * Copyright (c) 2020 The ZMK Contributors
  *
  * SPDX-License-Identifier: MIT
  */
@@ -15,48 +15,41 @@
 
 LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
 
-static int behavior_rgb_underglow_init(struct device *dev)
-{
-  return 0;
-}
+static int behavior_rgb_underglow_init(struct device *dev) { return 0; }
 
-static int on_keymap_binding_pressed(struct device *dev, u32_t position, u32_t action, u32_t _)
-{
-  switch (action)
-  {
+static int on_keymap_binding_pressed(struct device *dev, u32_t position, u32_t action, u32_t _) {
+    switch (action) {
     case RGB_TOG:
-      return zmk_rgb_underglow_toggle();
+        return zmk_rgb_underglow_toggle();
     case RGB_HUI:
-      return zmk_rgb_underglow_change_hue(1);
+        return zmk_rgb_underglow_change_hue(1);
     case RGB_HUD:
-      return zmk_rgb_underglow_change_hue(-1);
+        return zmk_rgb_underglow_change_hue(-1);
     case RGB_SAI:
-      return zmk_rgb_underglow_change_sat(1);
+        return zmk_rgb_underglow_change_sat(1);
     case RGB_SAD:
-      return zmk_rgb_underglow_change_sat(-1);
+        return zmk_rgb_underglow_change_sat(-1);
     case RGB_BRI:
-      return zmk_rgb_underglow_change_brt(1);
+        return zmk_rgb_underglow_change_brt(1);
     case RGB_BRD:
-      return zmk_rgb_underglow_change_brt(-1);
+        return zmk_rgb_underglow_change_brt(-1);
     case RGB_SPI:
-      return zmk_rgb_underglow_change_spd(1);
+        return zmk_rgb_underglow_change_spd(1);
     case RGB_SPD:
-      return zmk_rgb_underglow_change_spd(-1);
+        return zmk_rgb_underglow_change_spd(-1);
     case RGB_EFF:
-      return zmk_rgb_underglow_cycle_effect(1);
+        return zmk_rgb_underglow_cycle_effect(1);
     case RGB_EFR:
-      return zmk_rgb_underglow_cycle_effect(-1);
-  }
+        return zmk_rgb_underglow_cycle_effect(-1);
+    }
 
-  return -ENOTSUP;
+    return -ENOTSUP;
 }
 
 static const struct behavior_driver_api behavior_rgb_underglow_driver_api = {
-  .binding_pressed = on_keymap_binding_pressed,
+    .binding_pressed = on_keymap_binding_pressed,
 };
 
-DEVICE_AND_API_INIT(behavior_rgb_underglow, DT_INST_LABEL(0), behavior_rgb_underglow_init,
-                    NULL,
-                    NULL,
-                    APPLICATION, CONFIG_KERNEL_INIT_PRIORITY_DEFAULT,
+DEVICE_AND_API_INIT(behavior_rgb_underglow, DT_INST_LABEL(0), behavior_rgb_underglow_init, NULL,
+                    NULL, APPLICATION, CONFIG_KERNEL_INIT_PRIORITY_DEFAULT,
                     &behavior_rgb_underglow_driver_api);
\ No newline at end of file
diff --git a/app/src/behaviors/behavior_sensor_rotate_key_press.c b/app/src/behaviors/behavior_sensor_rotate_key_press.c
index fb0fb85..1a0bf03 100644
--- a/app/src/behaviors/behavior_sensor_rotate_key_press.c
+++ b/app/src/behaviors/behavior_sensor_rotate_key_press.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Peter Johanson <peter@peterjohanson.com>
+ * Copyright (c) 2020 The ZMK Contributors
  *
  * SPDX-License-Identifier: MIT
  */
@@ -17,75 +17,69 @@
 LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
 
 struct behavior_sensor_rotate_key_press_config {
-  u8_t usage_page;
-};
-struct behavior_sensor_rotate_key_press_data { };
-
-static int behavior_sensor_rotate_key_press_init(struct device *dev)
-{
-	return 0;
+    u8_t usage_page;
 };
+struct behavior_sensor_rotate_key_press_data {};
 
+static int behavior_sensor_rotate_key_press_init(struct device *dev) { return 0; };
 
-static int on_sensor_binding_triggered(struct device *dev, struct device *sensor, u32_t increment_keycode, u32_t decrement_keycode)
-{
-  const struct behavior_sensor_rotate_key_press_config *cfg = dev->config_info;
-  struct sensor_value value;
-  int err;
-  u32_t keycode;
-  struct keycode_state_changed *ev;
-  LOG_DBG("usage_page 0x%02X inc keycode 0x%02X dec keycode 0x%02X", cfg->usage_page, increment_keycode, decrement_keycode);
+static int on_sensor_binding_triggered(struct device *dev, struct device *sensor,
+                                       u32_t increment_keycode, u32_t decrement_keycode) {
+    const struct behavior_sensor_rotate_key_press_config *cfg = dev->config_info;
+    struct sensor_value value;
+    int err;
+    u32_t keycode;
+    struct keycode_state_changed *ev;
+    LOG_DBG("usage_page 0x%02X inc keycode 0x%02X dec keycode 0x%02X", cfg->usage_page,
+            increment_keycode, decrement_keycode);
 
-  err = sensor_channel_get(sensor, SENSOR_CHAN_ROTATION, &value);
+    err = sensor_channel_get(sensor, SENSOR_CHAN_ROTATION, &value);
 
-  if (err) {
-    LOG_WRN("Failed to ge sensor rotation value: %d", err);
-    return err;
-  }
+    if (err) {
+        LOG_WRN("Failed to ge sensor rotation value: %d", err);
+        return err;
+    }
 
-  switch (value.val1) {
+    switch (value.val1) {
     case 1:
-      keycode = increment_keycode;
-      break;
+        keycode = increment_keycode;
+        break;
     case -1:
-      keycode = decrement_keycode;
-      break;
+        keycode = decrement_keycode;
+        break;
     default:
-      return -ENOTSUP;
-  }
-
-  LOG_DBG("SEND %d", keycode);
+        return -ENOTSUP;
+    }
 
+    LOG_DBG("SEND %d", keycode);
 
-  ev = new_keycode_state_changed();
-  ev->usage_page = cfg->usage_page;
-  ev->keycode = keycode;
-  ev->state = true;
-  ZMK_EVENT_RAISE(ev);
+    ev = new_keycode_state_changed();
+    ev->usage_page = cfg->usage_page;
+    ev->keycode = keycode;
+    ev->state = true;
+    ZMK_EVENT_RAISE(ev);
 
-  // TODO: Better way to do this?
-  k_msleep(5);
+    // TODO: Better way to do this?
+    k_msleep(5);
 
-  ev = new_keycode_state_changed();
-  ev->usage_page = cfg->usage_page;
-  ev->keycode = keycode;
-  ev->state = false;
-  return ZMK_EVENT_RAISE(ev);
+    ev = new_keycode_state_changed();
+    ev->usage_page = cfg->usage_page;
+    ev->keycode = keycode;
+    ev->state = false;
+    return ZMK_EVENT_RAISE(ev);
 }
 
 static const struct behavior_driver_api behavior_sensor_rotate_key_press_driver_api = {
-  .sensor_binding_triggered = on_sensor_binding_triggered
-};
-
-#define KP_INST(n) \
-  static const struct behavior_sensor_rotate_key_press_config behavior_sensor_rotate_key_press_config_##n = { \
-    .usage_page = DT_INST_PROP(n, usage_page) \
-  }; \
-  static struct behavior_sensor_rotate_key_press_data behavior_sensor_rotate_key_press_data_##n; \
-  DEVICE_AND_API_INIT(behavior_sensor_rotate_key_press_##n, DT_INST_LABEL(n), behavior_sensor_rotate_key_press_init, \
-                      &behavior_sensor_rotate_key_press_data_##n, \
-                      &behavior_sensor_rotate_key_press_config_##n, \
-                      APPLICATION, CONFIG_KERNEL_INIT_PRIORITY_DEFAULT, \
-                      &behavior_sensor_rotate_key_press_driver_api);
+    .sensor_binding_triggered = on_sensor_binding_triggered};
+
+#define KP_INST(n)                                                                                 \
+    static const struct behavior_sensor_rotate_key_press_config                                    \
+        behavior_sensor_rotate_key_press_config_##n = {.usage_page = DT_INST_PROP(n, usage_page)}; \
+    static struct behavior_sensor_rotate_key_press_data behavior_sensor_rotate_key_press_data_##n; \
+    DEVICE_AND_API_INIT(                                                                           \
+        behavior_sensor_rotate_key_press_##n, DT_INST_LABEL(n),                                    \
+        behavior_sensor_rotate_key_press_init, &behavior_sensor_rotate_key_press_data_##n,         \
+        &behavior_sensor_rotate_key_press_config_##n, APPLICATION,                                 \
+        CONFIG_KERNEL_INIT_PRIORITY_DEFAULT, &behavior_sensor_rotate_key_press_driver_api);
 
 DT_INST_FOREACH_STATUS_OKAY(KP_INST)
\ No newline at end of file
diff --git a/app/src/behaviors/behavior_toggle_layer.c b/app/src/behaviors/behavior_toggle_layer.c
index 13f4a29..2819451 100644
--- a/app/src/behaviors/behavior_toggle_layer.c
+++ b/app/src/behaviors/behavior_toggle_layer.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Cody McGinnis <brainwart@gmail.com>
+ * Copyright (c) 2020 The ZMK Contributors
  *
  * SPDX-License-Identifier: MIT
  */
@@ -14,36 +14,32 @@
 
 LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
 
-struct behavior_tog_config { };
-struct behavior_tog_data { };
+struct behavior_tog_config {};
+struct behavior_tog_data {};
 
-static int behavior_tog_init(struct device *dev)
-{
-	return 0;
-};
+static int behavior_tog_init(struct device *dev) { return 0; };
 
+static int tog_keymap_binding_pressed(struct device *dev, u32_t position, u32_t layer, u32_t _) {
+    LOG_DBG("position %d layer %d", position, layer);
 
-static int tog_keymap_binding_pressed(struct device *dev, u32_t position, u32_t layer, u32_t _)
-{
-  return zmk_keymap_layer_toggle(layer);
+    return zmk_keymap_layer_toggle(layer);
 }
 
-static int tog_keymap_binding_released(struct device *dev, u32_t position, u32_t layer, u32_t _)
-{
-  return 0;
+static int tog_keymap_binding_released(struct device *dev, u32_t position, u32_t layer, u32_t _) {
+    LOG_DBG("position %d layer %d", position, layer);
+
+    return 0;
 }
 
 static const struct behavior_driver_api behavior_tog_driver_api = {
-  .binding_pressed = tog_keymap_binding_pressed,
-  .binding_released = tog_keymap_binding_released,
+    .binding_pressed = tog_keymap_binding_pressed,
+    .binding_released = tog_keymap_binding_released,
 };
 
 static const struct behavior_tog_config behavior_tog_config = {};
 
 static struct behavior_tog_data behavior_tog_data;
 
-DEVICE_AND_API_INIT(behavior_tog, DT_INST_LABEL(0), behavior_tog_init,
-                    &behavior_tog_data,
-                    &behavior_tog_config,
-                    APPLICATION, CONFIG_KERNEL_INIT_PRIORITY_DEFAULT,
+DEVICE_AND_API_INIT(behavior_tog, DT_INST_LABEL(0), behavior_tog_init, &behavior_tog_data,
+                    &behavior_tog_config, APPLICATION, CONFIG_KERNEL_INIT_PRIORITY_DEFAULT,
                     &behavior_tog_driver_api);
diff --git a/app/src/behaviors/behavior_transparent.c b/app/src/behaviors/behavior_transparent.c
index 5109264..f7852f3 100644
--- a/app/src/behaviors/behavior_transparent.c
+++ b/app/src/behaviors/behavior_transparent.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Peter Johanson <peter@peterjohanson.com>
+ * Copyright (c) 2020 The ZMK Contributors
  *
  * SPDX-License-Identifier: MIT
  */
@@ -13,36 +13,30 @@
 
 LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
 
-struct behavior_transparent_config { };
-struct behavior_transparent_data { };
+struct behavior_transparent_config {};
+struct behavior_transparent_data {};
 
-static int behavior_transparent_init(struct device *dev)
-{
-	return 0;
-};
+static int behavior_transparent_init(struct device *dev) { return 0; };
 
-static int on_keymap_binding_pressed(struct device *dev, u32_t position, u32_t _param1, u32_t _param2)
-{
-  return 1;
+static int on_keymap_binding_pressed(struct device *dev, u32_t position, u32_t _param1,
+                                     u32_t _param2) {
+    return 1;
 }
 
-static int on_keymap_binding_released(struct device *dev, u32_t position, u32_t _param1, u32_t _param2)
-{
-  return 1;
+static int on_keymap_binding_released(struct device *dev, u32_t position, u32_t _param1,
+                                      u32_t _param2) {
+    return 1;
 }
 
 static const struct behavior_driver_api behavior_transparent_driver_api = {
-  .binding_pressed = on_keymap_binding_pressed,
-  .binding_released = on_keymap_binding_released,
+    .binding_pressed = on_keymap_binding_pressed,
+    .binding_released = on_keymap_binding_released,
 };
 
-
 static const struct behavior_transparent_config behavior_transparent_config = {};
 
 static struct behavior_transparent_data behavior_transparent_data;
 
 DEVICE_AND_API_INIT(behavior_transparent, DT_INST_LABEL(0), behavior_transparent_init,
-                    &behavior_transparent_data,
-                    &behavior_transparent_config,
-                    APPLICATION, CONFIG_KERNEL_INIT_PRIORITY_DEFAULT,
-                    &behavior_transparent_driver_api);
\ No newline at end of file
+                    &behavior_transparent_data, &behavior_transparent_config, APPLICATION,
+                    CONFIG_KERNEL_INIT_PRIORITY_DEFAULT, &behavior_transparent_driver_api);
\ No newline at end of file
diff --git a/app/src/ble.c b/app/src/ble.c
index 0e96d16..49e2b3b 100644
--- a/app/src/ble.c
+++ b/app/src/ble.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Peter Johanson
+ * Copyright (c) 2020 The ZMK Contributors
  *
  * SPDX-License-Identifier: MIT
  */
@@ -8,6 +8,8 @@
 #include <init.h>
 
 #include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
 
 #include <settings/settings.h>
 #include <bluetooth/bluetooth.h>
@@ -15,37 +17,224 @@
 #include <bluetooth/hci.h>
 #include <bluetooth/uuid.h>
 #include <bluetooth/gatt.h>
+#include <bluetooth/hci_err.h>
 
+#if IS_ENABLED(CONFIG_SETTINGS)
+
+#include <settings/settings.h>
+
+#endif
 
 #include <logging/log.h>
 
 LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
 
+#include <zmk/ble.h>
 #include <zmk/keys.h>
 #include <zmk/split/bluetooth/uuid.h>
+#include <zmk/event-manager.h>
+#include <zmk/events/ble-active-profile-changed.h>
 
 static struct bt_conn *auth_passkey_entry_conn;
 static u8_t passkey_entries[6] = {0, 0, 0, 0, 0, 0};
 static u8_t passkey_digit = 0;
 
-#if IS_ENABLED(CONFIG_ZMK_SPLIT_BLE_ROLE_PERIPHERAL)
-#define ZMK_ADV_PARAMS BT_LE_ADV_PARAM(BT_LE_ADV_OPT_CONNECTABLE | \
-                                        BT_LE_ADV_OPT_USE_NAME | \
-                                        BT_LE_ADV_OPT_ONE_TIME, \
-                                        BT_GAP_ADV_FAST_INT_MIN_2, \
-                                        BT_GAP_ADV_FAST_INT_MAX_2, NULL)
+#if IS_ENABLED(CONFIG_ZMK_SPLIT_BLE_ROLE_CENTRAL)
+#define PROFILE_COUNT (CONFIG_BT_MAX_PAIRED - 1)
 #else
-#define ZMK_ADV_PARAMS BT_LE_ADV_CONN_NAME
+#define PROFILE_COUNT CONFIG_BT_MAX_PAIRED
 #endif
 
-static void connected(struct bt_conn *conn, u8_t err)
-{
-    char addr[BT_ADDR_LE_STR_LEN];
+static struct zmk_ble_profile profiles[PROFILE_COUNT];
+static u8_t active_profile;
+
+static const struct bt_data zmk_ble_ad[] = {
+    BT_DATA_BYTES(BT_DATA_FLAGS, (BT_LE_AD_GENERAL | BT_LE_AD_NO_BREDR)),
+    BT_DATA_BYTES(BT_DATA_UUID16_SOME,
+#if !IS_ENABLED(CONFIG_ZMK_SPLIT_BLE_ROLE_PERIPHERAL)
+                  0x12, 0x18, /* HID Service */
+#endif
+                  0x0f, 0x18 /* Battery Service */
+                  ),
+#if IS_ENABLED(CONFIG_ZMK_SPLIT_BLE_ROLE_PERIPHERAL)
+    BT_DATA_BYTES(BT_DATA_UUID128_ALL, ZMK_SPLIT_BT_SERVICE_UUID)
+#endif
+};
+
+#if IS_ENABLED(CONFIG_ZMK_SPLIT_BLE_ROLE_CENTRAL)
+
+static bt_addr_le_t peripheral_addr;
+
+#endif /* IS_ENABLED(CONFIG_ZMK_SPLIT_BLE_ROLE_CENTRAL) */
+
+static void raise_profile_changed_event() {
+    struct ble_active_profile_changed *ev = new_ble_active_profile_changed();
+    ev->index = active_profile;
+    ev->profile = &profiles[active_profile];
+
+    ZMK_EVENT_RAISE(ev);
+}
+
+static bool active_profile_is_open() {
+    return !bt_addr_le_cmp(&profiles[active_profile].peer, BT_ADDR_LE_ANY);
+}
+
+void set_profile_address(u8_t index, const bt_addr_le_t *addr) {
+    char setting_name[15];
+    char addr_str[BT_ADDR_LE_STR_LEN];
+
+    bt_addr_le_to_str(addr, addr_str, sizeof(addr_str));
+
+    memcpy(&profiles[index].peer, addr, sizeof(bt_addr_le_t));
+    sprintf(setting_name, "ble/profiles/%d", index);
+    LOG_DBG("Setting profile addr for %s to %s", log_strdup(setting_name), log_strdup(addr_str));
+    settings_save_one(setting_name, &profiles[index], sizeof(struct zmk_ble_profile));
+    raise_profile_changed_event();
+}
+
+int zmk_ble_adv_pause() {
+    int err = bt_le_adv_stop();
+    if (err) {
+        LOG_ERR("Failed to stop advertising (err %d)", err);
+        return err;
+    }
+
+    return 0;
+};
+
+int zmk_ble_adv_resume() {
+    LOG_DBG("active_profile %d, directed? %s", active_profile,
+            active_profile_is_open() ? "no" : "yes");
+
+    int err = bt_le_adv_start(BT_LE_ADV_CONN_NAME, zmk_ble_ad, ARRAY_SIZE(zmk_ble_ad), NULL, 0);
+    if (err) {
+        LOG_ERR("Advertising failed to start (err %d)", err);
+        return err;
+    }
+
+    return 0;
+};
+
+int zmk_ble_clear_bonds() {
+    LOG_DBG("");
+
+    if (bt_addr_le_cmp(&profiles[active_profile].peer, BT_ADDR_LE_ANY)) {
+        LOG_DBG("Unpairing!");
+        bt_unpair(BT_ID_DEFAULT, &profiles[active_profile].peer);
+        set_profile_address(active_profile, BT_ADDR_LE_ANY);
+    }
+
+    return 0;
+};
+
+int zmk_ble_prof_select(u8_t index) {
+    LOG_DBG("profile %d", index);
+    if (active_profile == index) {
+        return 0;
+    }
+
+    active_profile = index;
+    return settings_save_one("ble/active_profile", &active_profile, sizeof(active_profile));
+
+    raise_profile_changed_event();
+};
+
+int zmk_ble_prof_next() {
+    LOG_DBG("");
+    return zmk_ble_prof_select((active_profile + 1) % PROFILE_COUNT);
+};
+
+int zmk_ble_prof_prev() {
+    LOG_DBG("");
+    return zmk_ble_prof_select((active_profile + PROFILE_COUNT - 1) % PROFILE_COUNT);
+};
+
+bt_addr_le_t *zmk_ble_active_profile_addr() { return &profiles[active_profile].peer; }
+
+char *zmk_ble_active_profile_name() { return profiles[active_profile].name; }
+
+#if IS_ENABLED(CONFIG_ZMK_SPLIT_BLE_ROLE_CENTRAL)
+
+void zmk_ble_set_peripheral_addr(bt_addr_le_t *addr) {
+    memcpy(&peripheral_addr, addr, sizeof(bt_addr_le_t));
+    settings_save_one("ble/peripheral_address", addr, sizeof(bt_addr_le_t));
+}
+
+#endif /* IS_ENABLED(CONFIG_ZMK_SPLIT_BLE_ROLE_CENTRAL) */
+
+#if IS_ENABLED(CONFIG_SETTINGS)
+
+static int ble_profiles_handle_set(const char *name, size_t len, settings_read_cb read_cb,
+                                   void *cb_arg) {
+    const char *next;
+
+    LOG_DBG("Setting BLE value %s", log_strdup(name));
+
+    if (settings_name_steq(name, "profiles", &next) && next) {
+        char *endptr;
+        u8_t idx = strtoul(next, &endptr, 10);
+        if (*endptr != '\0') {
+            LOG_WRN("Invalid profile index: %s", log_strdup(next));
+            return -EINVAL;
+        }
+
+        if (len != sizeof(struct zmk_ble_profile)) {
+            LOG_ERR("Invalid profile size (got %d expected %d)", len,
+                    sizeof(struct zmk_ble_profile));
+            return -EINVAL;
+        }
 
+        if (idx >= PROFILE_COUNT) {
+            LOG_WRN("Profile address for index %d is larger than max of %d", idx, PROFILE_COUNT);
+            return -EINVAL;
+        }
+
+        int err = read_cb(cb_arg, &profiles[idx], sizeof(struct zmk_ble_profile));
+        if (err <= 0) {
+            LOG_ERR("Failed to handle profile address from settings (err %d)", err);
+            return err;
+        }
+
+        char addr_str[BT_ADDR_LE_STR_LEN];
+        bt_addr_le_to_str(&profiles[idx].peer, addr_str, sizeof(addr_str));
+
+        LOG_DBG("Loaded %s address for profile %d", log_strdup(addr_str), idx);
+    } else if (settings_name_steq(name, "active_profile", &next) && !next) {
+        if (len != sizeof(active_profile)) {
+            return -EINVAL;
+        }
+
+        int err = read_cb(cb_arg, &active_profile, sizeof(active_profile));
+        if (err <= 0) {
+            LOG_ERR("Failed to handle active profile from settings (err %d)", err);
+            return err;
+        }
+    }
+#if IS_ENABLED(CONFIG_ZMK_SPLIT_BLE_ROLE_CENTRAL)
+    else if (settings_name_steq(name, "peripheral_address", &next) && !next) {
+        if (len != sizeof(bt_addr_le_t)) {
+            return -EINVAL;
+        }
+
+        int err = read_cb(cb_arg, &peripheral_addr, sizeof(bt_addr_le_t));
+        if (err <= 0) {
+            LOG_ERR("Failed to handle peripheral address from settings (err %d)", err);
+            return err;
+        }
+    }
+#endif
+
+    return 0;
+};
+
+struct settings_handler profiles_handler = {.name = "ble", .h_set = ble_profiles_handle_set};
+#endif /* IS_ENABLED(CONFIG_SETTINGS) */
+
+static void connected(struct bt_conn *conn, u8_t err) {
+    char addr[BT_ADDR_LE_STR_LEN];
     bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
 
-    if (err)
-    {
+    if (err) {
         LOG_WRN("Failed to connect to %s (%u)", log_strdup(addr), err);
         return;
     }
@@ -58,36 +247,37 @@ static void connected(struct bt_conn *conn, u8_t err)
     bt_conn_le_phy_update(conn, BT_CONN_LE_PHY_PARAM_2M);
 #endif
 
-    if (bt_conn_set_security(conn, BT_SECURITY_L2))
-    {
+    if (bt_conn_set_security(conn, BT_SECURITY_L2)) {
         LOG_ERR("Failed to set security");
     }
 }
 
-static void disconnected(struct bt_conn *conn, u8_t reason)
-{
+static void disconnected(struct bt_conn *conn, u8_t reason) {
     char addr[BT_ADDR_LE_STR_LEN];
 
     bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
 
     LOG_DBG("Disconnected from %s (reason 0x%02x)", log_strdup(addr), reason);
+
+#if IS_ENABLED(CONFIG_ZMK_SPLIT_BLE_ROLE_CENTRAL)
+    // if (bt_addr_le_cmp(&peripheral_addr, BT_ADDR_LE_ANY) && bt_addr_le_cmp(&peripheral_addr,
+    // bt_conn_get_dst(conn))) {
+    //     zmk_ble_adv_resume();
+    // }
+#else
+    // zmk_ble_adv_resume();
+#endif
 }
 
-static void security_changed(struct bt_conn *conn, bt_security_t level,
-                             enum bt_security_err err)
-{
+static void security_changed(struct bt_conn *conn, bt_security_t level, enum bt_security_err err) {
     char addr[BT_ADDR_LE_STR_LEN];
 
     bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
 
-    if (!err)
-    {
+    if (!err) {
         LOG_DBG("Security changed: %s level %u", log_strdup(addr), level);
-    }
-    else
-    {
-        LOG_ERR("Security failed: %s level %u err %d", log_strdup(addr), level,
-               err);
+    } else {
+        LOG_ERR("Security failed: %s level %u err %d", log_strdup(addr), level, err);
     }
 }
 
@@ -97,8 +287,7 @@ static struct bt_conn_cb conn_callbacks = {
     .security_changed = security_changed,
 };
 
-static void auth_passkey_display(struct bt_conn *conn, unsigned int passkey)
-{
+static void auth_passkey_display(struct bt_conn *conn, unsigned int passkey) {
     char addr[BT_ADDR_LE_STR_LEN];
 
     bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
@@ -108,8 +297,7 @@ static void auth_passkey_display(struct bt_conn *conn, unsigned int passkey)
 
 #ifdef CONFIG_ZMK_BLE_PASSKEY_ENTRY
 
-static void auth_passkey_entry(struct bt_conn *conn)
-{
+static void auth_passkey_entry(struct bt_conn *conn) {
     char addr[BT_ADDR_LE_STR_LEN];
 
     bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
@@ -120,14 +308,12 @@ static void auth_passkey_entry(struct bt_conn *conn)
 
 #endif
 
-static void auth_cancel(struct bt_conn *conn)
-{
+static void auth_cancel(struct bt_conn *conn) {
     char addr[BT_ADDR_LE_STR_LEN];
 
     bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
 
-    if (auth_passkey_entry_conn)
-    {
+    if (auth_passkey_entry_conn) {
         bt_conn_unref(auth_passkey_entry_conn);
         auth_passkey_entry_conn = NULL;
     }
@@ -137,7 +323,51 @@ static void auth_cancel(struct bt_conn *conn)
     LOG_DBG("Pairing cancelled: %s", log_strdup(addr));
 }
 
+#if !IS_ENABLED(CONFIG_ZMK_SPLIT_BLE_ROLE_PERIPHERAL)
+static enum bt_security_err auth_pairing_accept(struct bt_conn *conn,
+                                                const struct bt_conn_pairing_feat *const feat) {
+    struct bt_conn_info info;
+    bt_conn_get_info(conn, &info);
+
+    LOG_DBG("role %d, open? %s", info.role, active_profile_is_open() ? "yes" : "no");
+    if (info.role == BT_CONN_ROLE_SLAVE && !active_profile_is_open()) {
+        LOG_WRN("Rejecting pairing request to taken profile %d", active_profile);
+        return BT_SECURITY_ERR_PAIR_NOT_ALLOWED;
+    }
+
+    return BT_SECURITY_ERR_SUCCESS;
+};
+#endif /* !IS_ENABLED(CONFIG_ZMK_SPLIT_BLE_ROLE_PERIPHERAL) */
+
+static void auth_pairing_complete(struct bt_conn *conn, bool bonded) {
+    struct bt_conn_info info;
+    char addr[BT_ADDR_LE_STR_LEN];
+    const bt_addr_le_t *dst = bt_conn_get_dst(conn);
+
+    bt_addr_le_to_str(dst, addr, sizeof(addr));
+    bt_conn_get_info(conn, &info);
+
+    if (info.role != BT_CONN_ROLE_SLAVE) {
+        LOG_DBG("SKIPPING FOR ROLE %d", info.role);
+        return;
+    }
+
+#if !IS_ENABLED(CONFIG_ZMK_SPLIT_BLE_ROLE_PERIPHERAL)
+    if (!active_profile_is_open()) {
+        LOG_ERR("Pairing completed but current profile is not open: %s", log_strdup(addr));
+        bt_unpair(BT_ID_DEFAULT, dst);
+        return;
+    }
+#endif /* !IS_ENABLED(CONFIG_ZMK_SPLIT_BLE_ROLE_PERIPHERAL) */
+
+    set_profile_address(active_profile, dst);
+};
+
 static struct bt_conn_auth_cb zmk_ble_auth_cb_display = {
+#if !IS_ENABLED(CONFIG_ZMK_SPLIT_BLE_ROLE_PERIPHERAL)
+    .pairing_accept = auth_pairing_accept,
+#endif /* !IS_ENABLED(CONFIG_ZMK_SPLIT_BLE_ROLE_PERIPHERAL) */
+    .pairing_complete = auth_pairing_complete,
 // .passkey_display = auth_passkey_display,
 
 #ifdef CONFIG_ZMK_BLE_PASSKEY_ENTRY
@@ -146,51 +376,54 @@ static struct bt_conn_auth_cb zmk_ble_auth_cb_display = {
     .cancel = auth_cancel,
 };
 
-static const struct bt_data zmk_ble_ad[] = {
-    BT_DATA_BYTES(BT_DATA_FLAGS, (BT_LE_AD_GENERAL | BT_LE_AD_NO_BREDR)),
-    BT_DATA_BYTES(BT_DATA_UUID16_SOME,
-#if !IS_ENABLED(CONFIG_ZMK_SPLIT_BLE_ROLE_PERIPHERAL)
-                  0x12, 0x18,  /* HID Service */
-#endif
-                  0x0f, 0x18 /* Battery Service */
-    ),
-#if IS_ENABLED(CONFIG_ZMK_SPLIT_BLE_ROLE_PERIPHERAL)
-    BT_DATA_BYTES(BT_DATA_UUID128_ALL,
-                  ZMK_SPLIT_BT_SERVICE_UUID)
-#endif
-};
-
-static void zmk_ble_ready(int err)
-{
+static void zmk_ble_ready(int err) {
     LOG_DBG("ready? %d", err);
-    if (err)
-    {
+    if (err) {
         LOG_ERR("Bluetooth init failed (err %d)", err);
         return;
     }
 
-    err = bt_le_adv_start(ZMK_ADV_PARAMS, zmk_ble_ad, ARRAY_SIZE(zmk_ble_ad), NULL, 0);
-    if (err)
-    {
-        LOG_ERR("Advertising failed to start (err %d)", err);
-        return;
-    }
+    zmk_ble_adv_resume();
 }
 
-static int zmk_ble_init(struct device *_arg)
-{
+static int zmk_ble_init(struct device *_arg) {
     int err = bt_enable(NULL);
 
-    if (err)
-    {
+    if (err) {
         LOG_ERR("BLUETOOTH FAILED (%d)", err);
         return err;
     }
 
-    if (IS_ENABLED(CONFIG_BT_SETTINGS))
-    {
-        settings_load();
+#if IS_ENABLED(CONFIG_SETTINGS)
+    settings_subsys_init();
+
+    err = settings_register(&profiles_handler);
+    if (err) {
+        LOG_ERR("Failed to setup the profile settings handler (err %d)", err);
+        return err;
+    }
+
+    settings_load();
+
+#endif
+
+#if IS_ENABLED(CONFIG_ZMK_BLE_CLEAR_BONDS_ON_START)
+    LOG_WRN("Clearing all existing BLE bond information from the keyboard");
+
+    for (int i = 0; i < 10; i++) {
+        bt_unpair(i, NULL);
+    }
+
+    for (int i = 0; i < PROFILE_COUNT; i++) {
+        char setting_name[15];
+        sprintf(setting_name, "ble/profiles/%d", i);
+
+        err = settings_delete(setting_name);
+        if (err) {
+            LOG_ERR("Failed to delete setting: %d", err);
+        }
     }
+#endif
 
     bt_conn_cb_register(&conn_callbacks);
     bt_conn_auth_cb_register(&zmk_ble_auth_cb_display);
@@ -200,23 +433,28 @@ static int zmk_ble_init(struct device *_arg)
     return 0;
 }
 
-int zmk_ble_unpair_all()
-{
-    LOG_DBG("");
-    return bt_unpair(BT_ID_DEFAULT, NULL);
+int zmk_ble_unpair_all() {
+    int resp = 0;
+    for (int i = BT_ID_DEFAULT; i < CONFIG_BT_ID_MAX; i++) {
+
+        int err = bt_unpair(BT_ID_DEFAULT, NULL);
+        if (err) {
+            resp = err;
+            LOG_ERR("Failed to unpair devices (err %d)", err);
+        }
+    }
+
+    return resp;
 };
 
-bool zmk_ble_handle_key_user(struct zmk_key_event *key_event)
-{
+bool zmk_ble_handle_key_user(struct zmk_key_event *key_event) {
     zmk_key key = key_event->key;
 
-    if (!auth_passkey_entry_conn)
-    {
+    if (!auth_passkey_entry_conn) {
         return true;
     }
 
-    if (key < NUM_1 || key > NUM_0)
-    {
+    if (key < NUM_1 || key > NUM_0) {
         return true;
     }
 
@@ -224,11 +462,9 @@ bool zmk_ble_handle_key_user(struct zmk_key_event *key_event)
 
     passkey_entries[passkey_digit++] = val;
 
-    if (passkey_digit == 6)
-    {
+    if (passkey_digit == 6) {
         u32_t passkey = 0;
-        for (int i = 5; i >= 0; i--)
-        {
+        for (int i = 5; i >= 0; i--) {
             passkey = (passkey * 10) + val;
         }
         bt_conn_auth_passkey_entry(auth_passkey_entry_conn, passkey);
@@ -239,6 +475,4 @@ bool zmk_ble_handle_key_user(struct zmk_key_event *key_event)
     return false;
 }
 
-SYS_INIT(zmk_ble_init,
-        APPLICATION,
-        CONFIG_ZMK_BLE_INIT_PRIORITY);
+SYS_INIT(zmk_ble_init, APPLICATION, CONFIG_ZMK_BLE_INIT_PRIORITY);
diff --git a/app/src/ble_unpair_combo.c b/app/src/ble_unpair_combo.c
index a33a8e2..b6e542d 100644
--- a/app/src/ble_unpair_combo.c
+++ b/app/src/ble_unpair_combo.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Peter Johanson
+ * Copyright (c) 2020 The ZMK Contributors
  *
  * SPDX-License-Identifier: MIT
  */
@@ -7,24 +7,23 @@
 #include <device.h>
 #include <init.h>
 
-#include <logging/log.h>
-
 #define DT_DRV_COMPAT zmk_bt_unpair_combo
 
+#if DT_HAS_COMPAT_STATUS_OKAY(DT_DRV_COMPAT)
+
+#include <logging/log.h>
 LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
 
 #include <zmk/ble.h>
 #include <zmk/event-manager.h>
 #include <zmk/events/position-state-changed.h>
 
-
 static u8_t combo_state;
 
 const u32_t key_positions[] = DT_INST_PROP(0, key_positions);
 #define KP_LEN DT_INST_PROP_LEN(0, key_positions)
 
-int index_for_key_position(u32_t kp)
-{
+int index_for_key_position(u32_t kp) {
     for (int i = 0; i < KP_LEN; i++) {
         if (key_positions[i] == kp) {
             return i;
@@ -34,8 +33,7 @@ int index_for_key_position(u32_t kp)
     return -1;
 }
 
-int unpair_combo_listener(const struct zmk_event_header *eh)
-{
+int unpair_combo_listener(const struct zmk_event_header *eh) {
     if (is_position_state_changed(eh)) {
         const struct position_state_changed *psc = cast_position_state_changed(eh);
 
@@ -50,8 +48,7 @@ int unpair_combo_listener(const struct zmk_event_header *eh)
     return 0;
 };
 
-void unpair_combo_work_handler(struct k_work *work)
-{
+void unpair_combo_work_handler(struct k_work *work) {
     for (int i = 0; i < KP_LEN; i++) {
         if (!(combo_state & BIT(i))) {
             LOG_DBG("Key position %d not held, skipping unpair combo", key_positions[i]);
@@ -64,8 +61,7 @@ void unpair_combo_work_handler(struct k_work *work)
 
 struct k_delayed_work unpair_combo_work;
 
-int zmk_ble_unpair_combo_init(struct device *_unused)
-{
+int zmk_ble_unpair_combo_init(struct device *_unused) {
     k_delayed_work_init(&unpair_combo_work, unpair_combo_work_handler);
     k_delayed_work_submit(&unpair_combo_work, K_SECONDS(2));
 
@@ -75,6 +71,6 @@ int zmk_ble_unpair_combo_init(struct device *_unused)
 ZMK_LISTENER(zmk_ble_unpair_combo, unpair_combo_listener);
 ZMK_SUBSCRIPTION(zmk_ble_unpair_combo, position_state_changed);
 
-SYS_INIT(zmk_ble_unpair_combo_init,
-        APPLICATION,
-        CONFIG_APPLICATION_INIT_PRIORITY);
+SYS_INIT(zmk_ble_unpair_combo_init, APPLICATION, CONFIG_APPLICATION_INIT_PRIORITY);
+
+#endif /* DT_HAS_COMPAT_STATUS_OKAY(DT_DRV_COMPAT) */
diff --git a/app/src/display.c b/app/src/display.c
index 9021914..ecd1908 100644
--- a/app/src/display.c
+++ b/app/src/display.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Peter Johanson
+ * Copyright (c) 2020 The ZMK Contributors
  *
  * SPDX-License-Identifier: MIT
  */
@@ -20,8 +20,7 @@ static struct device *display;
 
 static lv_obj_t *screen;
 
-int zmk_display_init()
-{
+int zmk_display_init() {
     lv_obj_t *hello_world_label;
     lv_obj_t *count_label;
 
@@ -48,8 +47,7 @@ int zmk_display_init()
     return 0;
 }
 
-void zmk_display_task_handler()
-{
+void zmk_display_task_handler() {
     lv_tick_inc(10);
     lv_task_handler();
     k_sleep(K_MSEC(10));
diff --git a/app/src/endpoints.c b/app/src/endpoints.c
index c9ba716..ae78587 100644
--- a/app/src/endpoints.c
+++ b/app/src/endpoints.c
@@ -1,3 +1,8 @@
+/*
+ * Copyright (c) 2020 The ZMK Contributors
+ *
+ * SPDX-License-Identifier: MIT
+ */
 
 #include <zmk/endpoints.h>
 #include <zmk/hid.h>
@@ -7,27 +12,24 @@
 #include <logging/log.h>
 LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
 
-int zmk_endpoints_send_report(u8_t usage_page)
-{
+int zmk_endpoints_send_report(u8_t usage_page) {
     int err;
     struct zmk_hid_keypad_report *keypad_report;
     struct zmk_hid_consumer_report *consumer_report;
     LOG_DBG("usage page 0x%02X", usage_page);
-    switch (usage_page)
-    {
+    switch (usage_page) {
     case USAGE_KEYPAD:
         keypad_report = zmk_hid_get_keypad_report();
 #ifdef CONFIG_ZMK_USB
-        if (zmk_usb_hid_send_report((u8_t *)keypad_report, sizeof(struct zmk_hid_keypad_report)) != 0)
-        {
+        if (zmk_usb_hid_send_report((u8_t *)keypad_report, sizeof(struct zmk_hid_keypad_report)) !=
+            0) {
             LOG_DBG("USB Send Failed");
         }
 #endif /* CONFIG_ZMK_USB */
 
 #ifdef CONFIG_ZMK_BLE
         err = zmk_hog_send_keypad_report(&keypad_report->body);
-        if (err)
-        {
+        if (err) {
             LOG_ERR("FAILED TO SEND OVER HOG: %d", err);
         }
 #endif /* CONFIG_ZMK_BLE */
@@ -36,16 +38,15 @@ int zmk_endpoints_send_report(u8_t usage_page)
     case USAGE_CONSUMER:
         consumer_report = zmk_hid_get_consumer_report();
 #ifdef CONFIG_ZMK_USB
-        if (zmk_usb_hid_send_report((u8_t *)consumer_report, sizeof(struct zmk_hid_consumer_report)) != 0)
-        {
+        if (zmk_usb_hid_send_report((u8_t *)consumer_report,
+                                    sizeof(struct zmk_hid_consumer_report)) != 0) {
             LOG_DBG("USB Send Failed");
         }
 #endif /* CONFIG_ZMK_USB */
 
 #ifdef CONFIG_ZMK_BLE
         err = zmk_hog_send_consumer_report(&consumer_report->body);
-        if (err)
-        {
+        if (err) {
             LOG_ERR("FAILED TO SEND OVER HOG: %d", err);
         }
 #endif /* CONFIG_ZMK_BLE */
@@ -58,4 +59,3 @@ int zmk_endpoints_send_report(u8_t usage_page)
 
     return 0;
 }
-
diff --git a/app/src/event_manager.c b/app/src/event_manager.c
index c405176..226f3ce 100644
--- a/app/src/event_manager.c
+++ b/app/src/event_manager.c
@@ -1,9 +1,9 @@
 /*
- * Copyright (c) 2020 Peter Johanson <peter@peterjohanson.com>
+ * Copyright (c) 2020 The ZMK Contributors
  *
  * SPDX-License-Identifier: MIT
  */
- 
+
 #include <zephyr.h>
 #include <logging/log.h>
 
@@ -11,15 +11,13 @@ LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
 
 #include <zmk/event-manager.h>
 
-extern struct zmk_event_type* __event_type_start[];
-extern struct zmk_event_type* __event_type_end[];
+extern struct zmk_event_type *__event_type_start[];
+extern struct zmk_event_type *__event_type_end[];
 
 extern struct zmk_event_subscription __event_subscriptions_start[];
 extern struct zmk_event_subscription __event_subscriptions_end[];
 
-
-int zmk_event_manager_handle_from(struct zmk_event_header *event, u8_t start_index)
-{
+int zmk_event_manager_handle_from(struct zmk_event_header *event, u8_t start_index) {
     int ret = 0;
     u8_t len = __event_subscriptions_end - __event_subscriptions_start;
     for (int i = start_index; i < len; i++) {
@@ -31,15 +29,15 @@ int zmk_event_manager_handle_from(struct zmk_event_header *event, u8_t start_ind
                 goto release;
             } else if (ret > 0) {
                 switch (ret) {
-                    case ZMK_EV_EVENT_HANDLED:
-                        LOG_DBG("Listener handled the event");
-                        ret = 0;
-                        goto release;
-                    case ZMK_EV_EVENT_CAPTURED:
-                        LOG_DBG("Listener captured the event");
-                        event->last_listener_index = i;
-                        // Listeners are expected to free events they capture
-                        return 0;
+                case ZMK_EV_EVENT_HANDLED:
+                    LOG_DBG("Listener handled the event");
+                    ret = 0;
+                    goto release;
+                case ZMK_EV_EVENT_CAPTURED:
+                    LOG_DBG("Listener captured the event");
+                    event->last_listener_index = i;
+                    // Listeners are expected to free events they capture
+                    return 0;
                 }
             }
         }
@@ -50,19 +48,18 @@ release:
     return ret;
 }
 
-int zmk_event_manager_raise(struct zmk_event_header *event)
-{
+int zmk_event_manager_raise(struct zmk_event_header *event) {
     return zmk_event_manager_handle_from(event, 0);
 }
 
-int zmk_event_manager_raise_after(struct zmk_event_header *event, const struct zmk_listener *listener)
-{
+int zmk_event_manager_raise_after(struct zmk_event_header *event,
+                                  const struct zmk_listener *listener) {
     u8_t len = __event_subscriptions_end - __event_subscriptions_start;
     for (int i = 0; i < len; i++) {
         struct zmk_event_subscription *ev_sub = __event_subscriptions_start + i;
 
         if (ev_sub->event_type == event->event && ev_sub->listener == listener) {
-            return zmk_event_manager_handle_from(event, i+1);
+            return zmk_event_manager_handle_from(event, i + 1);
         }
     }
 
@@ -71,7 +68,22 @@ int zmk_event_manager_raise_after(struct zmk_event_header *event, const struct z
     return -EINVAL;
 }
 
-int zmk_event_manager_release(struct zmk_event_header *event)
-{
+int zmk_event_manager_raise_at(struct zmk_event_header *event,
+                               const struct zmk_listener *listener) {
+    u8_t len = __event_subscriptions_end - __event_subscriptions_start;
+    for (int i = 0; i < len; i++) {
+        struct zmk_event_subscription *ev_sub = __event_subscriptions_start + i;
+
+        if (ev_sub->event_type == event->event && ev_sub->listener == listener) {
+            return zmk_event_manager_handle_from(event, i);
+        }
+    }
+
+    LOG_WRN("Unable to find where to raise this event");
+
+    return -EINVAL;
+}
+
+int zmk_event_manager_release(struct zmk_event_header *event) {
     return zmk_event_manager_handle_from(event, event->last_listener_index + 1);
-}
\ No newline at end of file
+}
diff --git a/app/src/events/ble_active_profile_changed.c b/app/src/events/ble_active_profile_changed.c
new file mode 100644
index 0000000..a270a14
--- /dev/null
+++ b/app/src/events/ble_active_profile_changed.c
@@ -0,0 +1,10 @@
+/*
+ * Copyright (c) 2020 Peter Johanson <peter@peterjohanson.com>
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#include <kernel.h>
+#include <zmk/events/ble-active-profile-changed.h>
+
+ZMK_EVENT_IMPL(ble_active_profile_changed);
\ No newline at end of file
diff --git a/app/src/events/keycode_state_changed.c b/app/src/events/keycode_state_changed.c
index 73508e1..9a1984a 100644
--- a/app/src/events/keycode_state_changed.c
+++ b/app/src/events/keycode_state_changed.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Peter Johanson <peter@peterjohanson.com>
+ * Copyright (c) 2020 The ZMK Contributors
  *
  * SPDX-License-Identifier: MIT
  */
diff --git a/app/src/events/modifiers_state_changed.c b/app/src/events/modifiers_state_changed.c
index 71ec015..8becd02 100644
--- a/app/src/events/modifiers_state_changed.c
+++ b/app/src/events/modifiers_state_changed.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Peter Johanson <peter@peterjohanson.com>
+ * Copyright (c) 2020 The ZMK Contributors
  *
  * SPDX-License-Identifier: MIT
  */
diff --git a/app/src/events/position_state_changed.c b/app/src/events/position_state_changed.c
index 69cba03..f8f1a26 100644
--- a/app/src/events/position_state_changed.c
+++ b/app/src/events/position_state_changed.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Peter Johanson <peter@peterjohanson.com>
+ * Copyright (c) 2020 The ZMK Contributors
  *
  * SPDX-License-Identifier: MIT
  */
diff --git a/app/src/events/sensor_event.c b/app/src/events/sensor_event.c
index 1b0302d..c6b80cd 100644
--- a/app/src/events/sensor_event.c
+++ b/app/src/events/sensor_event.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Peter Johanson <peter@peterjohanson.com>
+ * Copyright (c) 2020 The ZMK Contributors
  *
  * SPDX-License-Identifier: MIT
  */
diff --git a/app/src/hid.c b/app/src/hid.c
index ca04056..f80906c 100644
--- a/app/src/hid.c
+++ b/app/src/hid.c
@@ -1,44 +1,36 @@
+/*
+ * Copyright (c) 2020 The ZMK Contributors
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
 #include <logging/log.h>
 LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
 
 #include <zmk/hid.h>
 
 static struct zmk_hid_keypad_report kp_report = {
-    .report_id = 1,
-    .body = {
-        .modifiers = 0,
-        .keys = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}};
-
-static struct zmk_hid_consumer_report consumer_report = {
-    .report_id = 2,
-    .body = {
-        .keys = {0,0,0,0,0,0}}};
-
-#define _TOGGLE_MOD(mod, state)                      \
-    if (modifier > MOD_RGUI)                         \
-    {                                                \
-        return -EINVAL;                              \
-    }                                                \
-    WRITE_BIT(kp_report.body.modifiers, mod, state); \
+    .report_id = 1, .body = {.modifiers = 0, .keys = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}};
+
+static struct zmk_hid_consumer_report consumer_report = {.report_id = 2,
+                                                         .body = {.keys = {0, 0, 0, 0, 0, 0}}};
+
+#define _TOGGLE_MOD(mod, state)                                                                    \
+    if (modifier > MOD_RGUI) {                                                                     \
+        return -EINVAL;                                                                            \
+    }                                                                                              \
+    WRITE_BIT(kp_report.body.modifiers, mod, state);                                               \
     return 0;
 
-int zmk_hid_register_mod(zmk_mod modifier)
-{
-    _TOGGLE_MOD(modifier, true);
-}
-int zmk_hid_unregister_mod(zmk_mod modifier)
-{
-    _TOGGLE_MOD(modifier, false);
-}
+int zmk_hid_register_mod(zmk_mod modifier) { _TOGGLE_MOD(modifier, true); }
+int zmk_hid_unregister_mod(zmk_mod modifier) { _TOGGLE_MOD(modifier, false); }
 
-int zmk_hid_register_mods(zmk_mod_flags modifiers)
-{
+int zmk_hid_register_mods(zmk_mod_flags modifiers) {
     kp_report.body.modifiers |= modifiers;
     return 0;
 }
 
-int zmk_hid_unregister_mods(zmk_mod_flags modifiers)
-{
+int zmk_hid_unregister_mods(zmk_mod_flags modifiers) {
     kp_report.body.modifiers &= ~modifiers;
     return 0;
 }
@@ -61,28 +53,21 @@ int zmk_hid_unregister_mods(zmk_mod_flags modifiers)
 
 #define TOGGLE_KEY(code, val) WRITE_BIT(kp_report.body.keys[code / 8], code % 8, val)
 
-#define TOGGLE_CONSUMER(match, val)                  \
-    for (int idx = 0; idx < MAX_KEYS; idx++)         \
-    {                                                \
-        if (consumer_report.body.keys[idx] != match) \
-        {                                            \
-            continue;                                \
-        }                                            \
-        consumer_report.body.keys[idx] = val;        \
-        break;                                       \
+#define TOGGLE_CONSUMER(match, val)                                                                \
+    for (int idx = 0; idx < MAX_KEYS; idx++) {                                                     \
+        if (consumer_report.body.keys[idx] != match) {                                             \
+            continue;                                                                              \
+        }                                                                                          \
+        consumer_report.body.keys[idx] = val;                                                      \
+        break;                                                                                     \
     }
 
-
-int zmk_hid_keypad_press(zmk_key code)
-{
-    if (code >= LCTL && code <= RGUI)
-    {
+int zmk_hid_keypad_press(zmk_key code) {
+    if (code >= LCTL && code <= RGUI) {
         return zmk_hid_register_mod(code - LCTL);
     }
 
-   
-    if (code > ZMK_HID_MAX_KEYCODE)
-    {
+    if (code > ZMK_HID_MAX_KEYCODE) {
         return -EINVAL;
     }
 
@@ -93,15 +78,12 @@ int zmk_hid_keypad_press(zmk_key code)
     return 0;
 };
 
-int zmk_hid_keypad_release(zmk_key code)
-{
-    if (code >= LCTL && code <= RGUI)
-    {
+int zmk_hid_keypad_release(zmk_key code) {
+    if (code >= LCTL && code <= RGUI) {
         return zmk_hid_unregister_mod(code - LCTL);
     }
 
-    if (code > ZMK_HID_MAX_KEYCODE)
-    {
+    if (code > ZMK_HID_MAX_KEYCODE) {
         return -EINVAL;
     }
 
@@ -112,25 +94,20 @@ int zmk_hid_keypad_release(zmk_key code)
     return 0;
 };
 
-int zmk_hid_consumer_press(zmk_key code)
-{
+int zmk_hid_consumer_press(zmk_key code) {
     TOGGLE_CONSUMER(0U, code);
     return 0;
 };
 
-
-int zmk_hid_consumer_release(zmk_key code)
-{
+int zmk_hid_consumer_release(zmk_key code) {
     TOGGLE_CONSUMER(code, 0U);
     return 0;
 };
 
-struct zmk_hid_keypad_report *zmk_hid_get_keypad_report()
-{
+struct zmk_hid_keypad_report *zmk_hid_get_keypad_report() {
     return &kp_report;
 }
 
-struct zmk_hid_consumer_report *zmk_hid_get_consumer_report()
-{
+struct zmk_hid_consumer_report *zmk_hid_get_consumer_report() {
     return &consumer_report;
 }
diff --git a/app/src/hid_listener.c b/app/src/hid_listener.c
index 69aa23e..4467e6d 100644
--- a/app/src/hid_listener.c
+++ b/app/src/hid_listener.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Peter Johanson <peter@peterjohanson.com>
+ * Copyright (c) 2020 The ZMK Contributors
  *
  * SPDX-License-Identifier: MIT
  */
@@ -15,90 +15,84 @@ LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
 #include <zmk/hid.h>
 #include <zmk/endpoints.h>
 
+static int hid_listener_keycode_pressed(u8_t usage_page, u32_t keycode) {
+    int err;
+    LOG_DBG("usage_page 0x%02X keycode 0x%02X", usage_page, keycode);
 
-static int hid_listener_keycode_pressed(u8_t usage_page, u32_t keycode)
-{
-  int err;
-  LOG_DBG("usage_page 0x%02X keycode 0x%02X", usage_page, keycode);
-  
-  switch (usage_page) {
-  case USAGE_KEYPAD:
-    err = zmk_hid_keypad_press(keycode);
-    if (err) {
-      LOG_ERR("Unable to press keycode");
-      return err;
+    switch (usage_page) {
+    case USAGE_KEYPAD:
+        err = zmk_hid_keypad_press(keycode);
+        if (err) {
+            LOG_ERR("Unable to press keycode");
+            return err;
+        }
+        break;
+    case USAGE_CONSUMER:
+        err = zmk_hid_consumer_press(keycode);
+        if (err) {
+            LOG_ERR("Unable to press keycode");
+            return err;
+        }
+        break;
     }
-    break;
-  case USAGE_CONSUMER:
-    err = zmk_hid_consumer_press(keycode);
-    if (err) {
-      LOG_ERR("Unable to press keycode");
-      return err;
-    }
-    break;
-  }
 
-  return zmk_endpoints_send_report(usage_page);
+    return zmk_endpoints_send_report(usage_page);
 }
 
-static int hid_listener_keycode_released(u8_t usage_page, u32_t keycode)
-{
-  int err;
-  LOG_DBG("usage_page 0x%02X keycode 0x%02X", usage_page, keycode);
-  
-  switch (usage_page) {
-  case USAGE_KEYPAD:
-    err = zmk_hid_keypad_release(keycode);
-    if (err) {
-      LOG_ERR("Unable to release keycode");
-      return err;
-    }
-    break;
-  case USAGE_CONSUMER:
-    err = zmk_hid_consumer_release(keycode);
-    if (err) {
-      LOG_ERR("Unable to release keycode");
-      return err;
+static int hid_listener_keycode_released(u8_t usage_page, u32_t keycode) {
+    int err;
+    LOG_DBG("usage_page 0x%02X keycode 0x%02X", usage_page, keycode);
+
+    switch (usage_page) {
+    case USAGE_KEYPAD:
+        err = zmk_hid_keypad_release(keycode);
+        if (err) {
+            LOG_ERR("Unable to release keycode");
+            return err;
+        }
+        break;
+    case USAGE_CONSUMER:
+        err = zmk_hid_consumer_release(keycode);
+        if (err) {
+            LOG_ERR("Unable to release keycode");
+            return err;
+        }
+        break;
     }
-    break;
-  }
-  return zmk_endpoints_send_report(usage_page);
+    return zmk_endpoints_send_report(usage_page);
 }
 
-static int hid_listener_modifiers_pressed(zmk_mod_flags modifiers)
-{
-  LOG_DBG("modifiers %d", modifiers);
-  
-  zmk_hid_register_mods(modifiers);
-  return zmk_endpoints_send_report(USAGE_KEYPAD);
+static int hid_listener_modifiers_pressed(zmk_mod_flags modifiers) {
+    LOG_DBG("modifiers %d", modifiers);
+
+    zmk_hid_register_mods(modifiers);
+    return zmk_endpoints_send_report(USAGE_KEYPAD);
 }
 
-static int hid_listener_modifiers_released(zmk_mod_flags modifiers)
-{
-  LOG_DBG("modifiers %d", modifiers);
-  
-  zmk_hid_unregister_mods(modifiers);
-  return zmk_endpoints_send_report(USAGE_KEYPAD);
+static int hid_listener_modifiers_released(zmk_mod_flags modifiers) {
+    LOG_DBG("modifiers %d", modifiers);
+
+    zmk_hid_unregister_mods(modifiers);
+    return zmk_endpoints_send_report(USAGE_KEYPAD);
 }
 
-int hid_listener(const struct zmk_event_header *eh)
-{
-  if (is_keycode_state_changed(eh)) {
-    const struct keycode_state_changed *ev = cast_keycode_state_changed(eh);
-    if (ev->state) {
-      hid_listener_keycode_pressed(ev->usage_page, ev->keycode);
-    } else {
-      hid_listener_keycode_released(ev->usage_page, ev->keycode);
-    }
-  } else if (is_modifiers_state_changed(eh)) {
-    const struct modifiers_state_changed *ev = cast_modifiers_state_changed(eh);
-    if (ev->state) {
-      hid_listener_modifiers_pressed(ev->modifiers);
-    } else {
-      hid_listener_modifiers_released(ev->modifiers);
+int hid_listener(const struct zmk_event_header *eh) {
+    if (is_keycode_state_changed(eh)) {
+        const struct keycode_state_changed *ev = cast_keycode_state_changed(eh);
+        if (ev->state) {
+            hid_listener_keycode_pressed(ev->usage_page, ev->keycode);
+        } else {
+            hid_listener_keycode_released(ev->usage_page, ev->keycode);
+        }
+    } else if (is_modifiers_state_changed(eh)) {
+        const struct modifiers_state_changed *ev = cast_modifiers_state_changed(eh);
+        if (ev->state) {
+            hid_listener_modifiers_pressed(ev->modifiers);
+        } else {
+            hid_listener_modifiers_released(ev->modifiers);
+        }
     }
-  }
-  return 0;
+    return 0;
 }
 
 ZMK_LISTENER(hid_listener, hid_listener);
diff --git a/app/src/hog.c b/app/src/hog.c
index 589c28f..11349ac 100644
--- a/app/src/hog.c
+++ b/app/src/hog.c
@@ -1,5 +1,15 @@
+/*
+ * Copyright (c) 2020 The ZMK Contributors
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
 #include <settings/settings.h>
 
+#include <logging/log.h>
+
+LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
+
 #include <bluetooth/bluetooth.h>
 #include <bluetooth/gatt.h>
 
@@ -7,21 +17,18 @@
 #include <zmk/hog.h>
 #include <zmk/hid.h>
 
-enum
-{
+enum {
     HIDS_REMOTE_WAKE = BIT(0),
     HIDS_NORMALLY_CONNECTABLE = BIT(1),
 };
 
-struct hids_info
-{
+struct hids_info {
     u16_t version; /* version number of base USB HID Specification */
     u8_t code;     /* country HID Device hardware is localized for. */
     u8_t flags;
 } __packed;
 
-struct hids_report
-{
+struct hids_report {
     u8_t id;   /* report id */
     u8_t type; /* report type */
 } __packed;
@@ -32,8 +39,7 @@ static struct hids_info info = {
     .flags = HIDS_NORMALLY_CONNECTABLE & HIDS_REMOTE_WAKE,
 };
 
-enum
-{
+enum {
     HIDS_INPUT = 0x01,
     HIDS_OUTPUT = 0x02,
     HIDS_FEATURE = 0x03,
@@ -53,31 +59,37 @@ static bool host_requests_notification = false;
 static u8_t ctrl_point;
 // static u8_t proto_mode;
 
-static ssize_t read_hids_info(struct bt_conn *conn, const struct bt_gatt_attr *attr, void *buf, u16_t len, u16_t offset)
-{
-    return bt_gatt_attr_read(conn, attr, buf, len, offset, attr->user_data, sizeof(struct hids_info));
+static ssize_t read_hids_info(struct bt_conn *conn, const struct bt_gatt_attr *attr, void *buf,
+                              u16_t len, u16_t offset) {
+    return bt_gatt_attr_read(conn, attr, buf, len, offset, attr->user_data,
+                             sizeof(struct hids_info));
 }
 
-static ssize_t read_hids_report_ref(struct bt_conn *conn, const struct bt_gatt_attr *attr, void *buf, u16_t len, u16_t offset)
-{
-    return bt_gatt_attr_read(conn, attr, buf, len, offset, attr->user_data, sizeof(struct hids_report));
+static ssize_t read_hids_report_ref(struct bt_conn *conn, const struct bt_gatt_attr *attr,
+                                    void *buf, u16_t len, u16_t offset) {
+    return bt_gatt_attr_read(conn, attr, buf, len, offset, attr->user_data,
+                             sizeof(struct hids_report));
 }
 
-static ssize_t read_hids_report_map(struct bt_conn *conn, const struct bt_gatt_attr *attr, void *buf, u16_t len, u16_t offset)
-{
-    return bt_gatt_attr_read(conn, attr, buf, len, offset, zmk_hid_report_desc, sizeof(zmk_hid_report_desc));
+static ssize_t read_hids_report_map(struct bt_conn *conn, const struct bt_gatt_attr *attr,
+                                    void *buf, u16_t len, u16_t offset) {
+    return bt_gatt_attr_read(conn, attr, buf, len, offset, zmk_hid_report_desc,
+                             sizeof(zmk_hid_report_desc));
 }
 
-static ssize_t read_hids_input_report(struct bt_conn *conn, const struct bt_gatt_attr *attr, void *buf, u16_t len, u16_t offset)
-{
+static ssize_t read_hids_input_report(struct bt_conn *conn, const struct bt_gatt_attr *attr,
+                                      void *buf, u16_t len, u16_t offset) {
     struct zmk_hid_keypad_report_body *report_body = &zmk_hid_get_keypad_report()->body;
-    return bt_gatt_attr_read(conn, attr, buf, len, offset, report_body, sizeof(struct zmk_hid_keypad_report_body));
+    return bt_gatt_attr_read(conn, attr, buf, len, offset, report_body,
+                             sizeof(struct zmk_hid_keypad_report_body));
 }
 
-static ssize_t read_hids_consumer_input_report(struct bt_conn *conn, const struct bt_gatt_attr *attr, void *buf, u16_t len, u16_t offset)
-{
+static ssize_t read_hids_consumer_input_report(struct bt_conn *conn,
+                                               const struct bt_gatt_attr *attr, void *buf,
+                                               u16_t len, u16_t offset) {
     struct zmk_hid_consumer_report_body *report_body = &zmk_hid_get_consumer_report()->body;
-    return bt_gatt_attr_read(conn, attr, buf, len, offset, report_body, sizeof(struct zmk_hid_consumer_report_body));
+    return bt_gatt_attr_read(conn, attr, buf, len, offset, report_body,
+                             sizeof(struct zmk_hid_consumer_report_body));
 }
 
 // static ssize_t write_proto_mode(struct bt_conn *conn,
@@ -89,20 +101,15 @@ static ssize_t read_hids_consumer_input_report(struct bt_conn *conn, const struc
 //     return 0;
 // }
 
-static void input_ccc_changed(const struct bt_gatt_attr *attr, u16_t value)
-{
+static void input_ccc_changed(const struct bt_gatt_attr *attr, u16_t value) {
     host_requests_notification = (value == BT_GATT_CCC_NOTIFY) ? 1 : 0;
 }
 
-static ssize_t write_ctrl_point(struct bt_conn *conn,
-                                const struct bt_gatt_attr *attr,
-                                const void *buf, u16_t len, u16_t offset,
-                                u8_t flags)
-{
+static ssize_t write_ctrl_point(struct bt_conn *conn, const struct bt_gatt_attr *attr,
+                                const void *buf, u16_t len, u16_t offset, u8_t flags) {
     u8_t *value = attr->user_data;
 
-    if (offset + len > sizeof(ctrl_point))
-    {
+    if (offset + len > sizeof(ctrl_point)) {
         return BT_GATT_ERR(BT_ATT_ERR_INVALID_OFFSET);
     }
 
@@ -112,42 +119,61 @@ static ssize_t write_ctrl_point(struct bt_conn *conn,
 }
 
 /* HID Service Declaration */
-BT_GATT_SERVICE_DEFINE(hog_svc,
-                       BT_GATT_PRIMARY_SERVICE(BT_UUID_HIDS),
-                       //    BT_GATT_CHARACTERISTIC(BT_UUID_HIDS_PROTOCOL_MODE, BT_GATT_CHRC_WRITE_WITHOUT_RESP,
-                       //                           BT_GATT_PERM_WRITE, NULL, write_proto_mode, &proto_mode),
-                       BT_GATT_CHARACTERISTIC(BT_UUID_HIDS_INFO, BT_GATT_CHRC_READ,
-                                              BT_GATT_PERM_READ, read_hids_info, NULL, &info),
-                       BT_GATT_CHARACTERISTIC(BT_UUID_HIDS_REPORT_MAP, BT_GATT_CHRC_READ,
-                                              BT_GATT_PERM_READ, read_hids_report_map, NULL, NULL),
-
-                       BT_GATT_CHARACTERISTIC(BT_UUID_HIDS_REPORT,
-                                              BT_GATT_CHRC_READ | BT_GATT_CHRC_NOTIFY,
-                                              BT_GATT_PERM_READ_ENCRYPT,
-                                              read_hids_input_report, NULL, NULL),
-                       BT_GATT_CCC(input_ccc_changed,
-                                   BT_GATT_PERM_READ_ENCRYPT | BT_GATT_PERM_WRITE_ENCRYPT),
-                       BT_GATT_DESCRIPTOR(BT_UUID_HIDS_REPORT_REF, BT_GATT_PERM_READ,
-                                          read_hids_report_ref, NULL, &input),
-                       BT_GATT_CHARACTERISTIC(BT_UUID_HIDS_REPORT,
-                                              BT_GATT_CHRC_READ | BT_GATT_CHRC_NOTIFY,
-                                              BT_GATT_PERM_READ_ENCRYPT,
-                                              read_hids_consumer_input_report, NULL, NULL),
-                       BT_GATT_CCC(input_ccc_changed,
-                                   BT_GATT_PERM_READ_ENCRYPT | BT_GATT_PERM_WRITE_ENCRYPT),
-                       BT_GATT_DESCRIPTOR(BT_UUID_HIDS_REPORT_REF, BT_GATT_PERM_READ,
-                                          read_hids_report_ref, NULL, &consumer_input),
-                       BT_GATT_CHARACTERISTIC(BT_UUID_HIDS_CTRL_POINT,
-                                              BT_GATT_CHRC_WRITE_WITHOUT_RESP,
-                                              BT_GATT_PERM_WRITE,
-                                              NULL, write_ctrl_point, &ctrl_point));
-
-int zmk_hog_send_keypad_report(struct zmk_hid_keypad_report_body *report)
-{
-    return bt_gatt_notify(NULL, &hog_svc.attrs[5], report, sizeof(struct zmk_hid_keypad_report_body));
+BT_GATT_SERVICE_DEFINE(
+    hog_svc, BT_GATT_PRIMARY_SERVICE(BT_UUID_HIDS),
+    //    BT_GATT_CHARACTERISTIC(BT_UUID_HIDS_PROTOCOL_MODE, BT_GATT_CHRC_WRITE_WITHOUT_RESP,
+    //                           BT_GATT_PERM_WRITE, NULL, write_proto_mode, &proto_mode),
+    BT_GATT_CHARACTERISTIC(BT_UUID_HIDS_INFO, BT_GATT_CHRC_READ, BT_GATT_PERM_READ, read_hids_info,
+                           NULL, &info),
+    BT_GATT_CHARACTERISTIC(BT_UUID_HIDS_REPORT_MAP, BT_GATT_CHRC_READ, BT_GATT_PERM_READ,
+                           read_hids_report_map, NULL, NULL),
+
+    BT_GATT_CHARACTERISTIC(BT_UUID_HIDS_REPORT, BT_GATT_CHRC_READ | BT_GATT_CHRC_NOTIFY,
+                           BT_GATT_PERM_READ_ENCRYPT, read_hids_input_report, NULL, NULL),
+    BT_GATT_CCC(input_ccc_changed, BT_GATT_PERM_READ_ENCRYPT | BT_GATT_PERM_WRITE_ENCRYPT),
+    BT_GATT_DESCRIPTOR(BT_UUID_HIDS_REPORT_REF, BT_GATT_PERM_READ, read_hids_report_ref, NULL,
+                       &input),
+    BT_GATT_CHARACTERISTIC(BT_UUID_HIDS_REPORT, BT_GATT_CHRC_READ | BT_GATT_CHRC_NOTIFY,
+                           BT_GATT_PERM_READ_ENCRYPT, read_hids_consumer_input_report, NULL, NULL),
+    BT_GATT_CCC(input_ccc_changed, BT_GATT_PERM_READ_ENCRYPT | BT_GATT_PERM_WRITE_ENCRYPT),
+    BT_GATT_DESCRIPTOR(BT_UUID_HIDS_REPORT_REF, BT_GATT_PERM_READ, read_hids_report_ref, NULL,
+                       &consumer_input),
+    BT_GATT_CHARACTERISTIC(BT_UUID_HIDS_CTRL_POINT, BT_GATT_CHRC_WRITE_WITHOUT_RESP,
+                           BT_GATT_PERM_WRITE, NULL, write_ctrl_point, &ctrl_point));
+
+struct bt_conn *destination_connection() {
+    struct bt_conn *conn;
+    bt_addr_le_t *addr = zmk_ble_active_profile_addr();
+    LOG_DBG("Address pointer %p", addr);
+    if (!bt_addr_le_cmp(addr, BT_ADDR_LE_ANY)) {
+        LOG_WRN("Not sending, no active address for current profile");
+        return NULL;
+    } else if ((conn = bt_conn_lookup_addr_le(BT_ID_DEFAULT, addr)) == NULL) {
+        LOG_WRN("Not sending, not connected to active profile");
+        return NULL;
+    }
+
+    return conn;
+}
+
+int zmk_hog_send_keypad_report(struct zmk_hid_keypad_report_body *report) {
+    struct bt_conn *conn = destination_connection();
+    if (conn == NULL) {
+        return -ENOTCONN;
+    }
+
+    LOG_DBG("Sending to NULL? %s", conn == NULL ? "yes" : "no");
+
+    return bt_gatt_notify(conn, &hog_svc.attrs[5], report,
+                          sizeof(struct zmk_hid_keypad_report_body));
 };
 
-int zmk_hog_send_consumer_report(struct zmk_hid_consumer_report_body *report)
-{
-    return bt_gatt_notify(NULL, &hog_svc.attrs[10], report, sizeof(struct zmk_hid_consumer_report_body));
+int zmk_hog_send_consumer_report(struct zmk_hid_consumer_report_body *report) {
+    struct bt_conn *conn = destination_connection();
+    if (conn == NULL) {
+        return -ENOTCONN;
+    }
+
+    return bt_gatt_notify(conn, &hog_svc.attrs[10], report,
+                          sizeof(struct zmk_hid_consumer_report_body));
 };
diff --git a/app/src/keymap.c b/app/src/keymap.c
index ee6e370..a87ce04 100644
--- a/app/src/keymap.c
+++ b/app/src/keymap.c
@@ -1,3 +1,8 @@
+/*
+ * Copyright (c) 2020 The ZMK Contributors
+ *
+ * SPDX-License-Identifier: MIT
+ */
 
 #include <sys/util.h>
 #include <logging/log.h>
@@ -19,189 +24,185 @@ static u8_t zmk_keymap_layer_default = 0;
 
 #define DT_DRV_COMPAT zmk_keymap
 
-#define LAYER_CHILD_LEN(node) 1+
+#define LAYER_CHILD_LEN(node) 1 +
 #define ZMK_KEYMAP_NODE DT_DRV_INST(0)
-#define ZMK_KEYMAP_LAYERS_LEN (DT_INST_FOREACH_CHILD(0, LAYER_CHILD_LEN) 0) 
+#define ZMK_KEYMAP_LAYERS_LEN (DT_INST_FOREACH_CHILD(0, LAYER_CHILD_LEN) 0)
 
 #define LAYER_NODE(l) DT_PHANDLE_BY_IDX(ZMK_KEYMAP_NODE, layers, l)
 
-#define _TRANSFORM_ENTRY(idx, layer) \
-	{ .behavior_dev = DT_LABEL(DT_PHANDLE_BY_IDX(layer, bindings, idx)), \
-	  .param1 = COND_CODE_0(DT_PHA_HAS_CELL_AT_IDX(layer, bindings, idx, param1), (0), (DT_PHA_BY_IDX(layer, bindings, idx, param1))), \
-	  .param2 = COND_CODE_0(DT_PHA_HAS_CELL_AT_IDX(layer, bindings, idx, param2), (0), (DT_PHA_BY_IDX(layer, bindings, idx, param2))), \
-	},
-
-#define TRANSFORMED_LAYER(node) \
-  { UTIL_LISTIFY(DT_PROP_LEN(node, bindings), _TRANSFORM_ENTRY, node) },
+#define _TRANSFORM_ENTRY(idx, layer)                                                               \
+    {                                                                                              \
+        .behavior_dev = DT_LABEL(DT_PHANDLE_BY_IDX(layer, bindings, idx)),                         \
+        .param1 = COND_CODE_0(DT_PHA_HAS_CELL_AT_IDX(layer, bindings, idx, param1), (0),           \
+                              (DT_PHA_BY_IDX(layer, bindings, idx, param1))),                      \
+        .param2 = COND_CODE_0(DT_PHA_HAS_CELL_AT_IDX(layer, bindings, idx, param2), (0),           \
+                              (DT_PHA_BY_IDX(layer, bindings, idx, param2))),                      \
+    },
 
+#define TRANSFORMED_LAYER(node) {UTIL_LISTIFY(DT_PROP_LEN(node, bindings), _TRANSFORM_ENTRY, node)},
 
 #if ZMK_KEYMAP_HAS_SENSORS
-#define _TRANSFORM_SENSOR_ENTRY(idx, layer) \
-	{ .behavior_dev = DT_LABEL(DT_PHANDLE_BY_IDX(layer, sensor_bindings, idx)), \
-	  .param1 = COND_CODE_0(DT_PHA_HAS_CELL_AT_IDX(layer, sensor_bindings, idx, param1), (0), (DT_PHA_BY_IDX(layer, sensor_bindings, idx, param1))), \
-	  .param2 = COND_CODE_0(DT_PHA_HAS_CELL_AT_IDX(layer, sensor_bindings, idx, param2), (0), (DT_PHA_BY_IDX(layer, sensor_bindings, idx, param2))), \
-	},
-
-#define SENSOR_LAYER(node) \
-	COND_CODE_1(DT_NODE_HAS_PROP(node, sensor_bindings), \
-		({ UTIL_LISTIFY(DT_PROP_LEN(node, sensor_bindings), _TRANSFORM_SENSOR_ENTRY, node) }), \
-		({})),
+#define _TRANSFORM_SENSOR_ENTRY(idx, layer)                                                        \
+    {                                                                                              \
+        .behavior_dev = DT_LABEL(DT_PHANDLE_BY_IDX(layer, sensor_bindings, idx)),                  \
+        .param1 = COND_CODE_0(DT_PHA_HAS_CELL_AT_IDX(layer, sensor_bindings, idx, param1), (0),    \
+                              (DT_PHA_BY_IDX(layer, sensor_bindings, idx, param1))),               \
+        .param2 = COND_CODE_0(DT_PHA_HAS_CELL_AT_IDX(layer, sensor_bindings, idx, param2), (0),    \
+                              (DT_PHA_BY_IDX(layer, sensor_bindings, idx, param2))),               \
+    },
+
+#define SENSOR_LAYER(node)                                                                         \
+    COND_CODE_1(                                                                                   \
+        DT_NODE_HAS_PROP(node, sensor_bindings),                                                   \
+        ({UTIL_LISTIFY(DT_PROP_LEN(node, sensor_bindings), _TRANSFORM_SENSOR_ENTRY, node)}),       \
+        ({})),
 
 #endif /* ZMK_KEYMAP_HAS_SENSORS */
 
 // State
 
-// When a behavior handles a key position "down" event, we record that layer
+// When a behavior handles a key position "down" event, we record the layer state
 // here so that even if that layer is deactivated before the "up", event, we
 // still send the release event to the behavior in that layer also.
-static u8_t zmk_keymap_active_behavior_layer[ZMK_KEYMAP_LEN];
+static u32_t zmk_keymap_active_behavior_layer[ZMK_KEYMAP_LEN];
 
 static struct zmk_behavior_binding zmk_keymap[ZMK_KEYMAP_LAYERS_LEN][ZMK_KEYMAP_LEN] = {
-	DT_INST_FOREACH_CHILD(0, TRANSFORMED_LAYER)
-};
+    DT_INST_FOREACH_CHILD(0, TRANSFORMED_LAYER)};
 
 #if ZMK_KEYMAP_HAS_SENSORS
 
-static struct zmk_behavior_binding zmk_sensor_keymap[ZMK_KEYMAP_LAYERS_LEN][ZMK_KEYMAP_SENSORS_LEN] = {
-	DT_INST_FOREACH_CHILD(0, SENSOR_LAYER)
-};
+static struct zmk_behavior_binding zmk_sensor_keymap[ZMK_KEYMAP_LAYERS_LEN]
+                                                    [ZMK_KEYMAP_SENSORS_LEN] = {
+                                                        DT_INST_FOREACH_CHILD(0, SENSOR_LAYER)};
 
 #endif /* ZMK_KEYMAP_HAS_SENSORS */
 
-#define SET_LAYER_STATE(layer, state)                \
-	if (layer >= 32)                                 \
-	{                                                \
-		return -EINVAL;                              \
-	}                                                \
-	WRITE_BIT(zmk_keymap_layer_state, layer, state); \
-	return 0;
-
-bool zmk_keymap_layer_active(u8_t layer)
-{
-	return (zmk_keymap_layer_state & (BIT(layer))) == (BIT(layer));
-};
+#define SET_LAYER_STATE(layer, state)                                                              \
+    if (layer >= 32) {                                                                             \
+        return -EINVAL;                                                                            \
+    }                                                                                              \
+    WRITE_BIT(zmk_keymap_layer_state, layer, state);                                               \
+    return 0;
 
-int zmk_keymap_layer_activate(u8_t layer)
-{
-	SET_LAYER_STATE(layer, true);
+bool zmk_keymap_layer_active(u8_t layer) {
+    return (zmk_keymap_layer_state & (BIT(layer))) == (BIT(layer));
 };
 
-int zmk_keymap_layer_deactivate(u8_t layer)
-{
-	SET_LAYER_STATE(layer, false);
-};
+int zmk_keymap_layer_activate(u8_t layer) { SET_LAYER_STATE(layer, true); };
+
+int zmk_keymap_layer_deactivate(u8_t layer) { SET_LAYER_STATE(layer, false); };
 
-int zmk_keymap_layer_toggle(u8_t layer)
-{
-	if (zmk_keymap_layer_active(layer))
-	{
-		return zmk_keymap_layer_deactivate(layer);
-	}
+int zmk_keymap_layer_toggle(u8_t layer) {
+    if (zmk_keymap_layer_active(layer)) {
+        return zmk_keymap_layer_deactivate(layer);
+    }
 
-  	return zmk_keymap_layer_activate(layer);
+    return zmk_keymap_layer_activate(layer);
 };
 
-bool is_active_position(u32_t position, u8_t layer)
-{
-	return (zmk_keymap_layer_state & BIT(layer)) == BIT(layer)
-		|| layer == zmk_keymap_layer_default
-		|| zmk_keymap_active_behavior_layer[position] == layer;
+bool is_active_layer(u8_t layer, u32_t layer_state) {
+    return (layer_state & BIT(layer)) == BIT(layer) || layer == zmk_keymap_layer_default;
 }
 
-int zmk_keymap_position_state_changed(u32_t position, bool pressed)
-{
-	for (int layer = ZMK_KEYMAP_LAYERS_LEN - 1; layer >= zmk_keymap_layer_default; layer--)
-	{
-		if (is_active_position(position, layer))
-		{
-			struct zmk_behavior_binding *binding = &zmk_keymap[layer][position];
-			struct device *behavior;
-			int ret;
-
-			LOG_DBG("layer: %d position: %d, binding name: %s", layer, position, log_strdup(binding->behavior_dev));
-
-			behavior = device_get_binding(binding->behavior_dev);
-
-			if (!behavior) {
-				LOG_DBG("No behavior assigned to %d on layer %d", position, layer);
-				continue;
-			}
-			if (pressed) {
-				ret = behavior_keymap_binding_pressed(behavior, position, binding->param1, binding->param2);
-			} else {
-				ret = behavior_keymap_binding_released(behavior, position, binding->param1, binding->param2);
-			}
-			
-
-			if (ret > 0) {
-				LOG_DBG("behavior processing to continue to next layer");
-				continue;
-			} else if (ret < 0) {
-				LOG_DBG("Behavior returned error: %d", ret);
-				zmk_keymap_active_behavior_layer[position] = 0;
-				return ret; 
-			} else {
-				zmk_keymap_active_behavior_layer[position] = pressed ? layer : 0;
-				return ret;
-			}
-		}
-	}
-
-	return -ENOTSUP;
+int zmk_keymap_apply_position_state(int layer, u32_t position, bool pressed) {
+    struct zmk_behavior_binding *binding = &zmk_keymap[layer][position];
+    struct device *behavior;
+
+    LOG_DBG("layer: %d position: %d, binding name: %s", layer, position,
+            log_strdup(binding->behavior_dev));
+
+    behavior = device_get_binding(binding->behavior_dev);
+
+    if (!behavior) {
+        LOG_DBG("No behavior assigned to %d on layer %d", position, layer);
+        return 1;
+    }
+
+    if (pressed) {
+        return behavior_keymap_binding_pressed(behavior, position, binding->param1,
+                                               binding->param2);
+    } else {
+        return behavior_keymap_binding_released(behavior, position, binding->param1,
+                                                binding->param2);
+    }
+}
+
+int zmk_keymap_position_state_changed(u32_t position, bool pressed) {
+    for (int layer = ZMK_KEYMAP_LAYERS_LEN - 1; layer >= zmk_keymap_layer_default; layer--) {
+        u32_t layer_state =
+            pressed ? zmk_keymap_layer_state : zmk_keymap_active_behavior_layer[position];
+        if (is_active_layer(layer, layer_state)) {
+            int ret = zmk_keymap_apply_position_state(layer, position, pressed);
+
+            zmk_keymap_active_behavior_layer[position] = zmk_keymap_layer_state;
+
+            if (ret > 0) {
+                LOG_DBG("behavior processing to continue to next layer");
+                continue;
+            } else if (ret < 0) {
+                LOG_DBG("Behavior returned error: %d", ret);
+                return ret;
+            } else {
+                return ret;
+            }
+        }
+    }
+
+    return -ENOTSUP;
 }
 
 #if ZMK_KEYMAP_HAS_SENSORS
-int zmk_keymap_sensor_triggered(u8_t sensor_number, struct device *sensor)
-{
-	for (int layer = ZMK_KEYMAP_LAYERS_LEN - 1; layer >= zmk_keymap_layer_default; layer--)
-	{
-		if (((zmk_keymap_layer_state & BIT(layer)) == BIT(layer) || layer == zmk_keymap_layer_default) && zmk_sensor_keymap[layer] != NULL)
-		{
-			struct zmk_behavior_binding *binding = &zmk_sensor_keymap[layer][sensor_number];
-			struct device *behavior;
-			int ret;
-
-			LOG_DBG("layer: %d sensor_number: %d, binding name: %s", layer, sensor_number, log_strdup(binding->behavior_dev));
-
-			behavior = device_get_binding(binding->behavior_dev);
-
-			if (!behavior) {
-				LOG_DBG("No behavior assigned to %d on layer %d", sensor_number, layer);
-				continue;
-			}
-			
-			ret = behavior_sensor_keymap_binding_triggered(behavior, sensor, binding->param1, binding->param2);
-
-			if (ret > 0) {
-				LOG_DBG("behavior processing to continue to next layer");
-				continue;
-			} else if (ret < 0) {
-				LOG_DBG("Behavior returned error: %d", ret);
-				return ret; 
-			} else {
-				return ret;
-			}
-		}
-	}
-
-	return -ENOTSUP;
+int zmk_keymap_sensor_triggered(u8_t sensor_number, struct device *sensor) {
+    for (int layer = ZMK_KEYMAP_LAYERS_LEN - 1; layer >= zmk_keymap_layer_default; layer--) {
+        if (((zmk_keymap_layer_state & BIT(layer)) == BIT(layer) ||
+             layer == zmk_keymap_layer_default) &&
+            zmk_sensor_keymap[layer] != NULL) {
+            struct zmk_behavior_binding *binding = &zmk_sensor_keymap[layer][sensor_number];
+            struct device *behavior;
+            int ret;
+
+            LOG_DBG("layer: %d sensor_number: %d, binding name: %s", layer, sensor_number,
+                    log_strdup(binding->behavior_dev));
+
+            behavior = device_get_binding(binding->behavior_dev);
+
+            if (!behavior) {
+                LOG_DBG("No behavior assigned to %d on layer %d", sensor_number, layer);
+                continue;
+            }
+
+            ret = behavior_sensor_keymap_binding_triggered(behavior, sensor, binding->param1,
+                                                           binding->param2);
+
+            if (ret > 0) {
+                LOG_DBG("behavior processing to continue to next layer");
+                continue;
+            } else if (ret < 0) {
+                LOG_DBG("Behavior returned error: %d", ret);
+                return ret;
+            } else {
+                return ret;
+            }
+        }
+    }
+
+    return -ENOTSUP;
 }
 
 #endif /* ZMK_KEYMAP_HAS_SENSORS */
 
-int keymap_listener(const struct zmk_event_header *eh)
-{
-	if (is_position_state_changed(eh)) {
-		const struct position_state_changed *ev = cast_position_state_changed(eh);
-		return zmk_keymap_position_state_changed(ev->position, ev->state);
+int keymap_listener(const struct zmk_event_header *eh) {
+    if (is_position_state_changed(eh)) {
+        const struct position_state_changed *ev = cast_position_state_changed(eh);
+        return zmk_keymap_position_state_changed(ev->position, ev->state);
 #if ZMK_KEYMAP_HAS_SENSORS
-	} else if (is_sensor_event(eh)) {
-		const struct sensor_event *ev = cast_sensor_event(eh);
-		return zmk_keymap_sensor_triggered(ev->sensor_number, ev->sensor);
+    } else if (is_sensor_event(eh)) {
+        const struct sensor_event *ev = cast_sensor_event(eh);
+        return zmk_keymap_sensor_triggered(ev->sensor_number, ev->sensor);
 #endif /* ZMK_KEYMAP_HAS_SENSORS */
-	}
+    }
 
-	return -ENOTSUP;
+    return -ENOTSUP;
 }
 
 ZMK_LISTENER(keymap, keymap_listener);
@@ -210,4 +211,3 @@ ZMK_SUBSCRIPTION(keymap, position_state_changed);
 #if ZMK_KEYMAP_HAS_SENSORS
 ZMK_SUBSCRIPTION(keymap, sensor_event);
 #endif /* ZMK_KEYMAP_HAS_SENSORS */
-
diff --git a/app/src/kscan.c b/app/src/kscan.c
index 63713f1..0046f5c 100644
--- a/app/src/kscan.c
+++ b/app/src/kscan.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Peter Johanson
+ * Copyright (c) 2020 The ZMK Contributors
  *
  * SPDX-License-Identifier: MIT
  */
@@ -18,61 +18,55 @@ LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
 #define ZMK_KSCAN_EVENT_STATE_PRESSED 0
 #define ZMK_KSCAN_EVENT_STATE_RELEASED 1
 
-struct zmk_kscan_event
-{
-	u32_t row;
-	u32_t column;
-	u32_t state;
+struct zmk_kscan_event {
+    u32_t row;
+    u32_t column;
+    u32_t state;
 };
 
-struct zmk_kscan_msg_processor
-{
-	struct k_work work;
+struct zmk_kscan_msg_processor {
+    struct k_work work;
 } msg_processor;
 
 K_MSGQ_DEFINE(zmk_kscan_msgq, sizeof(struct zmk_kscan_event), CONFIG_ZMK_KSCAN_EVENT_QUEUE_SIZE, 4);
 
-static void zmk_kscan_callback(struct device *dev, u32_t row, u32_t column, bool pressed)
-{
-	struct zmk_kscan_event ev = {
-		.row = row,
-		.column = column,
-		.state = (pressed ? ZMK_KSCAN_EVENT_STATE_PRESSED : ZMK_KSCAN_EVENT_STATE_RELEASED)};
+static void zmk_kscan_callback(struct device *dev, u32_t row, u32_t column, bool pressed) {
+    struct zmk_kscan_event ev = {
+        .row = row,
+        .column = column,
+        .state = (pressed ? ZMK_KSCAN_EVENT_STATE_PRESSED : ZMK_KSCAN_EVENT_STATE_RELEASED)};
 
-	k_msgq_put(&zmk_kscan_msgq, &ev, K_NO_WAIT);
-	k_work_submit(&msg_processor.work);
+    k_msgq_put(&zmk_kscan_msgq, &ev, K_NO_WAIT);
+    k_work_submit(&msg_processor.work);
 }
 
-void zmk_kscan_process_msgq(struct k_work *item)
-{
-	struct zmk_kscan_event ev;
+void zmk_kscan_process_msgq(struct k_work *item) {
+    struct zmk_kscan_event ev;
 
-	while (k_msgq_get(&zmk_kscan_msgq, &ev, K_NO_WAIT) == 0)
-	{
-		bool pressed = (ev.state == ZMK_KSCAN_EVENT_STATE_PRESSED);
-		u32_t position = zmk_matrix_transform_row_column_to_position(ev.row, ev.column);
-		struct position_state_changed *pos_ev;
-		LOG_DBG("Row: %d, col: %d, position: %d, pressed: %s\n", ev.row, ev.column, position, (pressed ? "true" : "false"));
-		pos_ev = new_position_state_changed();
-		pos_ev->state = pressed;
-		pos_ev->position = position;
-		ZMK_EVENT_RAISE(pos_ev);
-	}
+    while (k_msgq_get(&zmk_kscan_msgq, &ev, K_NO_WAIT) == 0) {
+        bool pressed = (ev.state == ZMK_KSCAN_EVENT_STATE_PRESSED);
+        u32_t position = zmk_matrix_transform_row_column_to_position(ev.row, ev.column);
+        struct position_state_changed *pos_ev;
+        LOG_DBG("Row: %d, col: %d, position: %d, pressed: %s\n", ev.row, ev.column, position,
+                (pressed ? "true" : "false"));
+        pos_ev = new_position_state_changed();
+        pos_ev->state = pressed;
+        pos_ev->position = position;
+        ZMK_EVENT_RAISE(pos_ev);
+    }
 }
 
-int zmk_kscan_init(char *name)
-{
-	struct device *dev = device_get_binding(name);
-	if (dev == NULL)
-	{
-		LOG_ERR("Failed to get the KSCAN device");
-		return -EINVAL;
-	}
+int zmk_kscan_init(char *name) {
+    struct device *dev = device_get_binding(name);
+    if (dev == NULL) {
+        LOG_ERR("Failed to get the KSCAN device");
+        return -EINVAL;
+    }
 
-	k_work_init(&msg_processor.work, zmk_kscan_process_msgq);
+    k_work_init(&msg_processor.work, zmk_kscan_process_msgq);
 
-	kscan_config(dev, zmk_kscan_callback);
-	kscan_enable_callback(dev);
+    kscan_config(dev, zmk_kscan_callback);
+    kscan_enable_callback(dev);
 
-	return 0;
+    return 0;
 }
diff --git a/app/src/kscan_composite.c b/app/src/kscan_composite.c
index d46484b..0249140 100644
--- a/app/src/kscan_composite.c
+++ b/app/src/kscan_composite.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Peter Johanson <peter@peterjohanson.com>
+ * Copyright (c) 2020 The ZMK Contributors
  *
  * SPDX-License-Identifier: MIT
  */
@@ -15,37 +15,31 @@ LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
 #define MATRIX_ROWS DT_PROP(MATRIX_NODE_ID, rows)
 #define MATRIX_COLS DT_PROP(MATRIX_NODE_ID, columns)
 
-struct kscan_composite_child_config
-{
+struct kscan_composite_child_config {
     char *label;
     u8_t row_offset;
     u8_t column_offset;
 };
 
-#define CHILD_CONFIG(inst)                          \
-    {                                               \
-        .label = DT_LABEL(DT_PHANDLE(inst, kscan)), \
-        .row_offset = DT_PROP(inst, row_offset),    \
-        .column_offset = DT_PROP(inst, column_offset)},
+#define CHILD_CONFIG(inst)                                                                         \
+    {.label = DT_LABEL(DT_PHANDLE(inst, kscan)),                                                   \
+     .row_offset = DT_PROP(inst, row_offset),                                                      \
+     .column_offset = DT_PROP(inst, column_offset)},
 
 const struct kscan_composite_child_config kscan_composite_children[] = {
     DT_FOREACH_CHILD(MATRIX_NODE_ID, CHILD_CONFIG)};
 
-struct kscan_composite_config
-{
-};
+struct kscan_composite_config {};
 
-struct kscan_composite_data
-{
+struct kscan_composite_data {
     kscan_callback_t callback;
 
     struct device *dev;
 };
 
-static int kscan_composite_enable_callback(struct device *dev)
-{
-    for (int i = 0; i < sizeof(kscan_composite_children) / sizeof(kscan_composite_children[0]); i++)
-    {
+static int kscan_composite_enable_callback(struct device *dev) {
+    for (int i = 0; i < sizeof(kscan_composite_children) / sizeof(kscan_composite_children[0]);
+         i++) {
         const struct kscan_composite_child_config *cfg = &kscan_composite_children[i];
 
         kscan_enable_callback(device_get_binding(cfg->label));
@@ -53,10 +47,9 @@ static int kscan_composite_enable_callback(struct device *dev)
     return 0;
 }
 
-static int kscan_composite_disable_callback(struct device *dev)
-{
-    for (int i = 0; i < sizeof(kscan_composite_children) / sizeof(kscan_composite_children[0]); i++)
-    {
+static int kscan_composite_disable_callback(struct device *dev) {
+    for (int i = 0; i < sizeof(kscan_composite_children) / sizeof(kscan_composite_children[0]);
+         i++) {
         const struct kscan_composite_child_config *cfg = &kscan_composite_children[i];
 
         kscan_disable_callback(device_get_binding(cfg->label));
@@ -64,18 +57,17 @@ static int kscan_composite_disable_callback(struct device *dev)
     return 0;
 }
 
-static void kscan_composite_child_callback(struct device *child_dev, u32_t row, u32_t column, bool pressed)
-{
+static void kscan_composite_child_callback(struct device *child_dev, u32_t row, u32_t column,
+                                           bool pressed) {
     // TODO: Ideally we can get this passed into our callback!
     struct device *dev = device_get_binding(DT_INST_LABEL(0));
     struct kscan_composite_data *data = dev->driver_data;
 
-    for (int i = 0; i < sizeof(kscan_composite_children) / sizeof(kscan_composite_children[0]); i++)
-    {
+    for (int i = 0; i < sizeof(kscan_composite_children) / sizeof(kscan_composite_children[0]);
+         i++) {
         const struct kscan_composite_child_config *cfg = &kscan_composite_children[i];
 
-        if (device_get_binding(cfg->label) != child_dev)
-        {
+        if (device_get_binding(cfg->label) != child_dev) {
             continue;
         }
 
@@ -83,17 +75,15 @@ static void kscan_composite_child_callback(struct device *child_dev, u32_t row,
     }
 }
 
-static int kscan_composite_configure(struct device *dev, kscan_callback_t callback)
-{
+static int kscan_composite_configure(struct device *dev, kscan_callback_t callback) {
     struct kscan_composite_data *data = dev->driver_data;
 
-    if (!callback)
-    {
+    if (!callback) {
         return -EINVAL;
     }
 
-    for (int i = 0; i < sizeof(kscan_composite_children) / sizeof(kscan_composite_children[0]); i++)
-    {
+    for (int i = 0; i < sizeof(kscan_composite_children) / sizeof(kscan_composite_children[0]);
+         i++) {
         const struct kscan_composite_child_config *cfg = &kscan_composite_children[i];
 
         kscan_config(device_get_binding(cfg->label), &kscan_composite_child_callback);
@@ -104,8 +94,7 @@ static int kscan_composite_configure(struct device *dev, kscan_callback_t callba
     return 0;
 }
 
-static int kscan_composite_init(struct device *dev)
-{
+static int kscan_composite_init(struct device *dev) {
     struct kscan_composite_data *data = dev->driver_data;
 
     data->dev = dev;
@@ -123,8 +112,6 @@ static const struct kscan_composite_config kscan_composite_config = {};
 
 static struct kscan_composite_data kscan_composite_data;
 
-DEVICE_AND_API_INIT(kscan_composite, DT_INST_LABEL(0), kscan_composite_init,
-                    &kscan_composite_data,
-                    &kscan_composite_config,
-                    APPLICATION, CONFIG_KERNEL_INIT_PRIORITY_DEFAULT,
+DEVICE_AND_API_INIT(kscan_composite, DT_INST_LABEL(0), kscan_composite_init, &kscan_composite_data,
+                    &kscan_composite_config, APPLICATION, CONFIG_KERNEL_INIT_PRIORITY_DEFAULT,
                     &mock_driver_api);
diff --git a/app/src/kscan_mock.c b/app/src/kscan_mock.c
index b0ba90b..e9c15a0 100644
--- a/app/src/kscan_mock.c
+++ b/app/src/kscan_mock.c
@@ -1,21 +1,21 @@
 /*
- * Copyright (c) 2020 Peter Johanson <peter@peterjohanson.com>
+ * Copyright (c) 2020 The ZMK Contributors
  *
  * SPDX-License-Identifier: MIT
  */
 
 #define DT_DRV_COMPAT zmk_kscan_mock
 
+#include <stdlib.h>
 #include <device.h>
 #include <drivers/kscan.h>
 #include <logging/log.h>
 
 LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
 
-#include <zmk/kscan-mock.h>
+#include <dt-bindings/zmk/kscan-mock.h>
 
-struct kscan_mock_data
-{
+struct kscan_mock_data {
     kscan_callback_t callback;
 
     u8_t event_index;
@@ -23,20 +23,17 @@ struct kscan_mock_data
     struct device *dev;
 };
 
-static int kscan_mock_disable_callback(struct device *dev)
-{
+static int kscan_mock_disable_callback(struct device *dev) {
     struct kscan_mock_data *data = dev->driver_data;
 
     k_delayed_work_cancel(&data->work);
     return 0;
 }
 
-static int kscan_mock_configure(struct device *dev, kscan_callback_t callback)
-{
+static int kscan_mock_configure(struct device *dev, kscan_callback_t callback) {
     struct kscan_mock_data *data = dev->driver_data;
 
-    if (!callback)
-    {
+    if (!callback) {
         return -EINVAL;
     }
 
@@ -46,58 +43,53 @@ static int kscan_mock_configure(struct device *dev, kscan_callback_t callback)
     return 0;
 }
 
-#define MOCK_INST_INIT(n)                                                          \
-    struct kscan_mock_config_##n                                                   \
-    {                                                                              \
-        u32_t events[DT_INST_PROP_LEN(n, events)];                                 \
-    };                                                                             \
-    static void kscan_mock_schedule_next_event_##n(struct device *dev)             \
-    {                                                                              \
-        struct kscan_mock_data *data = dev->driver_data;                           \
-        const struct kscan_mock_config_##n *cfg = dev->config_info;                \
-        if (data->event_index < DT_INST_PROP_LEN(n, events))                       \
-        {                                                                          \
-            u32_t ev = cfg->events[data->event_index];                             \
-            LOG_DBG("delaying next keypress: %d", ZMK_MOCK_MSEC(ev));              \
-            k_delayed_work_submit(&data->work, K_MSEC(ZMK_MOCK_MSEC(ev)));         \
-        }                                                                          \
-    }                                                                              \
-    static void kscan_mock_work_handler_##n(struct k_work *work)                   \
-    {                                                                              \
-        struct kscan_mock_data *data =                                             \
-            CONTAINER_OF(work, struct kscan_mock_data, work);                      \
-        const struct kscan_mock_config_##n *cfg = data->dev->config_info;          \
-        u32_t ev = cfg->events[data->event_index++];                               \
-        LOG_DBG("ev %u row %d column %d state %d\n", ev,                           \
-                ZMK_MOCK_ROW(ev), ZMK_MOCK_COL(ev), ZMK_MOCK_IS_PRESS(ev));        \
-        data->callback(data->dev,                                                  \
-                       ZMK_MOCK_ROW(ev), ZMK_MOCK_COL(ev), ZMK_MOCK_IS_PRESS(ev)); \
-        kscan_mock_schedule_next_event_##n(data->dev);                             \
-    }                                                                              \
-    static int kscan_mock_init_##n(struct device *dev)                             \
-    {                                                                              \
-        struct kscan_mock_data *data = dev->driver_data;                           \
-        data->dev = dev;                                                           \
-        k_delayed_work_init(&data->work, kscan_mock_work_handler_##n);             \
-        return 0;                                                                  \
-    }                                                                              \
-    static int kscan_mock_enable_callback_##n(struct device *dev)                  \
-    {                                                                              \
-        kscan_mock_schedule_next_event_##n(dev);                                   \
-        return 0;                                                                  \
-    }                                                                              \
-    static const struct kscan_driver_api mock_driver_api_##n = {                   \
-        .config = kscan_mock_configure,                                            \
-        .enable_callback = kscan_mock_enable_callback_##n,                         \
-        .disable_callback = kscan_mock_disable_callback,                           \
-    };                                                                             \
-    static struct kscan_mock_data kscan_mock_data_##n;                             \
-    static const struct kscan_mock_config_##n kscan_mock_config_##n = {            \
-        .events = DT_INST_PROP(n, events)};                                        \
-    DEVICE_AND_API_INIT(kscan_mock_##n, DT_INST_LABEL(n), kscan_mock_init_##n,     \
-                        &kscan_mock_data_##n,                                      \
-                        &kscan_mock_config_##n,                                    \
-                        APPLICATION, CONFIG_KERNEL_INIT_PRIORITY_DEFAULT,          \
-                        &mock_driver_api_##n);
+#define MOCK_INST_INIT(n)                                                                          \
+    struct kscan_mock_config_##n {                                                                 \
+        u32_t events[DT_INST_PROP_LEN(n, events)];                                                 \
+        bool exit_after;                                                                           \
+    };                                                                                             \
+    static void kscan_mock_schedule_next_event_##n(struct device *dev) {                           \
+        struct kscan_mock_data *data = dev->driver_data;                                           \
+        const struct kscan_mock_config_##n *cfg = dev->config_info;                                \
+        if (data->event_index < DT_INST_PROP_LEN(n, events)) {                                     \
+            u32_t ev = cfg->events[data->event_index];                                             \
+            LOG_DBG("delaying next keypress: %d", ZMK_MOCK_MSEC(ev));                              \
+            k_delayed_work_submit(&data->work, K_MSEC(ZMK_MOCK_MSEC(ev)));                         \
+        } else if (cfg->exit_after) {                                                              \
+            LOG_DBG("Exiting");                                                                    \
+            exit(0);                                                                               \
+        }                                                                                          \
+    }                                                                                              \
+    static void kscan_mock_work_handler_##n(struct k_work *work) {                                 \
+        struct kscan_mock_data *data = CONTAINER_OF(work, struct kscan_mock_data, work);           \
+        const struct kscan_mock_config_##n *cfg = data->dev->config_info;                          \
+        u32_t ev = cfg->events[data->event_index];                                                 \
+        LOG_DBG("ev %u row %d column %d state %d\n", ev, ZMK_MOCK_ROW(ev), ZMK_MOCK_COL(ev),       \
+                ZMK_MOCK_IS_PRESS(ev));                                                            \
+        data->callback(data->dev, ZMK_MOCK_ROW(ev), ZMK_MOCK_COL(ev), ZMK_MOCK_IS_PRESS(ev));      \
+        kscan_mock_schedule_next_event_##n(data->dev);                                             \
+        data->event_index++;                                                                       \
+    }                                                                                              \
+    static int kscan_mock_init_##n(struct device *dev) {                                           \
+        struct kscan_mock_data *data = dev->driver_data;                                           \
+        data->dev = dev;                                                                           \
+        k_delayed_work_init(&data->work, kscan_mock_work_handler_##n);                             \
+        return 0;                                                                                  \
+    }                                                                                              \
+    static int kscan_mock_enable_callback_##n(struct device *dev) {                                \
+        kscan_mock_schedule_next_event_##n(dev);                                                   \
+        return 0;                                                                                  \
+    }                                                                                              \
+    static const struct kscan_driver_api mock_driver_api_##n = {                                   \
+        .config = kscan_mock_configure,                                                            \
+        .enable_callback = kscan_mock_enable_callback_##n,                                         \
+        .disable_callback = kscan_mock_disable_callback,                                           \
+    };                                                                                             \
+    static struct kscan_mock_data kscan_mock_data_##n;                                             \
+    static const struct kscan_mock_config_##n kscan_mock_config_##n = {                            \
+        .events = DT_INST_PROP(n, events), .exit_after = DT_INST_PROP(n, exit_after)};             \
+    DEVICE_AND_API_INIT(kscan_mock_##n, DT_INST_LABEL(n), kscan_mock_init_##n,                     \
+                        &kscan_mock_data_##n, &kscan_mock_config_##n, APPLICATION,                 \
+                        CONFIG_KERNEL_INIT_PRIORITY_DEFAULT, &mock_driver_api_##n);
 
-DT_INST_FOREACH_STATUS_OKAY(MOCK_INST_INIT)
\ No newline at end of file
+DT_INST_FOREACH_STATUS_OKAY(MOCK_INST_INIT)
diff --git a/app/src/main.c b/app/src/main.c
index 5a678ee..dca923e 100644
--- a/app/src/main.c
+++ b/app/src/main.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Peter Johanson
+ * Copyright (c) 2020 The ZMK Contributors
  *
  * SPDX-License-Identifier: MIT
  */
@@ -18,20 +18,18 @@ LOG_MODULE_REGISTER(zmk, CONFIG_ZMK_LOG_LEVEL);
 
 #define ZMK_KSCAN_DEV DT_LABEL(ZMK_MATRIX_NODE_ID)
 
-void main(void)
-{
-	LOG_INF("Welcome to ZMK!\n");
+void main(void) {
+    LOG_INF("Welcome to ZMK!\n");
 
-	if (zmk_kscan_init(ZMK_KSCAN_DEV) != 0)
-	{
-		return;
-	}
+    if (zmk_kscan_init(ZMK_KSCAN_DEV) != 0) {
+        return;
+    }
 
 #ifdef CONFIG_ZMK_DISPLAY
-	zmk_display_init();
+    zmk_display_init();
 
-	while (1) {
-		zmk_display_task_handler();
-	}
+    while (1) {
+        zmk_display_task_handler();
+    }
 #endif /* CONFIG_ZMK_DISPLAY */
 }
diff --git a/app/src/matrix_transform.c b/app/src/matrix_transform.c
index 7ecf1ae..4e68a56 100644
--- a/app/src/matrix_transform.c
+++ b/app/src/matrix_transform.c
@@ -1,3 +1,8 @@
+/*
+ * Copyright (c) 2020 The ZMK Contributors
+ *
+ * SPDX-License-Identifier: MIT
+ */
 
 #include <zephyr.h>
 #include <zmk/matrix_transform.h>
@@ -6,16 +11,15 @@
 
 #ifdef ZMK_KEYMAP_TRANSFORM_NODE
 
-#define _TRANSFORM_ENTRY(i, _) \
-	[(KT_ROW(DT_PROP_BY_IDX(ZMK_KEYMAP_TRANSFORM_NODE, map, i)) * ZMK_MATRIX_COLS) + KT_COL(DT_PROP_BY_IDX(ZMK_KEYMAP_TRANSFORM_NODE, map, i))] = i,
+#define _TRANSFORM_ENTRY(i, _)                                                                     \
+    [(KT_ROW(DT_PROP_BY_IDX(ZMK_KEYMAP_TRANSFORM_NODE, map, i)) * ZMK_MATRIX_COLS) +               \
+        KT_COL(DT_PROP_BY_IDX(ZMK_KEYMAP_TRANSFORM_NODE, map, i))] = i,
 
-static u32_t transform[] = 
-    { UTIL_LISTIFY(ZMK_KEYMAP_LEN, _TRANSFORM_ENTRY, 0) };
+static u32_t transform[] = {UTIL_LISTIFY(ZMK_KEYMAP_LEN, _TRANSFORM_ENTRY, 0)};
 
 #endif
 
-u32_t zmk_matrix_transform_row_column_to_position(u32_t row, u32_t column)
-{
+u32_t zmk_matrix_transform_row_column_to_position(u32_t row, u32_t column) {
     u32_t matrix_index;
 
 #if DT_NODE_HAS_PROP(ZMK_KEYMAP_TRANSFORM_NODE, col_offset)
diff --git a/app/src/rgb_underglow.c b/app/src/rgb_underglow.c
index cb98e8d..d453755 100644
--- a/app/src/rgb_underglow.c
+++ b/app/src/rgb_underglow.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Nick Winans <nick@winans.codes>
+ * Copyright (c) 2020 The ZMK Contributors
  *
  * SPDX-License-Identifier: MIT
  */
@@ -18,8 +18,8 @@
 
 LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
 
-#define STRIP_LABEL		    DT_LABEL(DT_CHOSEN(zmk_underglow))
-#define STRIP_NUM_PIXELS	DT_PROP(DT_CHOSEN(zmk_underglow), chain_length)
+#define STRIP_LABEL DT_LABEL(DT_CHOSEN(zmk_underglow))
+#define STRIP_NUM_PIXELS DT_PROP(DT_CHOSEN(zmk_underglow), chain_length)
 
 enum rgb_underglow_effect {
     UNDERGLOW_EFFECT_SOLID,
@@ -30,19 +30,19 @@ enum rgb_underglow_effect {
 };
 
 struct led_hsb {
-	u16_t h;
-	u8_t  s;
-	u8_t  b;
+    u16_t h;
+    u8_t s;
+    u8_t b;
 };
 
 struct rgb_underglow_state {
     u16_t hue;
-    u8_t  saturation;
-    u8_t  brightness;
-    u8_t  animation_speed;
-    u8_t  current_effect;
+    u8_t saturation;
+    u8_t brightness;
+    u8_t animation_speed;
+    u8_t current_effect;
     u16_t animation_step;
-    bool  on;
+    bool on;
 };
 
 struct device *led_strip;
@@ -92,17 +92,40 @@ static struct led_rgb hsb_to_rgb(struct led_hsb hsb)
     double q = v * (1 - f * s);
     double t = v * (1 - (1 - f) * s);
 
-    switch (i % 6)
-    {
-        case 0: r = v; g = t; b = p; break;
-        case 1: r = q; g = v; b = p; break;
-        case 2: r = p; g = v; b = t; break;
-        case 3: r = p; g = q; b = v; break;
-        case 4: r = t; g = p; b = v; break;
-        case 5: r = v; g = p; b = q; break;
+    switch (i % 6) {
+    case 0:
+        r = v;
+        g = t;
+        b = p;
+        break;
+    case 1:
+        r = q;
+        g = v;
+        b = p;
+        break;
+    case 2:
+        r = p;
+        g = v;
+        b = t;
+        break;
+    case 3:
+        r = p;
+        g = q;
+        b = v;
+        break;
+    case 4:
+        r = t;
+        g = p;
+        b = v;
+        break;
+    case 5:
+        r = v;
+        g = p;
+        b = q;
+        break;
     }
 
-    struct led_rgb rgb = { r: r*255, g: g*255, b: b*255 };
+    struct led_rgb rgb = {r : r * 255, g : g * 255, b : b * 255};
 
     return rgb;
 }
@@ -125,41 +148,37 @@ static void zmk_rgb_underglow_effect_solid()
         int sat = state.saturation;
         int brt = state.brightness;
 
-        struct led_hsb hsb = { hue, sat, brt };
+        struct led_hsb hsb = {hue, sat, brt};
 
         pixels[i] = hsb_to_rgb(hsb);
     }
 }
 
-static void zmk_rgb_underglow_effect_breathe()
-{
-    for (int i=0; i<STRIP_NUM_PIXELS; i++)
-    {
+static void zmk_rgb_underglow_effect_breathe() {
+    for (int i = 0; i < STRIP_NUM_PIXELS; i++) {
         int hue = state.hue;
         int sat = state.saturation;
         int brt = abs(state.animation_step - 1200) / 12;
 
-        struct led_hsb hsb = { hue, sat, brt };
+        struct led_hsb hsb = {hue, sat, brt};
 
         pixels[i] = hsb_to_rgb(hsb);
     }
 
     state.animation_step += state.animation_speed * 10;
-    
+
     if (state.animation_step > 2400) {
         state.animation_step = 0;
     }
 }
 
-static void zmk_rgb_underglow_effect_spectrum()
-{
-    for (int i=0; i<STRIP_NUM_PIXELS; i++)
-    {
+static void zmk_rgb_underglow_effect_spectrum() {
+    for (int i = 0; i < STRIP_NUM_PIXELS; i++) {
         int hue = state.animation_step;
         int sat = state.saturation;
         int brt = state.brightness;
 
-        struct led_hsb hsb = { hue, sat, brt };
+        struct led_hsb hsb = {hue, sat, brt};
 
         pixels[i] = hsb_to_rgb(hsb);
     }
@@ -168,15 +187,13 @@ static void zmk_rgb_underglow_effect_spectrum()
     state.animation_step = state.animation_step % 360;
 }
 
-static void zmk_rgb_underglow_effect_swirl()
-{
-    for (int i=0; i<STRIP_NUM_PIXELS; i++)
-    {
+static void zmk_rgb_underglow_effect_swirl() {
+    for (int i = 0; i < STRIP_NUM_PIXELS; i++) {
         int hue = (360 / STRIP_NUM_PIXELS * i + state.animation_step) % 360;
         int sat = state.saturation;
         int brt = state.brightness;
 
-        struct led_hsb hsb = { hue, sat, brt };
+        struct led_hsb hsb = {hue, sat, brt};
 
         pixels[i] = hsb_to_rgb(hsb);
     }
@@ -185,22 +202,20 @@ static void zmk_rgb_underglow_effect_swirl()
     state.animation_step = state.animation_step % 360;
 }
 
-static void zmk_rgb_underglow_tick(struct k_work *work)
-{
-    switch (state.current_effect)
-    {
-        case UNDERGLOW_EFFECT_SOLID:
-            zmk_rgb_underglow_effect_solid();
-            break;
-        case UNDERGLOW_EFFECT_BREATHE:
-            zmk_rgb_underglow_effect_breathe();
-            break;
-        case UNDERGLOW_EFFECT_SPECTRUM:
-            zmk_rgb_underglow_effect_spectrum();
-            break;
-        case UNDERGLOW_EFFECT_SWIRL:
-            zmk_rgb_underglow_effect_swirl();
-            break;
+static void zmk_rgb_underglow_tick(struct k_work *work) {
+    switch (state.current_effect) {
+    case UNDERGLOW_EFFECT_SOLID:
+        zmk_rgb_underglow_effect_solid();
+        break;
+    case UNDERGLOW_EFFECT_BREATHE:
+        zmk_rgb_underglow_effect_breathe();
+        break;
+    case UNDERGLOW_EFFECT_SPECTRUM:
+        zmk_rgb_underglow_effect_spectrum();
+        break;
+    case UNDERGLOW_EFFECT_SWIRL:
+        zmk_rgb_underglow_effect_swirl();
+        break;
     }
 
     led_strip_update_rgb(led_strip, pixels, STRIP_NUM_PIXELS);
@@ -224,15 +239,14 @@ static void zmk_rgb_underglow_tick_handler(struct k_timer *timer)
 
 K_TIMER_DEFINE(underglow_tick, zmk_rgb_underglow_tick_handler, NULL);
 
-static int zmk_rgb_underglow_init(struct device *_arg)
-{
-	led_strip = device_get_binding(STRIP_LABEL);
-	if (led_strip) {
-		LOG_INF("Found LED strip device %s", STRIP_LABEL);
-	} else {
-		LOG_ERR("LED strip device %s not found", STRIP_LABEL);
-		return -EINVAL;
-	}
+static int zmk_rgb_underglow_init(struct device *_arg) {
+    led_strip = device_get_binding(STRIP_LABEL);
+    if (led_strip) {
+        LOG_INF("Found LED strip device %s", STRIP_LABEL);
+    } else {
+        LOG_ERR("LED strip device %s not found", STRIP_LABEL);
+        return -EINVAL;
+    }
 
     state = (struct rgb_underglow_state){
         hue: CONFIG_ZMK_RGB_UNDERGLOW_HUE_START,
@@ -276,15 +290,15 @@ int zmk_rgb_underglow_cycle_effect(int direction)
     if (state.current_effect >= UNDERGLOW_EFFECT_NUMBER) {
         state.current_effect = 0;
     }
-    
+
     state.animation_step = 0;
 
     return zmk_rgb_underglow_save_state();
 }
 
-int zmk_rgb_underglow_toggle()
-{
-    if (!led_strip) return -ENODEV;
+int zmk_rgb_underglow_toggle() {
+    if (!led_strip)
+        return -ENODEV;
 
     state.on = !state.on;
 
@@ -300,15 +314,15 @@ int zmk_rgb_underglow_toggle()
     return zmk_rgb_underglow_save_state();
 }
 
-int zmk_rgb_underglow_change_hue(int direction)
-{
-    if (!led_strip) return -ENODEV;
+int zmk_rgb_underglow_change_hue(int direction) {
+    if (!led_strip)
+        return -ENODEV;
 
     if (state.hue == 0 && direction < 0) {
         state.hue = 360 - CONFIG_ZMK_RGB_UNDERGLOW_HUE_STEP;
         return 0;
     }
-    
+
     state.hue += direction * CONFIG_ZMK_RGB_UNDERGLOW_HUE_STEP;
 
     state.hue = state.hue % 360;
@@ -316,9 +330,9 @@ int zmk_rgb_underglow_change_hue(int direction)
     return zmk_rgb_underglow_save_state();
 }
 
-int zmk_rgb_underglow_change_sat(int direction)
-{
-    if (!led_strip) return -ENODEV;
+int zmk_rgb_underglow_change_sat(int direction) {
+    if (!led_strip)
+        return -ENODEV;
 
     if (state.saturation == 0 && direction < 0) {
         return 0;
@@ -333,9 +347,9 @@ int zmk_rgb_underglow_change_sat(int direction)
     return zmk_rgb_underglow_save_state();
 }
 
-int zmk_rgb_underglow_change_brt(int direction)
-{
-    if (!led_strip) return -ENODEV;
+int zmk_rgb_underglow_change_brt(int direction) {
+    if (!led_strip)
+        return -ENODEV;
 
     if (state.brightness == 0 && direction < 0) {
         return 0;
@@ -350,9 +364,9 @@ int zmk_rgb_underglow_change_brt(int direction)
     return zmk_rgb_underglow_save_state();
 }
 
-int zmk_rgb_underglow_change_spd(int direction)
-{
-    if (!led_strip) return -ENODEV;
+int zmk_rgb_underglow_change_spd(int direction) {
+    if (!led_strip)
+        return -ENODEV;
 
     if (state.animation_speed == 1 && direction < 0) {
         return 0;
@@ -367,6 +381,4 @@ int zmk_rgb_underglow_change_spd(int direction)
     return zmk_rgb_underglow_save_state();
 }
 
-SYS_INIT(zmk_rgb_underglow_init,
-        APPLICATION,
-        CONFIG_APPLICATION_INIT_PRIORITY);
+SYS_INIT(zmk_rgb_underglow_init, APPLICATION, CONFIG_APPLICATION_INIT_PRIORITY);
diff --git a/app/src/sensors.c b/app/src/sensors.c
index 501ce15..15f374b 100644
--- a/app/src/sensors.c
+++ b/app/src/sensors.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Peter Johanson
+ * Copyright (c) 2020 The ZMK Contributors
  *
  * SPDX-License-Identifier: MIT
  */
@@ -24,19 +24,19 @@ struct sensors_data_item {
     struct sensor_trigger trigger;
 };
 
-#define _SENSOR_ITEM(node) {.dev = NULL, .trigger = { .type = SENSOR_TRIG_DELTA, .chan = SENSOR_CHAN_ROTATION } },
-#define SENSOR_ITEM(idx, _) COND_CODE_1(DT_NODE_HAS_STATUS(ZMK_KEYMAP_SENSORS_BY_IDX(idx),okay), (_SENSOR_ITEM(ZMK_KEYMAP_SENSORS_BY_IDX(idx))),())
+#define _SENSOR_ITEM(node)                                                                         \
+    {.dev = NULL, .trigger = {.type = SENSOR_TRIG_DELTA, .chan = SENSOR_CHAN_ROTATION}},
+#define SENSOR_ITEM(idx, _)                                                                        \
+    COND_CODE_1(DT_NODE_HAS_STATUS(ZMK_KEYMAP_SENSORS_BY_IDX(idx), okay),                          \
+                (_SENSOR_ITEM(ZMK_KEYMAP_SENSORS_BY_IDX(idx))), ())
 
-static struct sensors_data_item sensors[] = {
-    UTIL_LISTIFY(ZMK_KEYMAP_SENSORS_LEN, SENSOR_ITEM, 0)
-};
+static struct sensors_data_item sensors[] = {UTIL_LISTIFY(ZMK_KEYMAP_SENSORS_LEN, SENSOR_ITEM, 0)};
 
-static void zmk_sensors_trigger_handler(struct device *dev, struct sensor_trigger *trigger)
-{
+static void zmk_sensors_trigger_handler(struct device *dev, struct sensor_trigger *trigger) {
     int err;
-    struct sensors_data_item * item = CONTAINER_OF(trigger, struct sensors_data_item, trigger);
+    struct sensors_data_item *item = CONTAINER_OF(trigger, struct sensors_data_item, trigger);
     struct sensor_event *event;
-    
+
     LOG_DBG("sensor %d", item->sensor_number);
 
     err = sensor_sample_fetch(dev);
@@ -52,8 +52,7 @@ static void zmk_sensors_trigger_handler(struct device *dev, struct sensor_trigge
     ZMK_EVENT_RAISE(event);
 }
 
-static void zmk_sensors_init_item(const char *node, u8_t i, u8_t abs_i)
-{
+static void zmk_sensors_init_item(const char *node, u8_t i, u8_t abs_i) {
     LOG_DBG("Init %s at index %d with sensor_number %d", node, i, abs_i);
 
     sensors[i].dev = device_get_binding(node);
@@ -68,10 +67,11 @@ static void zmk_sensors_init_item(const char *node, u8_t i, u8_t abs_i)
 }
 
 #define _SENSOR_INIT(node) zmk_sensors_init_item(DT_LABEL(node), local_index++, absolute_index++);
-#define SENSOR_INIT(idx, _i) COND_CODE_1(DT_NODE_HAS_STATUS(ZMK_KEYMAP_SENSORS_BY_IDX(idx),okay), (_SENSOR_INIT(ZMK_KEYMAP_SENSORS_BY_IDX(idx))),(absolute_index++;))
+#define SENSOR_INIT(idx, _i)                                                                       \
+    COND_CODE_1(DT_NODE_HAS_STATUS(ZMK_KEYMAP_SENSORS_BY_IDX(idx), okay),                          \
+                (_SENSOR_INIT(ZMK_KEYMAP_SENSORS_BY_IDX(idx))), (absolute_index++;))
 
-static int zmk_sensors_init(struct device *_arg)
-{
+static int zmk_sensors_init(struct device *_arg) {
     int local_index = 0;
     int absolute_index = 0;
 
@@ -79,8 +79,6 @@ static int zmk_sensors_init(struct device *_arg)
     return 0;
 }
 
-SYS_INIT(zmk_sensors_init,
-        APPLICATION,
-        CONFIG_APPLICATION_INIT_PRIORITY);
+SYS_INIT(zmk_sensors_init, APPLICATION, CONFIG_APPLICATION_INIT_PRIORITY);
 
 #endif /* ZMK_KEYMAP_HAS_SENSORS */
\ No newline at end of file
diff --git a/app/src/split/bluetooth/central.c b/app/src/split/bluetooth/central.c
index 237096f..cb1b68b 100644
--- a/app/src/split/bluetooth/central.c
+++ b/app/src/split/bluetooth/central.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Peter Johanson
+ * Copyright (c) 2020 The ZMK Contributors
  *
  * SPDX-License-Identifier: MIT
  */
@@ -10,12 +10,14 @@
 #include <bluetooth/conn.h>
 #include <bluetooth/uuid.h>
 #include <bluetooth/gatt.h>
+#include <bluetooth/hci.h>
 #include <sys/byteorder.h>
 
 #include <logging/log.h>
 
 LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
 
+#include <zmk/ble.h>
 #include <zmk/split/bluetooth/uuid.h>
 #include <zmk/event-manager.h>
 #include <zmk/events/position-state-changed.h>
@@ -31,283 +33,290 @@ static struct bt_uuid_128 uuid = BT_UUID_INIT_128(ZMK_SPLIT_BT_SERVICE_UUID);
 static struct bt_gatt_discover_params discover_params;
 static struct bt_gatt_subscribe_params subscribe_params;
 
-static u8_t split_central_notify_func(struct bt_conn *conn,
-			   struct bt_gatt_subscribe_params *params,
-			   const void *data, u16_t length)
-{
-	static u8_t position_state[POSITION_STATE_DATA_LEN];
+static u8_t split_central_notify_func(struct bt_conn *conn, struct bt_gatt_subscribe_params *params,
+                                      const void *data, u16_t length) {
+    static u8_t position_state[POSITION_STATE_DATA_LEN];
 
-	u8_t changed_positions[POSITION_STATE_DATA_LEN];
+    u8_t changed_positions[POSITION_STATE_DATA_LEN];
 
-	if (!data) {
-		LOG_DBG("[UNSUBSCRIBED]");
-		params->value_handle = 0U;
-		return BT_GATT_ITER_STOP;
-	}
+    if (!data) {
+        LOG_DBG("[UNSUBSCRIBED]");
+        params->value_handle = 0U;
+        return BT_GATT_ITER_STOP;
+    }
 
-	LOG_DBG("[NOTIFICATION] data %p length %u", data, length);
+    LOG_DBG("[NOTIFICATION] data %p length %u", data, length);
 
-	for (int i = 0; i < POSITION_STATE_DATA_LEN; i++) {
-		changed_positions[i] = ((u8_t *)data)[i] ^ position_state[i];
-		position_state[i] = ((u8_t *)data)[i];
-	}
+    for (int i = 0; i < POSITION_STATE_DATA_LEN; i++) {
+        changed_positions[i] = ((u8_t *)data)[i] ^ position_state[i];
+        position_state[i] = ((u8_t *)data)[i];
+    }
 
-	for (int i = 0; i < POSITION_STATE_DATA_LEN; i++) {
-		for (int j = 0; j < 8; j++) {
-			if (changed_positions[i] & BIT(j)) {
-				u32_t position = (i * 8) + j;
-				bool pressed = position_state[i] & BIT(j);
-				struct position_state_changed *pos_ev = new_position_state_changed();
-				pos_ev->position = position;
-				pos_ev->state = pressed;
+    for (int i = 0; i < POSITION_STATE_DATA_LEN; i++) {
+        for (int j = 0; j < 8; j++) {
+            if (changed_positions[i] & BIT(j)) {
+                u32_t position = (i * 8) + j;
+                bool pressed = position_state[i] & BIT(j);
+                struct position_state_changed *pos_ev = new_position_state_changed();
+                pos_ev->position = position;
+                pos_ev->state = pressed;
 
-				LOG_DBG("Trigger key position state change for %d", position);
-				ZMK_EVENT_RAISE(pos_ev);
-			}
-		}
-	}
+                LOG_DBG("Trigger key position state change for %d", position);
+                ZMK_EVENT_RAISE(pos_ev);
+            }
+        }
+    }
+
+    return BT_GATT_ITER_CONTINUE;
+}
 
+static int split_central_subscribe(struct bt_conn *conn) {
+    int err = bt_gatt_subscribe(conn, &subscribe_params);
+    switch (err) {
+    case -EALREADY:
+        LOG_DBG("[ALREADY SUBSCRIBED]");
+        break;
+        // break;
+        // bt_gatt_unsubscribe(conn, &subscribe_params);
+        // return split_central_subscribe(conn);
+    case 0:
+        LOG_DBG("[SUBSCRIBED]");
+        break;
+    default:
+        LOG_ERR("Subscribe failed (err %d)", err);
+        break;
+    }
 
-	return BT_GATT_ITER_CONTINUE;
+    return 0;
 }
 
-static u8_t split_central_discovery_func(struct bt_conn *conn,
-			     const struct bt_gatt_attr *attr,
-			     struct bt_gatt_discover_params *params)
-{
-	int err;
-
-	if (!attr) {
-		LOG_DBG("Discover complete");
-		(void)memset(params, 0, sizeof(*params));
-		return BT_GATT_ITER_STOP;
-	}
-
-	LOG_DBG("[ATTRIBUTE] handle %u", attr->handle);
-
-	if (!bt_uuid_cmp(discover_params.uuid, BT_UUID_DECLARE_128(ZMK_SPLIT_BT_SERVICE_UUID))) {
-		memcpy(&uuid, BT_UUID_DECLARE_128(ZMK_SPLIT_BT_CHAR_POSITION_STATE_UUID), sizeof(uuid));
-		discover_params.uuid = &uuid.uuid;
-		discover_params.start_handle = attr->handle + 1;
-		discover_params.type = BT_GATT_DISCOVER_CHARACTERISTIC;
-
-		err = bt_gatt_discover(conn, &discover_params);
-		if (err) {
-			LOG_ERR("Discover failed (err %d)", err);
-		}
-	} else if (!bt_uuid_cmp(discover_params.uuid,
-				BT_UUID_DECLARE_128(ZMK_SPLIT_BT_CHAR_POSITION_STATE_UUID))) {
-		memcpy(&uuid, BT_UUID_GATT_CCC, sizeof(uuid));
-		discover_params.uuid = &uuid.uuid;
-		discover_params.start_handle = attr->handle + 2;
-		discover_params.type = BT_GATT_DISCOVER_DESCRIPTOR;
-		subscribe_params.value_handle = bt_gatt_attr_value_handle(attr);
-
-		err = bt_gatt_discover(conn, &discover_params);
-		if (err) {
-			LOG_ERR("Discover failed (err %d)", err);
-		}
-	} else {
-		subscribe_params.notify = split_central_notify_func;
-		subscribe_params.value = BT_GATT_CCC_NOTIFY;
-		subscribe_params.ccc_handle = attr->handle;
-
-		err = bt_gatt_subscribe(conn, &subscribe_params);
-		if (err && err != -EALREADY) {
-			LOG_ERR("Subscribe failed (err %d)", err);
-		} else {
-			LOG_DBG("[SUBSCRIBED]");
-		}
-
-		return BT_GATT_ITER_STOP;
-	}
-
-	return BT_GATT_ITER_STOP;
+static u8_t split_central_discovery_func(struct bt_conn *conn, const struct bt_gatt_attr *attr,
+                                         struct bt_gatt_discover_params *params) {
+    int err;
+
+    if (!attr) {
+        LOG_DBG("Discover complete");
+        (void)memset(params, 0, sizeof(*params));
+        return BT_GATT_ITER_STOP;
+    }
+
+    LOG_DBG("[ATTRIBUTE] handle %u", attr->handle);
+
+    if (!bt_uuid_cmp(discover_params.uuid, BT_UUID_DECLARE_128(ZMK_SPLIT_BT_SERVICE_UUID))) {
+        memcpy(&uuid, BT_UUID_DECLARE_128(ZMK_SPLIT_BT_CHAR_POSITION_STATE_UUID), sizeof(uuid));
+        discover_params.uuid = &uuid.uuid;
+        discover_params.start_handle = attr->handle + 1;
+        discover_params.type = BT_GATT_DISCOVER_CHARACTERISTIC;
+
+        err = bt_gatt_discover(conn, &discover_params);
+        if (err) {
+            LOG_ERR("Discover failed (err %d)", err);
+        }
+    } else if (!bt_uuid_cmp(discover_params.uuid,
+                            BT_UUID_DECLARE_128(ZMK_SPLIT_BT_CHAR_POSITION_STATE_UUID))) {
+        memcpy(&uuid, BT_UUID_GATT_CCC, sizeof(uuid));
+        discover_params.uuid = &uuid.uuid;
+        discover_params.start_handle = attr->handle + 2;
+        discover_params.type = BT_GATT_DISCOVER_DESCRIPTOR;
+        subscribe_params.value_handle = bt_gatt_attr_value_handle(attr);
+
+        err = bt_gatt_discover(conn, &discover_params);
+        if (err) {
+            LOG_ERR("Discover failed (err %d)", err);
+        }
+    } else {
+        subscribe_params.notify = split_central_notify_func;
+        subscribe_params.value = BT_GATT_CCC_NOTIFY;
+        subscribe_params.ccc_handle = attr->handle;
+
+        split_central_subscribe(conn);
+
+        return BT_GATT_ITER_STOP;
+    }
+
+    return BT_GATT_ITER_STOP;
 }
 
 static void split_central_process_connection(struct bt_conn *conn) {
-	int err;
-
-	LOG_DBG("Current security for connection: %d", bt_conn_get_security(conn));
-	
-	err = bt_conn_set_security(conn, BT_SECURITY_L2);
-	if (err) {
-		LOG_ERR("Failed to set security (reason %d)", err);
-		return;
-	}
-
-	if (conn == default_conn) {
-		discover_params.uuid = &uuid.uuid;
-		discover_params.func = split_central_discovery_func;
-		discover_params.start_handle = 0x0001;
-		discover_params.end_handle = 0xffff;
-		discover_params.type = BT_GATT_DISCOVER_PRIMARY;
-
-		err = bt_gatt_discover(default_conn, &discover_params);
-		if (err) {
-			LOG_ERR("Discover failed(err %d)", err);
-			return;
-		}
-	}
-
-	struct bt_conn_info info;
-
-	bt_conn_get_info(conn, &info);
-
-	LOG_DBG("New connection params: Interval: %d, Latency: %d, PHY: %d", info.le.interval, info.le.latency, info.le.phy->rx_phy);
+    int err;
+
+    LOG_DBG("Current security for connection: %d", bt_conn_get_security(conn));
+
+    err = bt_conn_set_security(conn, BT_SECURITY_L2);
+    if (err) {
+        LOG_ERR("Failed to set security (reason %d)", err);
+        return;
+    }
+
+    if (conn == default_conn && !subscribe_params.value) {
+        discover_params.uuid = &uuid.uuid;
+        discover_params.func = split_central_discovery_func;
+        discover_params.start_handle = 0x0001;
+        discover_params.end_handle = 0xffff;
+        discover_params.type = BT_GATT_DISCOVER_PRIMARY;
+
+        err = bt_gatt_discover(default_conn, &discover_params);
+        if (err) {
+            LOG_ERR("Discover failed(err %d)", err);
+            return;
+        }
+    }
+
+    struct bt_conn_info info;
+
+    bt_conn_get_info(conn, &info);
+
+    LOG_DBG("New connection params: Interval: %d, Latency: %d, PHY: %d", info.le.interval,
+            info.le.latency, info.le.phy->rx_phy);
 }
 
-static bool split_central_eir_found(struct bt_data *data, void *user_data)
-{
-	bt_addr_le_t *addr = user_data;
-	int i;
+static bool split_central_eir_found(struct bt_data *data, void *user_data) {
+    bt_addr_le_t *addr = user_data;
+    int i;
 
-	LOG_DBG("[AD]: %u data_len %u", data->type, data->data_len);
+    LOG_DBG("[AD]: %u data_len %u", data->type, data->data_len);
 
-	switch (data->type) {
-	case BT_DATA_UUID128_SOME:
-	case BT_DATA_UUID128_ALL:
-		if (data->data_len % 16 != 0U) {
-			LOG_ERR("AD malformed");
-			return true;
-		}
+    switch (data->type) {
+    case BT_DATA_UUID128_SOME:
+    case BT_DATA_UUID128_ALL:
+        if (data->data_len % 16 != 0U) {
+            LOG_ERR("AD malformed");
+            return true;
+        }
 
-		for (i = 0; i < data->data_len; i += 16) {
-			struct bt_le_conn_param *param;
-			struct bt_uuid uuid;
-			int err;
+        for (i = 0; i < data->data_len; i += 16) {
+            struct bt_le_conn_param *param;
+            struct bt_uuid uuid;
+            int err;
 
             if (!bt_uuid_create(&uuid, &data->data[i], 16)) {
                 LOG_ERR("Unable to load UUID");
                 continue;
             }
 
-			if (!bt_uuid_cmp(&uuid, BT_UUID_DECLARE_128(ZMK_SPLIT_BT_SERVICE_UUID))) {
-				char uuid_str[BT_UUID_STR_LEN];
-				char service_uuid_str[BT_UUID_STR_LEN];
-
-				bt_uuid_to_str(&uuid, uuid_str, sizeof(uuid_str));
-				bt_uuid_to_str(BT_UUID_DECLARE_128(ZMK_SPLIT_BT_SERVICE_UUID), service_uuid_str, sizeof(service_uuid_str));
-				LOG_DBG("UUID %s does not match split UUID: %s", log_strdup(uuid_str), log_strdup(service_uuid_str));
-				continue;
-			}
-
-			LOG_DBG("Found the split service");
-
-			err = bt_le_scan_stop();
-			if (err) {
-				LOG_ERR("Stop LE scan failed (err %d)", err);
-				continue;
-			}
-
-			default_conn = bt_conn_lookup_addr_le(BT_ID_DEFAULT, addr);
-			if (default_conn) {
-				LOG_DBG("Found existing connection");
-				split_central_process_connection(default_conn);
-			} else {
-				param = BT_LE_CONN_PARAM(0x0006, 0x0006, 30, 400);
-				err = bt_conn_le_create(addr, BT_CONN_LE_CREATE_CONN,
-							param, &default_conn);
-				if (err) {
-					LOG_ERR("Create conn failed (err %d)", err);
-					start_scan();
-				}
-
-				err = bt_conn_le_phy_update(default_conn, BT_CONN_LE_PHY_PARAM_2M);
-				if (err) {
-					LOG_ERR("Update phy conn failed (err %d)", err);
-					start_scan();
-				}
-			}
-
-			return false;
-		}
-	}
-
-	return true;
+            if (!bt_uuid_cmp(&uuid, BT_UUID_DECLARE_128(ZMK_SPLIT_BT_SERVICE_UUID))) {
+                char uuid_str[BT_UUID_STR_LEN];
+                char service_uuid_str[BT_UUID_STR_LEN];
+
+                bt_uuid_to_str(&uuid, uuid_str, sizeof(uuid_str));
+                bt_uuid_to_str(BT_UUID_DECLARE_128(ZMK_SPLIT_BT_SERVICE_UUID), service_uuid_str,
+                               sizeof(service_uuid_str));
+                LOG_DBG("UUID %s does not match split UUID: %s", log_strdup(uuid_str),
+                        log_strdup(service_uuid_str));
+                continue;
+            }
+
+            LOG_DBG("Found the split service");
+
+            zmk_ble_set_peripheral_addr(addr);
+
+            err = bt_le_scan_stop();
+            if (err) {
+                LOG_ERR("Stop LE scan failed (err %d)", err);
+                continue;
+            }
+
+            default_conn = bt_conn_lookup_addr_le(BT_ID_DEFAULT, addr);
+            if (default_conn) {
+                LOG_DBG("Found existing connection");
+                split_central_process_connection(default_conn);
+            } else {
+                param = BT_LE_CONN_PARAM(0x0006, 0x0006, 30, 400);
+
+                err = bt_conn_le_create(addr, BT_CONN_LE_CREATE_CONN, param, &default_conn);
+                if (err) {
+                    LOG_ERR("Create conn failed (err %d) (create conn? 0x%04x)", err,
+                            BT_HCI_OP_LE_CREATE_CONN);
+                    start_scan();
+                }
+
+                err = bt_conn_le_phy_update(default_conn, BT_CONN_LE_PHY_PARAM_2M);
+                if (err) {
+                    LOG_ERR("Update phy conn failed (err %d)", err);
+                    start_scan();
+                }
+            }
+
+            return false;
+        }
+    }
+
+    return true;
 }
 
 static void split_central_device_found(const bt_addr_le_t *addr, s8_t rssi, u8_t type,
-			 struct net_buf_simple *ad)
-{
-	char dev[BT_ADDR_LE_STR_LEN];
-
-	bt_addr_le_to_str(addr, dev, sizeof(dev));
-	LOG_DBG("[DEVICE]: %s, AD evt type %u, AD data len %u, RSSI %i",
-	       log_strdup(dev), type, ad->len, rssi);
-
-	/* We're only interested in connectable events */
-	if (type == BT_GAP_ADV_TYPE_ADV_IND ||
-	    type == BT_GAP_ADV_TYPE_ADV_DIRECT_IND) {
-		bt_data_parse(ad, split_central_eir_found, (void *)addr);
-	}
+                                       struct net_buf_simple *ad) {
+    char dev[BT_ADDR_LE_STR_LEN];
+
+    bt_addr_le_to_str(addr, dev, sizeof(dev));
+    LOG_DBG("[DEVICE]: %s, AD evt type %u, AD data len %u, RSSI %i", log_strdup(dev), type, ad->len,
+            rssi);
+
+    /* We're only interested in connectable events */
+    if (type == BT_GAP_ADV_TYPE_ADV_IND || type == BT_GAP_ADV_TYPE_ADV_DIRECT_IND) {
+        bt_data_parse(ad, split_central_eir_found, (void *)addr);
+    }
 }
 
-static int start_scan(void)
-{
-	int err;
+static int start_scan(void) {
+    int err;
 
-	err = bt_le_scan_start(BT_LE_SCAN_PASSIVE, split_central_device_found);
-	if (err) {
-		LOG_ERR("Scanning failed to start (err %d)", err);
-		return err;
-	}
+    err = bt_le_scan_start(BT_LE_SCAN_PASSIVE, split_central_device_found);
+    if (err) {
+        LOG_ERR("Scanning failed to start (err %d)", err);
+        return err;
+    }
 
-	LOG_DBG("Scanning successfully started");
+    LOG_DBG("Scanning successfully started");
     return 0;
 }
 
-static void split_central_connected(struct bt_conn *conn, u8_t conn_err)
-{
-	char addr[BT_ADDR_LE_STR_LEN];
+static void split_central_connected(struct bt_conn *conn, u8_t conn_err) {
+    char addr[BT_ADDR_LE_STR_LEN];
 
-	bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
+    bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
 
-	if (conn_err) {
-		LOG_ERR("Failed to connect to %s (%u)", addr, conn_err);
+    if (conn_err) {
+        LOG_ERR("Failed to connect to %s (%u)", log_strdup(addr), conn_err);
 
-		bt_conn_unref(default_conn);
-		default_conn = NULL;
+        bt_conn_unref(default_conn);
+        default_conn = NULL;
 
-		start_scan();
-		return;
-	}
+        start_scan();
+        return;
+    }
 
-	LOG_DBG("Connected: %s", log_strdup(addr));	
+    LOG_DBG("Connected: %s", log_strdup(addr));
 
-	split_central_process_connection(conn);
+    split_central_process_connection(conn);
 }
 
-static void split_central_disconnected(struct bt_conn *conn, u8_t reason)
-{
-	char addr[BT_ADDR_LE_STR_LEN];
+static void split_central_disconnected(struct bt_conn *conn, u8_t reason) {
+    char addr[BT_ADDR_LE_STR_LEN];
 
-	bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
+    bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
 
-	LOG_DBG("Disconnected: %s (reason %d)", log_strdup(addr), reason);
+    LOG_DBG("Disconnected: %s (reason %d)", log_strdup(addr), reason);
 
-	if (default_conn != conn) {
-		return;
-	}
+    if (default_conn != conn) {
+        return;
+    }
 
-	bt_conn_unref(default_conn);
-	default_conn = NULL;
+    bt_conn_unref(default_conn);
+    default_conn = NULL;
 
-	start_scan();
+    start_scan();
 }
 
 static struct bt_conn_cb conn_callbacks = {
-	.connected = split_central_connected,
-	.disconnected = split_central_disconnected,
+    .connected = split_central_connected,
+    .disconnected = split_central_disconnected,
 };
 
-int zmk_split_bt_central_init(struct device *_arg)
-{
-	bt_conn_cb_register(&conn_callbacks);
+int zmk_split_bt_central_init(struct device *_arg) {
+    bt_conn_cb_register(&conn_callbacks);
 
-	return start_scan();
+    return start_scan();
 }
 
-SYS_INIT(zmk_split_bt_central_init,
-         APPLICATION,
-		 CONFIG_ZMK_BLE_INIT_PRIORITY);
\ No newline at end of file
+SYS_INIT(zmk_split_bt_central_init, APPLICATION, CONFIG_ZMK_BLE_INIT_PRIORITY);
\ No newline at end of file
diff --git a/app/src/split/bluetooth/service.c b/app/src/split/bluetooth/service.c
index e1d232a..86af685 100644
--- a/app/src/split/bluetooth/service.c
+++ b/app/src/split/bluetooth/service.c
@@ -1,6 +1,16 @@
+/*
+ * Copyright (c) 2020 The ZMK Contributors
+ *
+ * SPDX-License-Identifier: MIT
+ */
 
 #include <zephyr/types.h>
 #include <sys/util.h>
+
+#include <logging/log.h>
+
+LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
+
 #include <bluetooth/gatt.h>
 #include <bluetooth/uuid.h>
 
@@ -11,40 +21,36 @@
 static u8_t num_of_positions = ZMK_KEYMAP_LEN;
 static u8_t position_state[16];
 
-static ssize_t split_svc_pos_state(struct bt_conn *conn, const struct bt_gatt_attr *attrs, void *buf, u16_t len, u16_t offset)
-{
-    return bt_gatt_attr_read(conn, attrs, buf, len, offset, &position_state, sizeof(position_state));
+static ssize_t split_svc_pos_state(struct bt_conn *conn, const struct bt_gatt_attr *attrs,
+                                   void *buf, u16_t len, u16_t offset) {
+    return bt_gatt_attr_read(conn, attrs, buf, len, offset, &position_state,
+                             sizeof(position_state));
 }
 
-static ssize_t split_svc_num_of_positions(struct bt_conn *conn, const struct bt_gatt_attr *attrs, void *buf, u16_t len, u16_t offset)
-{
+static ssize_t split_svc_num_of_positions(struct bt_conn *conn, const struct bt_gatt_attr *attrs,
+                                          void *buf, u16_t len, u16_t offset) {
     return bt_gatt_attr_read(conn, attrs, buf, len, offset, attrs->user_data, sizeof(u8_t));
 }
 
-static void split_svc_pos_state_ccc(const struct bt_gatt_attr *attr, u16_t value)
-{
+static void split_svc_pos_state_ccc(const struct bt_gatt_attr *attr, u16_t value) {
+    LOG_DBG("value %d", value);
 }
 
+BT_GATT_SERVICE_DEFINE(
+    split_svc, BT_GATT_PRIMARY_SERVICE(BT_UUID_DECLARE_128(ZMK_SPLIT_BT_SERVICE_UUID)),
+    BT_GATT_CHARACTERISTIC(BT_UUID_DECLARE_128(ZMK_SPLIT_BT_CHAR_POSITION_STATE_UUID),
+                           BT_GATT_CHRC_READ | BT_GATT_CHRC_NOTIFY, BT_GATT_PERM_READ_ENCRYPT,
+                           split_svc_pos_state, NULL, &position_state),
+    BT_GATT_CCC(split_svc_pos_state_ccc, BT_GATT_PERM_READ_ENCRYPT | BT_GATT_PERM_WRITE_ENCRYPT),
+    BT_GATT_DESCRIPTOR(BT_UUID_NUM_OF_DIGITALS, BT_GATT_PERM_READ, split_svc_num_of_positions, NULL,
+                       &num_of_positions), );
 
-BT_GATT_SERVICE_DEFINE(split_svc,
-                       BT_GATT_PRIMARY_SERVICE(BT_UUID_DECLARE_128(ZMK_SPLIT_BT_SERVICE_UUID)),
-                       BT_GATT_CHARACTERISTIC(BT_UUID_DECLARE_128(ZMK_SPLIT_BT_CHAR_POSITION_STATE_UUID), BT_GATT_CHRC_READ | BT_GATT_CHRC_NOTIFY,
-                                              BT_GATT_PERM_READ_ENCRYPT,
-                                              split_svc_pos_state, NULL, &position_state),
-                       BT_GATT_CCC(split_svc_pos_state_ccc,
-                                   BT_GATT_PERM_READ_ENCRYPT | BT_GATT_PERM_WRITE_ENCRYPT),
-                       BT_GATT_DESCRIPTOR(BT_UUID_NUM_OF_DIGITALS, BT_GATT_PERM_READ,
-                                          split_svc_num_of_positions, NULL, &num_of_positions),
-);
-
-int zmk_split_bt_position_pressed(u8_t position)
-{
+int zmk_split_bt_position_pressed(u8_t position) {
     WRITE_BIT(position_state[position / 8], position % 8, true);
     return bt_gatt_notify(NULL, &split_svc.attrs[1], &position_state, sizeof(position_state));
 }
 
-int zmk_split_bt_position_released(u8_t position)
-{
+int zmk_split_bt_position_released(u8_t position) {
     WRITE_BIT(position_state[position / 8], position % 8, false);
     return bt_gatt_notify(NULL, &split_svc.attrs[1], &position_state, sizeof(position_state));
 }
\ No newline at end of file
diff --git a/app/src/split_listener.c b/app/src/split_listener.c
index 65f835a..b2adfb2 100644
--- a/app/src/split_listener.c
+++ b/app/src/split_listener.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Peter Johanson <peter@peterjohanson.com>
+ * Copyright (c) 2020 The ZMK Contributors
  *
  * SPDX-License-Identifier: MIT
  */
@@ -19,17 +19,17 @@ LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
 #include <zmk/hid.h>
 #include <zmk/endpoints.h>
 
-int split_listener(const struct zmk_event_header *eh)
-{
-  if (is_position_state_changed(eh)) {
-    const struct position_state_changed *ev = cast_position_state_changed(eh);
-    if (ev->state) {
-      zmk_split_bt_position_pressed(ev->position);
-    } else {
-      zmk_split_bt_position_released(ev->position);
+int split_listener(const struct zmk_event_header *eh) {
+    LOG_DBG("");
+    if (is_position_state_changed(eh)) {
+        const struct position_state_changed *ev = cast_position_state_changed(eh);
+        if (ev->state) {
+            return zmk_split_bt_position_pressed(ev->position);
+        } else {
+            return zmk_split_bt_position_released(ev->position);
+        }
     }
-  }
-  return 0;
+    return 0;
 }
 
 ZMK_LISTENER(split_listener, split_listener);
diff --git a/app/src/usb_hid.c b/app/src/usb_hid.c
index 784fc25..530ffea 100644
--- a/app/src/usb_hid.c
+++ b/app/src/usb_hid.c
@@ -1,3 +1,8 @@
+/*
+ * Copyright (c) 2020 The ZMK Contributors
+ *
+ * SPDX-License-Identifier: MIT
+ */
 
 #include <device.h>
 #include <init.h>
@@ -17,71 +22,56 @@ static struct device *hid_dev;
 
 static K_SEM_DEFINE(hid_sem, 1, 1);
 
-static void in_ready_cb(void)
-{
-	k_sem_give(&hid_sem);
-}
+static void in_ready_cb(void) { k_sem_give(&hid_sem); }
 
-static const struct hid_ops ops =
-{
-	.int_in_ready = in_ready_cb,
+static const struct hid_ops ops = {
+    .int_in_ready = in_ready_cb,
 };
 
-int zmk_usb_hid_send_report(const u8_t *report, size_t len)
-{
-	switch(usb_status) {
-	case USB_DC_SUSPEND:
-		return usb_wakeup_request();
-	case USB_DC_ERROR:
-	case USB_DC_RESET:
-	case USB_DC_DISCONNECTED:
-	case USB_DC_UNKNOWN:
-		return -ENODEV;
-	default:
-		k_sem_take(&hid_sem, K_MSEC(30));
-		int err = hid_int_ep_write(hid_dev, report, len, NULL);
-
-		if (err) {
-			k_sem_give(&hid_sem);
-		}
-
-		return err;
-	}
+int zmk_usb_hid_send_report(const u8_t *report, size_t len) {
+    switch (usb_status) {
+    case USB_DC_SUSPEND:
+        return usb_wakeup_request();
+    case USB_DC_ERROR:
+    case USB_DC_RESET:
+    case USB_DC_DISCONNECTED:
+    case USB_DC_UNKNOWN:
+        return -ENODEV;
+    default:
+        k_sem_take(&hid_sem, K_MSEC(30));
+        int err = hid_int_ep_write(hid_dev, report, len, NULL);
+
+        if (err) {
+            k_sem_give(&hid_sem);
+        }
+
+        return err;
+    }
 }
 
-void usb_hid_status_cb(enum usb_dc_status_code status, const u8_t *params)
-{
-	usb_status = status;
-};
+void usb_hid_status_cb(enum usb_dc_status_code status, const u8_t *params) { usb_status = status; };
 
-static int zmk_usb_hid_init(struct device *_arg)
-{
-	int usb_enable_ret;
+static int zmk_usb_hid_init(struct device *_arg) {
+    int usb_enable_ret;
 
-	hid_dev = device_get_binding("HID_0");
-	if (hid_dev == NULL)
-	{
-		LOG_ERR("Unable to locate HID device");
-		return -EINVAL;
-	}
+    hid_dev = device_get_binding("HID_0");
+    if (hid_dev == NULL) {
+        LOG_ERR("Unable to locate HID device");
+        return -EINVAL;
+    }
 
-	usb_hid_register_device(hid_dev,
-							zmk_hid_report_desc, sizeof(zmk_hid_report_desc),
-							&ops);
+    usb_hid_register_device(hid_dev, zmk_hid_report_desc, sizeof(zmk_hid_report_desc), &ops);
 
-	usb_hid_init(hid_dev);
+    usb_hid_init(hid_dev);
 
-	usb_enable_ret = usb_enable(usb_hid_status_cb);
+    usb_enable_ret = usb_enable(usb_hid_status_cb);
 
-	if (usb_enable_ret != 0)
-	{
-		LOG_ERR("Unable to enable USB");
-		return -EINVAL;
-	}
+    if (usb_enable_ret != 0) {
+        LOG_ERR("Unable to enable USB");
+        return -EINVAL;
+    }
 
-	return 0;
+    return 0;
 }
 
-SYS_INIT(zmk_usb_hid_init,
-         APPLICATION,
-		 CONFIG_ZMK_USB_INIT_PRIORITY);
+SYS_INIT(zmk_usb_hid_init, APPLICATION, CONFIG_ZMK_USB_INIT_PRIORITY);