Merge pull request #211 from petejohanson/core/keymap-port-event-exploration

Use PORT events for kscan matrix interrupts, add option for deep sleep.

6 files changed, 133 insertions, 33 deletions

diff --git a/app/CMakeLists.txt b/app/CMakeLists.txt
index 5c77c54..3e59d75 100644
--- a/app/CMakeLists.txt
+++ b/app/CMakeLists.txt
@@ -23,6 +23,7 @@ zephyr_linker_sources(RODATA include/linker/zmk-events.ld)
 # Add your source file to the "app" target. This must come after
 # find_package(Zephyr) which defines the target.
 target_include_directories(app PRIVATE include)
+target_sources_ifdef(CONFIG_ZMK_SLEEP app PRIVATE src/power.c)
 target_sources(app PRIVATE src/kscan.c)
 target_sources(app PRIVATE src/matrix_transform.c)
 target_sources(app PRIVATE src/hid.c)
diff --git a/app/Kconfig b/app/Kconfig
index 9398fce..edf5867 100644
--- a/app/Kconfig
+++ b/app/Kconfig
@@ -76,6 +76,25 @@ endif
 
 endmenu
 
+menuconfig ZMK_SLEEP
+	bool "Enable deep sleep support"
+	imply USB
+
+if ZMK_SLEEP
+
+config SYS_POWER_DEEP_SLEEP_STATES
+	default y
+
+choice SYS_PM_POLICY
+	default SYS_PM_POLICY_APP
+endchoice
+
+config ZMK_IDLE_SLEEP_TIMEOUT
+	int "Milliseconds to wait to sleep when going idle"
+	default 900000
+
+endif
+
 config ZMK_DISPLAY
 	bool "ZMK display support"
 	default n
@@ -112,7 +131,6 @@ config ZMK_SPLIT_BLE_ROLE_CENTRAL
 
 config ZMK_SPLIT_BLE_ROLE_PERIPHERAL
 	bool "Peripheral"
-	select BT_KEYS_OVERWRITE_OLDEST
 
 if ZMK_SPLIT_BLE_ROLE_PERIPHERAL
 
diff --git a/app/boards/arm/nice_nano/nice_nano.dts b/app/boards/arm/nice_nano/nice_nano.dts
index 2e9556b..3ffb0ea 100644
--- a/app/boards/arm/nice_nano/nice_nano.dts
+++ b/app/boards/arm/nice_nano/nice_nano.dts
@@ -31,6 +31,10 @@
 
 };
 
+&gpiote {
+	status = "okay";
+};
+
 &gpio0 {
 	status = "okay";
 };
diff --git a/app/drivers/zephyr/kscan_gpio_matrix.c b/app/drivers/zephyr/kscan_gpio_matrix.c
index 62008e3..a0b22e4 100644
--- a/app/drivers/zephyr/kscan_gpio_matrix.c
+++ b/app/drivers/zephyr/kscan_gpio_matrix.c
@@ -64,6 +64,7 @@ static int kscan_gpio_config_interrupts(struct device **devices,
     struct kscan_gpio_irq_callback_##n {                                                           \
         struct COND_CODE_0(DT_INST_PROP(n, debounce_period), (k_work), (k_delayed_work)) * work;   \
         struct gpio_callback callback;                                                             \
+        struct device *dev;                                                                        \
     };                                                                                             \
     static struct kscan_gpio_irq_callback_##n irq_callbacks_##n[INST_INPUT_LEN(n)];                \
     struct kscan_gpio_config_##n {                                                                 \
@@ -72,7 +73,7 @@ static int kscan_gpio_config_interrupts(struct device **devices,
     };                                                                                             \
     struct kscan_gpio_data_##n {                                                                   \
         kscan_callback_t callback;                                                                 \
-        COND_CODE_0(CONFIG_ZMK_KSCAN_MATRIX_POLLING, (), (struct k_timer poll_timer;))             \
+        COND_CODE_1(CONFIG_ZMK_KSCAN_MATRIX_POLLING, (struct k_timer poll_timer;), ())             \
         struct COND_CODE_0(DT_INST_PROP(n, debounce_period), (k_work), (k_delayed_work)) work;     \
         bool matrix_state[INST_MATRIX_ROWS(n)][INST_MATRIX_COLS(n)];                               \
         struct device *rows[INST_MATRIX_ROWS(n)];                                                  \
@@ -100,23 +101,25 @@ static int kscan_gpio_config_interrupts(struct device **devices,
         return (                                                                                   \
             COND_CODE_0(DT_ENUM_IDX(DT_DRV_INST(n), diode_direction), (cfg->rows), (cfg->cols)));  \
     }                                                                                              \
