Move Zephyr app into subdirectory.

11 files changed, 0 insertions, 1152 deletions

diff --git a/src/ble.c b/src/ble.c
deleted file mode 100644
index 51607c6..0000000
--- a/src/ble.c
+++ /dev/null
@@ -1,193 +0,0 @@
-
-#include <math.h>
-
-#include <settings/settings.h>
-#include <bluetooth/bluetooth.h>
-#include <bluetooth/conn.h>
-#include <bluetooth/hci.h>
-#include <bluetooth/uuid.h>
-#include <bluetooth/gatt.h>
-
-#include <zmk/keys.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;
-
-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)
-    {
-        printk("Failed to connect to %s (%u)\n", addr, err);
-        return;
-    }
-
-    printk("Connected %s\n", addr);
-
-    if (bt_conn_set_security(conn, BT_SECURITY_L2))
-    {
-        printk("Failed to set security\n");
-    }
-}
-
-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));
-
-    printk("Disconnected from %s (reason 0x%02x)\n", addr, reason);
-}
-
-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)
-    {
-        printk("Security changed: %s level %u\n", addr, level);
-    }
-    else
-    {
-        printk("Security failed: %s level %u err %d\n", addr, level,
-               err);
-    }
-}
-
-static struct bt_conn_cb conn_callbacks = {
-    .connected = connected,
-    .disconnected = disconnected,
-    .security_changed = security_changed,
-};
-
-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));
-
-    printk("Passkey for %s: %06u\n", addr, passkey);
-}
-
-#ifdef CONFIG_ZMK_BLE_PASSKEY_ENTRY
-
-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));
-
-    printk("Passkey entry requested for %s\n", addr);
-    auth_passkey_entry_conn = bt_conn_ref(conn);
-}
-
-#endif
-
-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)
-    {
-        bt_conn_unref(auth_passkey_entry_conn);
-        auth_passkey_entry_conn = NULL;
-    }
-
-    passkey_digit = 0;
-
-    printk("Pairing cancelled: %s\n", addr);
-}
-
-static struct bt_conn_auth_cb zmk_ble_auth_cb_display = {
-// .passkey_display = auth_passkey_display,
-
-#ifdef CONFIG_ZMK_BLE_PASSKEY_ENTRY
-    .passkey_entry = auth_passkey_entry,
-#endif
-    .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_ALL,
-                  0x12, 0x18,  /* HID Service */
-                  0x0f, 0x18), /* Battery Service */
-};
-
-static void zmk_ble_ready(int err)
-{
-    if (err)
-    {
-        printk("Bluetooth init failed (err %d)\n", err);
-        return;
-    }
-
-    err = bt_le_adv_start(BT_LE_ADV_CONN_NAME, zmk_ble_ad, ARRAY_SIZE(zmk_ble_ad), NULL, 0);
-    if (err)
-    {
-        printk("Advertising failed to start (err %d)\n", err);
-        return;
-    }
-}
-
-int zmk_ble_init()
-{
-    if (IS_ENABLED(CONFIG_SETTINGS))
-    {
-        settings_load();
-    }
-    int err = bt_enable(zmk_ble_ready);
-
-    if (err)
-    {
-        printk("BLUETOOTH FAILED");
-        return err;
-    }
-
-    bt_conn_cb_register(&conn_callbacks);
-    bt_conn_auth_cb_register(&zmk_ble_auth_cb_display);
-
-    return 0;
-}
-
-bool zmk_ble_handle_key_user(struct zmk_key_event *key_event)
-{
-    zmk_key key = key_event->key;
-
-    if (!auth_passkey_entry_conn)
-    {
-        return true;
-    }
-
-    if (key < KC_1 || key > KC_0)
-    {
-        return true;
-    }
-
-    u32_t val = (key == KC_0) ? 0 : (key - KC_1 + 1);
-
-    passkey_entries[passkey_digit++] = val;
-
-    if (passkey_digit == 6)
-    {
-        u32_t passkey = 0;
-        for (int i = 5; i >= 0; i--)
-        {
-            passkey = (passkey * 10) + val;
-        }
-        bt_conn_auth_passkey_entry(auth_passkey_entry_conn, passkey);
-        bt_conn_unref(auth_passkey_entry_conn);
-        auth_passkey_entry_conn = NULL;
-    }
-
-    return false;
-}
diff --git a/src/endpoints.c b/src/endpoints.c
deleted file mode 100644
index f46d42d..0000000
--- a/src/endpoints.c
+++ /dev/null
@@ -1,105 +0,0 @@
-
-#include <zmk/endpoints.h>
-#include <zmk/hid.h>
-#include <zmk/usb_hid.h>
-#include <zmk/hog.h>
-
-#include <logging/log.h>
-LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
-
-int zmk_endpoints_init()
-{
-    int err;
-
-    LOG_DBG("");
-
-#ifdef CONFIG_ZMK_USB
-    err = zmk_usb_hid_init();
-    if (err)
-    {
-        LOG_ERR("USB HID Init Failed\n");
-        return err;
-    }
-#endif /* CONFIG_ZMK_USB */
-
-#ifdef CONFIG_ZMK_BLE
-    err = zmk_hog_init();
-    if (err)
-    {
-        LOG_ERR("HOG Init Failed\n");
-        return err;
-    }
-
-#endif /* CONFIG_ZMK_BLE */
-
-    return 0;
-}
-
-int zmk_endpoints_send_report(enum zmk_hid_report_changes report_type)
-{
-    int err;
-    struct zmk_hid_keypad_report *keypad_report;
-    struct zmk_hid_consumer_report *consumer_report;
-    switch (report_type)
-    {
-    case 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)
-        {
-            LOG_DBG("USB Send Failed");
-        }
-#endif /* CONFIG_ZMK_USB */
-
-#ifdef CONFIG_ZMK_BLE
-        err = zmk_hog_send_keypad_report(&keypad_report->body);
-        if (err)
-        {
-            LOG_ERR("FAILED TO SEND OVER HOG: %d", err);
-        }
-#endif /* CONFIG_ZMK_BLE */
-
-        break;
-    case 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)
-        {
-            LOG_DBG("USB Send Failed");
-        }
-#endif /* CONFIG_ZMK_USB */
-
-#ifdef CONFIG_ZMK_BLE
-        err = zmk_hog_send_consumer_report(&consumer_report->body);
-        if (err)
-        {
-            LOG_ERR("FAILED TO SEND OVER HOG: %d", err);
-        }
-#endif /* CONFIG_ZMK_BLE */
-
-        break;
-    default:
-        LOG_ERR("Unknown report change type %d", report_type);
-        return -EINVAL;
-    }
-
-    return 0;
-}
-
-int zmk_endpoints_send_key_event(struct zmk_key_event key_event)
-{
-    enum zmk_hid_report_changes changes;
-
-    LOG_DBG("key %d, state %d\n", key_event.key, key_event.pressed);
-
-    if (key_event.pressed)
-    {
-        changes = zmk_hid_press_key(key_event.key);
-    }
-    else
-    {
-        changes = zmk_hid_release_key(key_event.key);
-    }
-
-    return zmk_endpoints_send_report(changes);
-}
diff --git a/src/handlers.c b/src/handlers.c
deleted file mode 100644
index 464b1ab..0000000
--- a/src/handlers.c
+++ /dev/null
@@ -1,88 +0,0 @@
-
-#include <zmk/ble.h>
-#include <zmk/handlers.h>
-#include <zmk/endpoints.h>
-#include <zmk/hid.h>
-#include <zmk/matrix.h>
-
-#ifdef CONFIG_ZMK_ACTION_MOD_TAP
-u16_t action_effect_pending = 0;
-#endif
-
-__attribute__((weak)) bool zmk_handle_key_user(struct zmk_key_event *key_event)
-{
-	return true;
-};
-
-bool zmk_handle_action(zmk_action action, struct zmk_key_event *key_event)
-{
-	zmk_mod mods = ZK_MODS(key_event->key);
-	u8_t flattened_index = (key_event->row * ZMK_MATRIX_COLS) + key_event->column;
-	switch (action)
-	{
-#ifdef CONFIG_ZMK_ACTION_MOD_TAP
-	case ZMK_ACTION_MOD_TAP:
-		if (key_event->pressed)
-		{
-			WRITE_BIT(action_effect_pending, flattened_index, true);
-			zmk_hid_register_mods(mods);
-		}
-		else
-		{
-			zmk_hid_unregister_mods(mods);
-			if (action_effect_pending & BIT(flattened_index))
-			{
-				struct zmk_key_event non_mod_event =
-					{
-						.row = key_event->row,
-						.column = key_event->column,
-						.key = ZK_KEY(key_event->key),
-						.pressed = true};
-
-				zmk_handle_key(non_mod_event);
-				// A small sleep is needed to ensure device layer sends initial
-				// key, before we send the release.
-				k_msleep(10);
-				non_mod_event.pressed = false;
-				zmk_handle_key(non_mod_event);
-			}
-			else
-			{
-				// Since not sending a keycode, at least send the report w/ the mod removed
-				zmk_endpoints_send_report(Keypad);
-			}
-		}
-		break;
-#endif
-	}
-	return false;
-};
-
-void zmk_handle_key(struct zmk_key_event key_event)
-{
-	zmk_action action = ZK_ACTION(key_event.key);
-
-	if (!zmk_handle_key_user(&key_event))
-	{
-		return;
-	}
-
-	if (action && !zmk_handle_action(action, &key_event))
-	{
-		return;
-	}
-
-#ifdef CONFIG_ZMK_ACTION_MOD_TAP
-	action_effect_pending = 0;
-#endif
-
-#ifdef CONFIG_ZMK_BLE
-	/* Used for intercepting key presses when doing passkey verification */
-	if (!zmk_ble_handle_key_user(&key_event))
-	{
-		return;
-	}
-#endif /* CONFIG_ZMK_BLE */
-
-	zmk_endpoints_send_key_event(key_event);
-};
diff --git a/src/hid.c b/src/hid.c
deleted file mode 100644
index b3d47cf..0000000
--- a/src/hid.c
+++ /dev/null
@@ -1,130 +0,0 @@
-#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 = 0x00}};
-
-#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_mods(zmk_mod_flags modifiers)
-{
-    kp_report.body.modifiers |= modifiers;
-    return 0;
-}
-
-int zmk_hid_unregister_mods(zmk_mod_flags modifiers)
-{
-    kp_report.body.modifiers &= ~modifiers;
-    return 0;
-}
-
-#define KEY_OFFSET 0x02
-#define MAX_KEYS 6
-
-/*
-#define TOGGLE_BOOT_KEY(match, val)                      \
-    for (int idx = 0; idx < MAX_KEYS; idx++)             \
-    {                                                    \
-        if (kp_report.boot.keys[idx + KEY_OFFSET] != match) \
-        {                                                \
-            continue;                                    \
-        }                                                \
-        kp_report.boot.keys[idx + KEY_OFFSET] = val;        \
-        break;                                           \
-    }
-*/
-
-#define TOGGLE_KEY(code, val) WRITE_BIT(kp_report.body.keys[code / 8], code % 8, val)
-
-#define TOGGLE_CONSUMER(key, state) \
-    WRITE_BIT(consumer_report.body.keys, (key - 0x100), state);
-
-enum zmk_hid_report_changes zmk_hid_press_key(zmk_key code)
-{
-    if (code >= KC_LCTL && code <= KC_RGUI)
-    {
-        return zmk_hid_register_mod(code - KC_LCTL);
-    }
-
-    if (ZK_IS_CONSUMER(code))
-    {
-        LOG_DBG("Toggling a consumer key!");
-        TOGGLE_CONSUMER(code, true);
-        return Consumer;
-    }
-    else
-    {
-        if (code > ZMK_HID_MAX_KEYCODE)
-        {
-            return -EINVAL;
-        }
-
-        // TOGGLE_BOOT_KEY(0U, code);
-
-        TOGGLE_KEY(code, true);
-
-        return Keypad;
-    }
-};
-
-enum zmk_hid_report_changes zmk_hid_release_key(zmk_key code)
-{
-    if (code >= KC_LCTL && code <= KC_RGUI)
-    {
-        return zmk_hid_unregister_mod(code - KC_LCTL);
-    }
-
-    if (ZK_IS_CONSUMER(code))
-    {
-        TOGGLE_CONSUMER(code, false);
-        return Consumer;
-    }
-    else
-    {
-        if (code > ZMK_HID_MAX_KEYCODE)
-        {
-            return -EINVAL;
-        }
-
-        // TOGGLE_BOOT_KEY(0U, code);
-
-        TOGGLE_KEY(code, false);
-
-        return Keypad;
-    }
-};
-
-struct zmk_hid_keypad_report *zmk_hid_get_keypad_report()
-{
-    return &kp_report;
-}
-
-struct zmk_hid_consumer_report *zmk_hid_get_consumer_report()
-{
-    return &consumer_report;
-}
diff --git a/src/hog.c b/src/hog.c
deleted file mode 100644
index 087af42..0000000
--- a/src/hog.c
+++ /dev/null
@@ -1,158 +0,0 @@
-#include <settings/settings.h>
-
-#include <bluetooth/bluetooth.h>
-#include <bluetooth/gatt.h>
-
-#include <zmk/ble.h>
-#include <zmk/hog.h>
-#include <zmk/hid.h>
-
-int zmk_hog_init()
-{
-    return zmk_ble_init();
-}
-
-enum
-{
-    HIDS_REMOTE_WAKE = BIT(0),
-    HIDS_NORMALLY_CONNECTABLE = BIT(1),
-};
-
-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
-{
-    u8_t id;   /* report id */
-    u8_t type; /* report type */
-} __packed;
-
-static struct hids_info info = {
-    .version = 0x0000,
-    .code = 0x00,
-    .flags = HIDS_NORMALLY_CONNECTABLE & HIDS_REMOTE_WAKE,
-};
-
-enum
-{
-    HIDS_INPUT = 0x01,
-    HIDS_OUTPUT = 0x02,
-    HIDS_FEATURE = 0x03,
-};
-
-static struct hids_report input = {
-    .id = 0x01,
-    .type = HIDS_INPUT,
-};
-
-static struct hids_report consumer_input = {
-    .id = 0x02,
-    .type = HIDS_INPUT,
-};
-
-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_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_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));
-}
-
-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));
-}
-
-// static ssize_t write_proto_mode(struct bt_conn *conn,
-//                                 const struct bt_gatt_attr *attr,
-//                                 const void *buf, u16_t len, u16_t offset,
-//                                 u8_t flags)
-// {
-//     printk("PROTO CHANGED\n");
-//     return 0;
-// }
-
-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)
-{
-    u8_t *value = attr->user_data;
-
-    if (offset + len > sizeof(ctrl_point))
-    {
-        return BT_GATT_ERR(BT_ATT_ERR_INVALID_OFFSET);
-    }
-
-    memcpy(value + offset, buf, len);
-
-    return len;
-}
-
-/* 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));
-};
-
-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));
-};
diff --git a/src/keymap.c b/src/keymap.c
deleted file mode 100644
index 569a2cc..0000000
--- a/src/keymap.c
+++ /dev/null
@@ -1,74 +0,0 @@
-
-#include <logging/log.h>
-LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
-#include <zmk/keymap.h>
-
-static u32_t zmk_keymap_layer_state = 0;
-static u8_t zmk_keymap_layer_default = 0;
-
-static zmk_key zmk_keymap[ZMK_KEYMAP_LAYERS_LEN][ZMK_MATRIX_ROWS * ZMK_MATRIX_COLS] = {
-#if DT_PROP_HAS_IDX(ZMK_KEYMAP_NODE, layers, 0)
-	DT_PROP_BY_PHANDLE_IDX(ZMK_KEYMAP_NODE, layers, 0, keys),
-#endif
-#if DT_PROP_HAS_IDX(ZMK_KEYMAP_NODE, layers, 1)
-	DT_PROP_BY_PHANDLE_IDX(ZMK_KEYMAP_NODE, layers, 1, keys),
-#endif
-#if DT_PROP_HAS_IDX(ZMK_KEYMAP_NODE, layers, 2)
-	DT_PROP_BY_PHANDLE_IDX(ZMK_KEYMAP_NODE, layers, 2, keys),
-#endif
-#if DT_PROP_HAS_IDX(ZMK_KEYMAP_NODE, layers, 3)
-	DT_PROP_BY_PHANDLE_IDX(ZMK_KEYMAP_NODE, layers, 3, keys),
-#endif
-#if DT_PROP_HAS_IDX(ZMK_KEYMAP_NODE, layers, 4)
-	DT_PROP_BY_PHANDLE_IDX(ZMK_KEYMAP_NODE, layers, 4, keys),
-#endif
-#if DT_PROP_HAS_IDX(ZMK_KEYMAP_NODE, layers, 5)
-	DT_PROP_BY_PHANDLE_IDX(ZMK_KEYMAP_NODE, layers, 5, keys),
-#endif
-#if DT_PROP_HAS_IDX(ZMK_KEYMAP_NODE, layers, 6)
-	DT_PROP_BY_PHANDLE_IDX(ZMK_KEYMAP_NODE, layers, 6, keys),
-#endif
-#if DT_PROP_HAS_IDX(ZMK_KEYMAP_NODE, layers, 7)
-	DT_PROP_BY_PHANDLE_IDX(ZMK_KEYMAP_NODE, layers, 7, keys),
-#endif
-};
-
-#define SET_LAYER_STATE(layer, state)                \
-	if (layer >= 32)                                 \
-	{                                                \
-		return false;                                \
-	}                                                \
-	WRITE_BIT(zmk_keymap_layer_state, layer, state); \
-	return true;
-
-bool zmk_keymap_layer_activate(u8_t layer)
-{
-	SET_LAYER_STATE(layer, true);
-};
-
-bool zmk_keymap_layer_deactivate(u8_t layer)
-{
-	SET_LAYER_STATE(layer, false);
-};
-
-zmk_key zmk_keymap_keycode_from_position(u32_t row, u32_t column)
-{
-	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)
-		{
-			u8_t key_index = (row * ZMK_MATRIX_COLS) + column;
-			LOG_DBG("Getting key at index %d", key_index);
-
-			zmk_key key = zmk_keymap[layer][key_index];
-			if (key == ZC_TRNS)
-			{
-				continue;
-			}
-
-			return key;
-		}
-	}
-
-	return ZC_NO;
-}
diff --git a/src/kscan.c b/src/kscan.c
deleted file mode 100644
index 1f54a14..0000000
--- a/src/kscan.c
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- * Copyright (c) 2020 Peter Johanson
- *
- * SPDX-License-Identifier: MIT
- */
-
-#include <zephyr.h>
-#include <device.h>
-#include <drivers/kscan.h>
-#include <logging/log.h>
-
-LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
-
-#include <zmk/keymap.h>
-#include <zmk/handlers.h>
-
-#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_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)};
-
-	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;
-
-	while (k_msgq_get(&zmk_kscan_msgq, &ev, K_NO_WAIT) == 0)
-	{
-		bool pressed = (ev.state == ZMK_KSCAN_EVENT_STATE_PRESSED);
-		zmk_key key = zmk_keymap_keycode_from_position(ev.row, ev.column);
-		struct zmk_key_event kev = (struct zmk_key_event){.row = ev.row, .column = ev.column, .key = key, .pressed = pressed};
-
-		LOG_DBG("Row: %d, col: %d, key: %d, pressed: %s\n", ev.row, ev.column, key, (pressed ? "true" : "false"));
-		zmk_handle_key(kev);
-	}
-}
-
-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);
-
-	kscan_config(dev, zmk_kscan_callback);
-	kscan_enable_callback(dev);
-
-	return 0;
-}
diff --git a/src/kscan_composite.c b/src/kscan_composite.c
deleted file mode 100644
index d46484b..0000000
--- a/src/kscan_composite.c
+++ /dev/null
@@ -1,130 +0,0 @@
-/*
- * Copyright (c) 2020 Peter Johanson <peter@peterjohanson.com>
- *
- * SPDX-License-Identifier: MIT
- */
-
-#define DT_DRV_COMPAT zmk_kscan_composite
-
-#include <device.h>
-#include <drivers/kscan.h>
-#include <logging/log.h>
-LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
-
-#define MATRIX_NODE_ID DT_DRV_INST(0)
-#define MATRIX_ROWS DT_PROP(MATRIX_NODE_ID, rows)
-#define MATRIX_COLS DT_PROP(MATRIX_NODE_ID, columns)
-
-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)},
-
-const struct kscan_composite_child_config kscan_composite_children[] = {
-    DT_FOREACH_CHILD(MATRIX_NODE_ID, CHILD_CONFIG)};
-
-struct kscan_composite_config
-{
-};
-
-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++)
-    {
-        const struct kscan_composite_child_config *cfg = &kscan_composite_children[i];
-
-        kscan_enable_callback(device_get_binding(cfg->label));
-    }
-    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++)
-    {
-        const struct kscan_composite_child_config *cfg = &kscan_composite_children[i];
-
-        kscan_disable_callback(device_get_binding(cfg->label));
-    }
-    return 0;
-}
-
-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++)
-    {
-        const struct kscan_composite_child_config *cfg = &kscan_composite_children[i];
-
-        if (device_get_binding(cfg->label) != child_dev)
-        {
-            continue;
-        }
-
-        data->callback(dev, row + cfg->row_offset, column + cfg->column_offset, pressed);
-    }
-}
-
-static int kscan_composite_configure(struct device *dev, kscan_callback_t callback)
-{
-    struct kscan_composite_data *data = dev->driver_data;
-
-    if (!callback)
-    {
-        return -EINVAL;
-    }
-
-    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);
-    }
-
-    data->callback = callback;
-
-    return 0;
-}
-
-static int kscan_composite_init(struct device *dev)
-{
-    struct kscan_composite_data *data = dev->driver_data;
-
-    data->dev = dev;
-
-    return 0;
-}
-
-static const struct kscan_driver_api mock_driver_api = {
-    .config = kscan_composite_configure,
-    .enable_callback = kscan_composite_enable_callback,
-    .disable_callback = kscan_composite_disable_callback,
-};
-
-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,
-                    &mock_driver_api);
diff --git a/src/kscan_mock.c b/src/kscan_mock.c
deleted file mode 100644
index 7d2d24d..0000000
--- a/src/kscan_mock.c
+++ /dev/null
@@ -1,102 +0,0 @@
-/*
- * Copyright (c) 2020 Peter Johanson <peter@peterjohanson.com>
- *
- * SPDX-License-Identifier: MIT
- */
-
-#define DT_DRV_COMPAT zmk_kscan_mock
-
-#include <device.h>
-#include <drivers/kscan.h>
-#include <logging/log.h>
-LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
-
-#include <zmk/kscan-mock.h>
-
-struct kscan_mock_data
-{
-    kscan_callback_t callback;
-
-    u8_t event_index;
-    struct k_delayed_work work;
-    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)
-{
-    struct kscan_mock_data *data = dev->driver_data;
-
-    if (!callback)
-    {
-        return -EINVAL;
-    }
-
-    data->event_index = 0;
-    data->callback = 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);
-
-DT_INST_FOREACH_STATUS_OKAY(MOCK_INST_INIT)
\ No newline at end of file
diff --git a/src/main.c b/src/main.c
deleted file mode 100644
index 1ced310..0000000
--- a/src/main.c
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * Copyright (c) 2020 Peter Johanson
- *
- * SPDX-License-Identifier: MIT
- */
-
-#include <zephyr.h>
-#include <device.h>
-#include <devicetree.h>
-#include <settings/settings.h>
-
-#include <logging/log.h>
-LOG_MODULE_REGISTER(zmk, CONFIG_ZMK_LOG_LEVEL);
-
-#include <zmk/matrix.h>
-#include <zmk/kscan.h>
-#include <zmk/endpoints.h>
-
-#define ZMK_KSCAN_DEV DT_LABEL(ZMK_MATRIX_NODE_ID)
-
-void main(void)
-{
-	printk("Welcome to ZMK!\n");
-
-	if (zmk_kscan_init(ZMK_KSCAN_DEV) != 0)
-	{
-		return;
-	}
-
-	if (zmk_endpoints_init())
-	{
-		printk("ENDPOINT INIT FAILED\n");
-		return;
-	}
-
-#ifdef CONFIG_SETTINGS
-	settings_load();
-#endif
-}
diff --git a/src/usb_hid.c b/src/usb_hid.c
deleted file mode 100644
index 2862d56..0000000
--- a/src/usb_hid.c
+++ /dev/null
@@ -1,58 +0,0 @@
-
-#include <device.h>
-
-#include <usb/usb_device.h>
-#include <usb/class/usb_hid.h>
-#include <dt-bindings/zmk/keys.h>
-
-#include <zmk/hid.h>
-#include <zmk/keymap.h>
-
-LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
-
-static enum usb_dc_status_code usb_status;
-
-static struct device *hid_dev;
-
-int zmk_usb_hid_send_report(const u8_t *report, size_t len)
-{
-	if (usb_status == USB_DC_SUSPEND)
-	{
-		return usb_wakeup_request();
-	}
-
-	return hid_int_ep_write(hid_dev, report, len, NULL);
-}
-
-void usb_hid_status_cb(enum usb_dc_status_code status, const u8_t *params)
-{
-	usb_status = status;
-};
-
-int zmk_usb_hid_init()
-{
-	int usb_enable_ret;
-
-	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),
-							NULL);
-
-	usb_hid_init(hid_dev);
-
-	usb_enable_ret = usb_enable(usb_hid_status_cb);
-
-	if (usb_enable_ret != 0)
-	{
-		LOG_ERR("Unable to enable USB");
-		return -EINVAL;
-	}
-
-	return 0;
-}