Add a mock kscan driver, working native_posix.

* Unified logging to one module.
* Mock kscan driver that simulates events.
* Working native_posix board target for testing.

src/endpoints.c

@@ -4,14 +4,19 @@
 #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("");
+
     err = zmk_usb_hid_init();
     if (err)
     {
-        printk("USB HID Init Failed\n");
+        LOG_ERR("USB HID Init Failed\n");
         return err;
     }
 
@@ -19,7 +24,7 @@ int zmk_endpoints_init()
     err = zmk_hog_init();
     if (err)
     {
-        printk("HOG Init Failed\n");
+        LOG_ERR("HOG Init Failed\n");
         return err;
     }
 
@@ -33,6 +38,8 @@ int zmk_endpoints_send_key_event(struct zmk_key_event key_event)
     struct zmk_hid_report *report;
     int err;
 
+    LOG_DBG("key %lld, state %d\n", key_event.key, key_event.pressed);
+
 
     if (key_event.pressed)
     {
@@ -54,8 +61,7 @@ int zmk_endpoints_send_key_event(struct zmk_key_event key_event)
     err = zmk_hog_send_report(report);
     if (err)
     {
-        printk("FAILED TO SEND OVER HOG: %d\n", err);
-        // LOG_DBG("HID Over GATTP Send Failed");
+        LOG_ERR("FAILED TO SEND OVER HOG: %d", err);
     }
 #endif /* CONFIG_ZMK_BLE */
 

src/kscan.c

@@ -9,7 +9,7 @@
 #include <drivers/kscan.h>
 #include <logging/log.h>
 
-LOG_MODULE_REGISTER(zmk_kscan, CONFIG_ZMK_KSCAN_LOG_LEVEL);
+LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
 
 #include <zmk/keymap.h>
 #include <zmk/handlers.h>

src/kscan_mock.c

@@ -0,0 +1,121 @@
+/*
+ * 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>
+
+#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)
+#define MATRIX_MOCK_EVENT_COUNT DT_PROP_LEN(MATRIX_NODE_ID, events)
+
+struct kscan_mock_config
+{
+    u32_t events[MATRIX_MOCK_EVENT_COUNT];
+};
+
+struct kscan_mock_data
+{
+    kscan_callback_t callback;
+
+    u8_t event_index;
+    struct k_delayed_work work;
+    struct device *dev;
+};
+
+static void kscan_mock_schedule_next_event(struct device *dev)
+{
+    struct kscan_mock_data *data = dev->driver_data;
+    const struct kscan_mock_config *cfg = dev->config_info;
+
+    if (data->event_index < MATRIX_MOCK_EVENT_COUNT)
+    {
+        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 int kscan_mock_enable_callback(struct device *dev)
+{
+    struct kscan_mock_data *data = dev->driver_data;
+    kscan_mock_schedule_next_event(dev);
+    return 0;
+}
+
+static int kscan_mock_disable_callback(struct device *dev)
+{
+    struct kscan_mock_data *data = dev->driver_data;
+    const struct kscan_mock_config *cfg = dev->config_info;
+
+    k_delayed_work_cancel(&data->work);
+    return 0;
+}
+
+static void kscan_mock_work_handler(struct k_work *work)
+{
+    struct kscan_mock_data *data =
+        CONTAINER_OF(work, struct kscan_mock_data, work);
+    struct kscan_mock_config *cfg = data->dev->config_info;
+
+    u32_t ev = cfg->events[data->event_index++];
+    LOG_DBG("Triggering ev %d\n", ev);
+    data->callback(data->dev, ZMK_MOCK_ROW(ev), ZMK_MOCK_COL(ev), ZMK_MOCK_IS_PRESS(ev));
+    kscan_mock_schedule_next_event(data->dev);
+}
+
+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;
+}
+
+static int kscan_mock_init(struct device *dev)
+{
+    struct kscan_mock_data *data = dev->driver_data;
+    const struct kscan_mock_config *cfg = dev->config_info;
+
+    printk("Init first event: %d\n", cfg->events[0]);
+
+    int err;
+
+    data->dev = dev;
+    k_delayed_work_init(&data->work, kscan_mock_work_handler);
+
+    return 0;
+}
+
+static const struct kscan_driver_api mock_driver_api = {
+    .config = kscan_mock_configure,
+    .enable_callback = kscan_mock_enable_callback,
+    .disable_callback = kscan_mock_disable_callback,
+};
+
+static const struct kscan_mock_config kscan_mock_config = {
+    .events = DT_PROP(MATRIX_NODE_ID, events)};
+
+static struct kscan_mock_data kscan_mock_data;
+
+DEVICE_AND_API_INIT(kscan_mock, DT_INST_LABEL(0), kscan_mock_init,
+                    &kscan_mock_data,
+                    &kscan_mock_config,
+                    APPLICATION, CONFIG_KERNEL_INIT_PRIORITY_DEFAULT,
+                    &mock_driver_api);

src/main.c

@@ -9,6 +9,9 @@
 #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>

src/usb_hid.c

@@ -8,7 +8,7 @@
 #include <zmk/hid.h>
 #include <zmk/keymap.h>
 
-LOG_MODULE_REGISTER(zmk_usb_hid, CONFIG_ZMK_USB_HID_LOG_LEVEL);
+LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
 
 static enum usb_dc_status_code usb_status;