-    COND_CODE_0(CONFIG_ZMK_KSCAN_MATRIX_POLLING,                                                   \
+    COND_CODE_1(CONFIG_ZMK_KSCAN_MATRIX_POLLING, (),                                               \
                 (                                                                                  \
                     static int kscan_gpio_enable_interrupts_##n(struct device *dev) {              \
                         return kscan_gpio_config_interrupts(                                       \
                             kscan_gpio_input_devices_##n(dev), kscan_gpio_input_configs_##n(dev),  \
-                            INST_INPUT_LEN(n), GPIO_INT_DEBOUNCE | GPIO_INT_EDGE_BOTH);            \
+                            INST_INPUT_LEN(n), GPIO_INT_LEVEL_ACTIVE);                             \
                     } static int kscan_gpio_disable_interrupts_##n(struct device *dev) {           \
                         return kscan_gpio_config_interrupts(kscan_gpio_input_devices_##n(dev),     \
                                                             kscan_gpio_input_configs_##n(dev),     \
                                                             INST_INPUT_LEN(n), GPIO_INT_DISABLE);  \
-                    }),                                                                            \
-                ())                                                                                \
+                    }))                                                                            \
     static void kscan_gpio_set_output_state_##n(struct device *dev, int value) {                   \
+        int err;                                                                                   \
         for (int i = 0; i < INST_OUTPUT_LEN(n); i++) {                                             \
             struct device *in_dev = kscan_gpio_output_devices_##n(dev)[i];                         \
             const struct kscan_gpio_item_config *cfg = &kscan_gpio_output_configs_##n(dev)[i];     \
-            gpio_pin_set(in_dev, cfg->pin, value);                                                 \
+            if ((err = gpio_pin_set(in_dev, cfg->pin, value))) {                                   \
+                LOG_DBG("FAILED TO SET OUTPUT %d to %d", cfg->pin, err);                           \
+            }                                                                                      \
         }                                                                                          \
     }                                                                                              \
     static void kscan_gpio_set_matrix_state_##n(                                                   \
@@ -134,8 +137,6 @@ static int kscan_gpio_config_interrupts(struct device **devices,
         /* Disable our interrupts temporarily while we scan, to avoid       */                     \
         /* re-entry while we iterate columns and set them active one by one */                     \
         /* to get pressed state for each matrix cell.                       */                     \
-        COND_CODE_0(CONFIG_ZMK_KSCAN_MATRIX_POLLING, (kscan_gpio_disable_interrupts_##n(dev);),    \
-                    ())                                                                            \
         kscan_gpio_set_output_state_##n(dev, 0);                                                   \
         for (int o = 0; o < INST_OUTPUT_LEN(n); o++) {                                             \
             struct device *out_dev = kscan_gpio_output_devices_##n(dev)[o];                        \
@@ -152,8 +153,6 @@ static int kscan_gpio_config_interrupts(struct device **devices,
         }                                                                                          \
         /* Set all our outputs as active again. */                                                 \
         kscan_gpio_set_output_state_##n(dev, 1);                                                   \
-        /*Re-enable interrupts so that they can be triggered again for future press/release*/      \
-        COND_CODE_0(CONFIG_ZMK_KSCAN_MATRIX_POLLING, (kscan_gpio_enable_interrupts_##n(dev);), ()) \
         for (int r = 0; r < INST_MATRIX_ROWS(n); r++) {                                            \
             for (int c = 0; c < INST_MATRIX_COLS(n); c++) {                                        \
                 bool pressed = read_state[r][c];                                                   \
@@ -172,6 +171,9 @@ static int kscan_gpio_config_interrupts(struct device **devices,
                             k_delayed_work_cancel(&data->work);                                    \
                             k_delayed_work_submit(&data->work, K_MSEC(5));                         \
                         }))                                                                        \
+        } else {                                                                                   \
+            COND_CODE_1(CONFIG_ZMK_KSCAN_MATRIX_POLLING, (),                                       \
+                        (kscan_gpio_enable_interrupts_##n(dev);))                                  \
         }                                                                                          \
         return 0;                                                                                  \
     }                                                                                              \
@@ -179,16 +181,20 @@ static int kscan_gpio_config_interrupts(struct device **devices,
         struct kscan_gpio_data_##n *data = CONTAINER_OF(work, struct kscan_gpio_data_##n, work);   \
         kscan_gpio_read_##n(data->dev);                                                            \
     }                                                                                              \
-    static void kscan_gpio_irq_callback_handler_##n(struct device *dev, struct gpio_callback *cb,  \
-                                                    gpio_port_pins_t pin) {                        \
-        struct kscan_gpio_irq_callback_##n *data =                                                 \
-            CONTAINER_OF(cb, struct kscan_gpio_irq_callback_##n, callback);                        \
-        COND_CODE_0(DT_INST_PROP(n, debounce_period), ({ k_work_submit(data->work); }), ({         \
-                        k_delayed_work_cancel(data->work);                                         \
-                        k_delayed_work_submit(data->work,                                          \
-                                              K_MSEC(DT_INST_PROP(n, debounce_period)));           \
-                    }))                                                                            \
-    }                                                                                              \
+    COND_CODE_1(CONFIG_ZMK_KSCAN_MATRIX_POLLING, (),                                               \
+                (static void kscan_gpio_irq_callback_handler_##n(                                  \
+                    struct device *dev, struct gpio_callback *cb, gpio_port_pins_t pin) {          \
+                    struct kscan_gpio_irq_callback_##n *data =                                     \
+                        CONTAINER_OF(cb, struct kscan_gpio_irq_callback_##n, callback);            \
+                    kscan_gpio_disable_interrupts_##n(data->dev);                                  \
+                    COND_CODE_0(DT_INST_PROP(n, debounce_period),                                  \
+                                ({ k_work_submit(data->work); }), ({                               \
+                                    k_delayed_work_cancel(data->work);                             \
+                                    k_delayed_work_submit(                                         \
+                                        data->work, K_MSEC(DT_INST_PROP(n, debounce_period)));     \
+                                }))                                                                \
+                }))                                                                                \
+                                                                                                   \
     static struct kscan_gpio_data_##n kscan_gpio_data_##n = {                                      \
         .rows = {[INST_MATRIX_ROWS(n) - 1] = NULL}, .cols = {[INST_MATRIX_COLS(n) - 1] = NULL}};   \
     static int kscan_gpio_configure_##n(struct device *dev, kscan_callback_t callback) {           \
@@ -201,24 +207,25 @@ static int kscan_gpio_config_interrupts(struct device **devices,
         return 0;                                                                                  \
     };                                                                                             \
     static int kscan_gpio_enable_##n(struct device *dev) {                                         \
-        COND_CODE_0(CONFIG_ZMK_KSCAN_MATRIX_POLLING,                                               \
-                    (int err = kscan_gpio_enable_interrupts_##n(dev);                              \
-                     if (err) { return err; } return kscan_gpio_read_##n(dev);),                   \
+        COND_CODE_1(CONFIG_ZMK_KSCAN_MATRIX_POLLING,                                               \
                     (struct kscan_gpio_data_##n *data = dev->driver_data;                          \
-                     k_timer_start(&data->poll_timer, K_MSEC(10), K_MSEC(10)); return 0;))         \
+                     k_timer_start(&data->poll_timer, K_MSEC(10), K_MSEC(10)); return 0;),         \
+                    (int err = kscan_gpio_enable_interrupts_##n(dev);                              \
+                     if (err) { return err; } return kscan_gpio_read_##n(dev);))                   \
     };                                                                                             \
     static int kscan_gpio_disable_##n(struct device *dev) {                                        \
-        COND_CODE_0(CONFIG_ZMK_KSCAN_MATRIX_POLLING,                                               \
-                    (return kscan_gpio_disable_interrupts_##n(dev);),                              \
+        COND_CODE_1(CONFIG_ZMK_KSCAN_MATRIX_POLLING,                                               \
                     (struct kscan_gpio_data_##n *data = dev->driver_data;                          \
-                     k_timer_stop(&data->poll_timer); return 0;))                                  \
+                     k_timer_stop(&data->poll_timer); return 0;),                                  \
+                    (return kscan_gpio_disable_interrupts_##n(dev);))                              \
     };                                                                                             \
-    COND_CODE_0(CONFIG_ZMK_KSCAN_MATRIX_POLLING, (),                                               \
+    COND_CODE_1(CONFIG_ZMK_KSCAN_MATRIX_POLLING,                                                   \
                 (static void kscan_gpio_timer_handler(struct k_timer *timer) {                     \
                     struct kscan_gpio_data_##n *data =                                             \
                         CONTAINER_OF(timer, struct kscan_gpio_data_##n, poll_timer);               \
                     k_work_submit(&data->work.work);                                               \
-                }))                                                                                \
+                }),                                                                                \
+                ())                                                                                \
     static int kscan_gpio_init_##n(struct device *dev) {                                           \
         struct kscan_gpio_data_##n *data = dev->driver_data;                                       \
         int err;                                                                                   \
@@ -238,6 +245,7 @@ static int kscan_gpio_config_interrupts(struct device **devices,
                 LOG_DBG("Configured pin %d on %s for input", in_cfg->pin, in_cfg->label);          \
             }                                                                                      \
             irq_callbacks_##n[i].work = &data->work;                                               \
+            irq_callbacks_##n[i].dev = dev;                                                        \
             gpio_init_callback(&irq_callbacks_##n[i].callback,                                     \
                                kscan_gpio_irq_callback_handler_##n, BIT(in_cfg->pin));             \
             err = gpio_add_callback(input_devices[i], &irq_callbacks_##n[i].callback);             \
@@ -263,8 +271,8 @@ static int kscan_gpio_config_interrupts(struct device **devices,
             }                                                                                      \
         }                                                                                          \
         data->dev = dev;                                                                           \
-        COND_CODE_0(CONFIG_ZMK_KSCAN_MATRIX_POLLING, (),                                           \
-                    (k_timer_init(&data->poll_timer, kscan_gpio_timer_handler, NULL);))            \
+        COND_CODE_1(CONFIG_ZMK_KSCAN_MATRIX_POLLING,                                               \
+                    (k_timer_init(&data->poll_timer, kscan_gpio_timer_handler, NULL);), ())        \
         (COND_CODE_0(DT_INST_PROP(n, debounce_period), (k_work_init), (k_delayed_work_init)))(     \
             &data->work, kscan_gpio_work_handler_##n);                                             \
         return 0;                                                                                  \
diff --git a/app/include/dt-bindings/zmk/bt.h b/app/include/dt-bindings/zmk/bt.h
index 05fd65c..a403d35 100644
--- a/app/include/dt-bindings/zmk/bt.h
+++ b/app/include/dt-bindings/zmk/bt.h
@@ -18,4 +18,4 @@ defines these aliases up front.
 #define BT_CLR BT_CLR_CMD 0
 #define BT_NXT BT_NXT_CMD 0
 #define BT_PRV BT_PRV_CMD 0
-#define BT_SEL BT_SEL_CMD
\ No newline at end of file
+#define BT_SEL BT_SEL_CMD
diff --git a/app/src/power.c b/app/src/power.c
new file mode 100644
index 0000000..73b3f12
--- /dev/null
+++ b/app/src/power.c
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2020 The ZMK Contributors
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#include <zephyr.h>
+#include <kernel.h>
+#include <power/power.h>
+
+#include <logging/log.h>
+
+LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
+
+#include <zmk/usb.h>
+#include <zmk/event-manager.h>
+#include <zmk/events/position-state-changed.h>
+#include <zmk/events/sensor-event.h>
+
+static u32_t power_last_uptime;
+
+#define MAX_IDLE_MS CONFIG_ZMK_IDLE_SLEEP_TIMEOUT
+
+bool is_usb_power_present() {
+#ifdef CONFIG_USB
+    enum usb_dc_status_code usb_status = zmk_usb_get_status();
+    switch (usb_status) {
+    case USB_DC_DISCONNECTED:
+    case USB_DC_UNKNOWN:
+        return false;
+    default:
+        return true;
+    }
+#else
+    return false;
+#endif /* CONFIG_USB */
+}
+
+enum power_states sys_pm_policy_next_state(s32_t ticks) {
+#ifdef CONFIG_SYS_POWER_DEEP_SLEEP_STATES
+#ifdef CONFIG_HAS_SYS_POWER_STATE_DEEP_SLEEP_1
+    s32_t current = k_uptime_get();
+    if (power_last_uptime > 0 && !is_usb_power_present() &&
+        current - power_last_uptime > MAX_IDLE_MS) {
+        return SYS_POWER_STATE_DEEP_SLEEP_1;
+    }
+#endif /* CONFIG_HAS_SYS_POWER_STATE_DEEP_SLEEP_1 */
+#endif /* CONFIG_SYS_POWER_DEEP_SLEEP_STATES */
+
+    return SYS_POWER_STATE_ACTIVE;
+}
+
+int power_event_listener(const struct zmk_event_header *eh) {
+    power_last_uptime = k_uptime_get();
+
+    return 0;
+}
+
+int power_init() {
+    power_last_uptime = k_uptime_get();
+
+    return 0;
+}
+
+ZMK_LISTENER(power, power_event_listener);
+ZMK_SUBSCRIPTION(power, position_state_changed);
+ZMK_SUBSCRIPTION(power, sensor_event);
+
+SYS_INIT(power_init, APPLICATION, CONFIG_APPLICATION_INIT_PRIORITY);
\ No newline at end of file