diff options
Diffstat (limited to 'app/src')
| -rw-r--r-- | app/src/behaviors/behavior_hid.c | 108 | ||||
| -rw-r--r-- | app/src/behaviors/behavior_key_press.c | 57 | ||||
| -rw-r--r-- | app/src/behaviors/behavior_keymap.c | 50 | ||||
| -rw-r--r-- | app/src/behaviors/behavior_mod_tap.c | 88 | ||||
| -rw-r--r-- | app/src/behaviors/behavior_momentary_layer.c | 55 | ||||
| -rw-r--r-- | app/src/behaviors/behavior_reset.c | 45 | ||||
| -rw-r--r-- | app/src/behaviors/behavior_transparent.c | 48 | ||||
| -rw-r--r-- | app/src/ble.c | 4 | ||||
| -rw-r--r-- | app/src/endpoints.c | 31 | ||||
| -rw-r--r-- | app/src/events.c | 83 | ||||
| -rw-r--r-- | app/src/handlers.c | 88 | ||||
| -rw-r--r-- | app/src/hid.c | 78 | ||||
| -rw-r--r-- | app/src/keymap.c | 97 | ||||
| -rw-r--r-- | app/src/kscan.c | 16 | ||||
| -rw-r--r-- | app/src/kscan_mock.c | 1 | ||||
| -rw-r--r-- | app/src/matrix_transform.c | 30 |
16 files changed, 672 insertions, 207 deletions
diff --git a/app/src/behaviors/behavior_hid.c b/app/src/behaviors/behavior_hid.c new file mode 100644 index 0000000..1ac7404 --- /dev/null +++ b/app/src/behaviors/behavior_hid.c @@ -0,0 +1,108 @@ +/* + * Copyright (c) 2020 Peter Johanson <peter@peterjohanson.com> + * + * SPDX-License-Identifier: MIT + */ + +#define DT_DRV_COMPAT zmk_behavior_hid + +#include <device.h> +#include <power/reboot.h> +#include <drivers/behavior.h> +#include <logging/log.h> + +LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL); + +#include <zmk/hid.h> +#include <zmk/endpoints.h> + +struct behavior_hid_config { }; +struct behavior_hid_data { }; + +static int behavior_hid_init(struct device *dev) +{ + return 0; +}; + +static int on_keycode_pressed(struct device *dev, u8_t usage_page, u32_t keycode) +{ + int err; + LOG_DBG("keycode %d", keycode); + + 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; + } + + return zmk_endpoints_send_report(usage_page); +} + +static int on_keycode_released(struct device *dev, u8_t usage_page, u32_t keycode) +{ + int err; + LOG_DBG("keycode %d", keycode); + + switch (usage_page) { + case USAGE_KEYPAD: + err = zmk_hid_keypad_release(keycode); + if (err) { + LOG_ERR("Unable to press keycode"); + return err; + } + break; + case USAGE_CONSUMER: + err = zmk_hid_consumer_release(keycode); + if (err) { + LOG_ERR("Unable to press keycode"); + return err; + } + break; + } + return zmk_endpoints_send_report(usage_page); +} + +static int on_modifiers_pressed(struct device *dev, zmk_mod_flags modifiers) +{ + LOG_DBG("modifiers %d", modifiers); + + zmk_hid_register_mods(modifiers); + return zmk_endpoints_send_report(USAGE_KEYPAD); +} + +static int on_modifiers_released(struct device *dev, zmk_mod_flags modifiers) +{ + LOG_DBG("modifiers %d", modifiers); + + zmk_hid_unregister_mods(modifiers); + return zmk_endpoints_send_report(USAGE_KEYPAD); +} + +static const struct behavior_driver_api behavior_hid_driver_api = { + .keycode_pressed = on_keycode_pressed, + .keycode_released = on_keycode_released, + .modifiers_pressed = on_modifiers_pressed, + .modifiers_released = on_modifiers_released +}; + + +static const struct behavior_hid_config behavior_hid_config = {}; + +static struct behavior_hid_data behavior_hid_data; + +DEVICE_AND_API_INIT(behavior_hid, DT_INST_LABEL(0), behavior_hid_init, + &behavior_hid_data, + &behavior_hid_config, + APPLICATION, CONFIG_KERNEL_INIT_PRIORITY_DEFAULT, + &behavior_hid_driver_api);
\ No newline at end of file diff --git a/app/src/behaviors/behavior_key_press.c b/app/src/behaviors/behavior_key_press.c new file mode 100644 index 0000000..7213b3c --- /dev/null +++ b/app/src/behaviors/behavior_key_press.c @@ -0,0 +1,57 @@ +/* + * Copyright (c) 2020 Peter Johanson <peter@peterjohanson.com> + * + * SPDX-License-Identifier: MIT + */ + +#define DT_DRV_COMPAT zmk_behavior_key_press + +#include <device.h> +#include <drivers/behavior.h> +#include <logging/log.h> + +#include <zmk/events.h> + +LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL); + +struct behavior_key_press_config { + u8_t usage_page; +}; +struct behavior_key_press_data { }; + +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); + return zmk_events_keycode_pressed(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_events_keycode_released(cfg->usage_page, keycode); +} + +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); + +DT_INST_FOREACH_STATUS_OKAY(KP_INST)
\ No newline at end of file diff --git a/app/src/behaviors/behavior_keymap.c b/app/src/behaviors/behavior_keymap.c new file mode 100644 index 0000000..7a06b2f --- /dev/null +++ b/app/src/behaviors/behavior_keymap.c @@ -0,0 +1,50 @@ +/* + * Copyright (c) 2020 Peter Johanson <peter@peterjohanson.com> + * + * SPDX-License-Identifier: MIT + */ + +#define DT_DRV_COMPAT zmk_behavior_keymap + +#include <device.h> +#include <power/reboot.h> +#include <drivers/behavior.h> +#include <logging/log.h> + +LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL); + +#include <zmk/keymap.h> + +struct behavior_keymap_config { }; +struct behavior_keymap_data { }; + +static int behavior_keymap_init(struct device *dev) +{ + return 0; +}; + +static int on_position_pressed(struct device *dev, u32_t position) +{ + return zmk_keymap_position_state_changed(position, true); +} + +static int on_position_released(struct device *dev, u32_t position) +{ + return zmk_keymap_position_state_changed(position, false); +} + +static const struct behavior_driver_api behavior_keymap_driver_api = { + .position_pressed = on_position_pressed, + .position_released = on_position_released, +}; + + +static const struct behavior_keymap_config behavior_keymap_config = {}; + +static struct behavior_keymap_data behavior_keymap_data; + +DEVICE_AND_API_INIT(behavior_keymap, DT_INST_LABEL(0), behavior_keymap_init, + &behavior_keymap_data, + &behavior_keymap_config, + APPLICATION, CONFIG_KERNEL_INIT_PRIORITY_DEFAULT, + &behavior_keymap_driver_api); diff --git a/app/src/behaviors/behavior_mod_tap.c b/app/src/behaviors/behavior_mod_tap.c new file mode 100644 index 0000000..2e6e339 --- /dev/null +++ b/app/src/behaviors/behavior_mod_tap.c @@ -0,0 +1,88 @@ +/* + * 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/events.h> + +LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL); + +struct behavior_mod_tap_config { }; +struct behavior_mod_tap_data { + u16_t pending_press_positions; +}; + +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: %d", mods, keycode); + WRITE_BIT(data->pending_press_positions, position, true); + return zmk_events_modifiers_pressed(mods); +} + + +// They keycode is passed by the "keymap" based on the parameter created as part of the assignment. +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); + +zmk_events_modifiers_released(mods); + if (data->pending_press_positions & BIT(position)) { + zmk_events_keycode_pressed(USAGE_KEYPAD, keycode); + k_msleep(10); + zmk_events_keycode_released(USAGE_KEYPAD, keycode); + } + + return 0; +} + +static int on_keycode_pressed(struct device *dev, u8_t usage_page, u32_t keycode) +{ + struct behavior_mod_tap_data *data = dev->driver_data; + data->pending_press_positions = 0; + LOG_DBG("pressing: %d", keycode); + return 0; +} + +static int on_keycode_released(struct device *dev, u8_t usage_page, u32_t keycode) +{ + LOG_DBG("releasing: %d", keycode); + return 0; +} + +static const struct behavior_driver_api behavior_mod_tap_driver_api = { + // These callbacks are all optional, and define which kinds of events the behavior can handle. + // They can reference local functions defined here, or shared event handlers. + .binding_pressed = on_keymap_binding_pressed, + .binding_released = on_keymap_binding_released, + .keycode_pressed = on_keycode_pressed, + .keycode_released = on_keycode_released + // Other optional callbacks a behavior can implement + // .on_mouse_moved + // .on_sensor_data - Any behaviour that wants to be linked to a censor can implement this behavior +}; + + +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_key_press, 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 new file mode 100644 index 0000000..904051e --- /dev/null +++ b/app/src/behaviors/behavior_momentary_layer.c @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2020 Peter Johanson <peter@peterjohanson.com> + * + * SPDX-License-Identifier: MIT + */ + +#define DT_DRV_COMPAT zmk_behavior_momentary_layer + +#include <device.h> +#include <drivers/behavior.h> +#include <logging/log.h> + +#include <zmk/events.h> +#include <zmk/keymap.h> + +LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL); + +struct behavior_mo_config { }; +struct behavior_mo_data { }; + +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); + + 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); + + 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 +}; + + +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, + &behavior_mo_driver_api); diff --git a/app/src/behaviors/behavior_reset.c b/app/src/behaviors/behavior_reset.c new file mode 100644 index 0000000..44cbc21 --- /dev/null +++ b/app/src/behaviors/behavior_reset.c @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2020 Peter Johanson <peter@peterjohanson.com> + * + * SPDX-License-Identifier: MIT + */ + +#define DT_DRV_COMPAT zmk_behavior_reset + +#include <device.h> +#include <power/reboot.h> +#include <drivers/behavior.h> +#include <logging/log.h> + +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; +}; + +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 const struct behavior_driver_api behavior_reset_driver_api = { + .binding_pressed = on_keymap_binding_pressed, +}; + + +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 diff --git a/app/src/behaviors/behavior_transparent.c b/app/src/behaviors/behavior_transparent.c new file mode 100644 index 0000000..5109264 --- /dev/null +++ b/app/src/behaviors/behavior_transparent.c @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2020 Peter Johanson <peter@peterjohanson.com> + * + * SPDX-License-Identifier: MIT + */ + +#define DT_DRV_COMPAT zmk_behavior_transparent + +#include <device.h> +#include <power/reboot.h> +#include <drivers/behavior.h> +#include <logging/log.h> + +LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL); + +struct behavior_transparent_config { }; +struct behavior_transparent_data { }; + +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_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, +}; + + +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 diff --git a/app/src/ble.c b/app/src/ble.c index 51607c6..0e6c5f2 100644 --- a/app/src/ble.c +++ b/app/src/ble.c @@ -168,12 +168,12 @@ bool zmk_ble_handle_key_user(struct zmk_key_event *key_event) return true; } - if (key < KC_1 || key > KC_0) + if (key < NUM_1 || key > NUM_0) { return true; } - u32_t val = (key == KC_0) ? 0 : (key - KC_1 + 1); + u32_t val = (key == NUM_0) ? 0 : (key - NUM_1 + 1); passkey_entries[passkey_digit++] = val; diff --git a/app/src/endpoints.c b/app/src/endpoints.c index f46d42d..7823e95 100644 --- a/app/src/endpoints.c +++ b/app/src/endpoints.c @@ -3,6 +3,7 @@ #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); @@ -35,14 +36,15 @@ int zmk_endpoints_init() return 0; } -int zmk_endpoints_send_report(enum zmk_hid_report_changes report_type) +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; - switch (report_type) + LOG_DBG("usage page 0x%02X", usage_page); + switch (usage_page) { - case Keypad: + 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) @@ -60,7 +62,7 @@ int zmk_endpoints_send_report(enum zmk_hid_report_changes report_type) #endif /* CONFIG_ZMK_BLE */ break; - case Consumer: + 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) @@ -79,27 +81,10 @@ int zmk_endpoints_send_report(enum zmk_hid_report_changes report_type) break; default: - LOG_ERR("Unknown report change type %d", report_type); - return -EINVAL; + LOG_ERR("Unsupported usage page %d", usage_page); + return -ENOTSUP; } 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/app/src/events.c b/app/src/events.c new file mode 100644 index 0000000..fabb93e --- /dev/null +++ b/app/src/events.c @@ -0,0 +1,83 @@ + +#include <zephyr.h> +#include <drivers/behavior.h> +#include <zmk/behavior.h> +#include <zmk/events.h> +#include <sys/util.h> + +#define DT_DRV_COMPAT zmk_behavior_global +#define GLOBAL_BEHAVIOR_LEN DT_NUM_INST_STATUS_OKAY(DT_DRV_COMPAT) + +#define LABEL_ENTRY(i) DT_INST_LABEL(i), +static const char *global_behaviors[] = { + DT_INST_FOREACH_STATUS_OKAY(LABEL_ENTRY) +}; + +int zmk_events_position_pressed(u32_t position) +{ + for (int i = 0; i < GLOBAL_BEHAVIOR_LEN; i++) { + const char* label = global_behaviors[i]; + struct device *dev = device_get_binding(label); + behavior_position_pressed(dev, position); + } + return 0; +}; + +int zmk_events_position_released(u32_t position) +{ + for (int i = 0; i < GLOBAL_BEHAVIOR_LEN; i++) { + const char* label = global_behaviors[i]; + struct device *dev = device_get_binding(label); + behavior_position_released(dev, position); + } + return 0; +}; + +int zmk_events_keycode_pressed(u8_t usage_page, u32_t keycode) +{ + for (int i = 0; i < GLOBAL_BEHAVIOR_LEN; i++) { + const char* label = global_behaviors[i]; + struct device *dev = device_get_binding(label); + behavior_keycode_pressed(dev, usage_page, keycode); + } + return 0; +}; + +int zmk_events_keycode_released(u8_t usage_page, u32_t keycode) +{ + for (int i = 0; i < GLOBAL_BEHAVIOR_LEN; i++) { + const char* label = global_behaviors[i]; + struct device *dev = device_get_binding(label); + behavior_keycode_released(dev, usage_page, keycode); + } + return 0; +}; + +int zmk_events_modifiers_pressed(zmk_mod_flags modifiers) +{ + for (int i = 0; i < GLOBAL_BEHAVIOR_LEN; i++) { + const char* label = global_behaviors[i]; + struct device *dev = device_get_binding(label); + behavior_modifiers_pressed(dev, modifiers); + } + return 0; +}; + +int zmk_events_modifiers_released(zmk_mod_flags modifiers) +{ + for (int i = 0; i < GLOBAL_BEHAVIOR_LEN; i++) { + const char* label = global_behaviors[i]; + struct device *dev = device_get_binding(label); + behavior_modifiers_released(dev, modifiers); + } + return 0; +}; + +int zmk_events_consumer_key_pressed(u32_t usage) +{ + return 0; +}; +int zmk_events_consumer_key_released(u32_t usage) +{ + return 0; +}; diff --git a/app/src/handlers.c b/app/src/handlers.c deleted file mode 100644 index 464b1ab..0000000 --- a/app/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/app/src/hid.c b/app/src/hid.c index b3d47cf..ca04056 100644 --- a/app/src/hid.c +++ b/app/src/hid.c @@ -12,7 +12,7 @@ static struct zmk_hid_keypad_report kp_report = { static struct zmk_hid_consumer_report consumer_report = { .report_id = 2, .body = { - .keys = 0x00}}; + .keys = {0,0,0,0,0,0}}}; #define _TOGGLE_MOD(mod, state) \ if (modifier > MOD_RGUI) \ @@ -61,62 +61,68 @@ 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(key, state) \ - WRITE_BIT(consumer_report.body.keys, (key - 0x100), state); +#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; \ + } + -enum zmk_hid_report_changes zmk_hid_press_key(zmk_key code) +int zmk_hid_keypad_press(zmk_key code) { - if (code >= KC_LCTL && code <= KC_RGUI) + if (code >= LCTL && code <= RGUI) { - return zmk_hid_register_mod(code - KC_LCTL); + return zmk_hid_register_mod(code - LCTL); } - if (ZK_IS_CONSUMER(code)) + + if (code > ZMK_HID_MAX_KEYCODE) { - LOG_DBG("Toggling a consumer key!"); - TOGGLE_CONSUMER(code, true); - return Consumer; + return -EINVAL; } - else - { - if (code > ZMK_HID_MAX_KEYCODE) - { - return -EINVAL; - } - // TOGGLE_BOOT_KEY(0U, code); + // TOGGLE_BOOT_KEY(0U, code); - TOGGLE_KEY(code, true); + TOGGLE_KEY(code, true); - return Keypad; - } + return 0; }; -enum zmk_hid_report_changes zmk_hid_release_key(zmk_key code) +int zmk_hid_keypad_release(zmk_key code) { - if (code >= KC_LCTL && code <= KC_RGUI) + if (code >= LCTL && code <= RGUI) { - return zmk_hid_unregister_mod(code - KC_LCTL); + return zmk_hid_unregister_mod(code - LCTL); } - if (ZK_IS_CONSUMER(code)) + if (code > ZMK_HID_MAX_KEYCODE) { - TOGGLE_CONSUMER(code, false); - return Consumer; + return -EINVAL; } - else - { - if (code > ZMK_HID_MAX_KEYCODE) - { - return -EINVAL; - } - // TOGGLE_BOOT_KEY(0U, code); + // TOGGLE_BOOT_KEY(0U, code); - TOGGLE_KEY(code, false); + TOGGLE_KEY(code, false); - return Keypad; - } + return 0; +}; + +int zmk_hid_consumer_press(zmk_key code) +{ + TOGGLE_CONSUMER(0U, code); + return 0; +}; + + +int zmk_hid_consumer_release(zmk_key code) +{ + TOGGLE_CONSUMER(code, 0U); + return 0; }; struct zmk_hid_keypad_report *zmk_hid_get_keypad_report() diff --git a/app/src/keymap.c b/app/src/keymap.c index 1cb705e..dd0fee4 100644 --- a/app/src/keymap.c +++ b/app/src/keymap.c @@ -1,24 +1,32 @@ +#include <sys/util.h> #include <logging/log.h> LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL); + +#include <zmk/matrix.h> #include <zmk/keymap.h> #include <dt-bindings/zmk/matrix-transform.h> -#include <sys/util.h> +#include <drivers/behavior.h> +#include <zmk/behavior.h> static u32_t zmk_keymap_layer_state = 0; static u8_t zmk_keymap_layer_default = 0; -#if DT_NODE_HAS_PROP(ZMK_KEYMAP_NODE, transform) -#define ZMK_KEYMAP_TRANSFORM_NODE DT_PHANDLE(ZMK_KEYMAP_NODE, transform) -#define ZMK_KEYMAP_LEN DT_PROP_LEN(ZMK_KEYMAP_TRANSFORM_NODE, map) +#define ZMK_KEYMAP_NODE DT_CHOSEN(zmk_keymap) +#define ZMK_KEYMAP_LAYERS_LEN DT_PROP_LEN(ZMK_KEYMAP_NODE, layers) + +#define LAYER_NODE(l) DT_PHANDLE_BY_IDX(ZMK_KEYMAP_NODE, layers, l) -#define _TRANSFORM_ENTRY(i, l) \ - [(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))] = DT_PROP_BY_IDX(DT_PHANDLE_BY_IDX(ZMK_KEYMAP_NODE, layers, l), keys, i), +#define _TRANSFORM_ENTRY(idx, layer) \ + { .behavior_dev = DT_LABEL(DT_PHANDLE_BY_IDX(DT_PHANDLE_BY_IDX(ZMK_KEYMAP_NODE, layers, layer), bindings, idx)), \ + .param1 = COND_CODE_0(DT_PHA_HAS_CELL_AT_IDX(LAYER_NODE(layer), bindings, idx, param1), (0), (DT_PHA_BY_IDX(LAYER_NODE(layer), bindings, idx, param1))), \ + .param2 = COND_CODE_0(DT_PHA_HAS_CELL_AT_IDX(LAYER_NODE(layer), bindings, idx, param2), (0), (DT_PHA_BY_IDX(LAYER_NODE(layer), bindings, idx, param2))), \ + }, #define TRANSFORMED_LAYER(idx) \ - { UTIL_LISTIFY(ZMK_KEYMAP_LEN, _TRANSFORM_ENTRY, idx) } + { UTIL_LISTIFY(DT_PROP_LEN(DT_PHANDLE_BY_IDX(ZMK_KEYMAP_NODE, layers, idx), bindings), _TRANSFORM_ENTRY, idx) } -static zmk_key zmk_keymap[ZMK_KEYMAP_LAYERS_LEN][ZMK_MATRIX_ROWS * ZMK_MATRIX_COLS] = { +static struct zmk_behavior_binding zmk_keymap[ZMK_KEYMAP_LAYERS_LEN][ZMK_MATRIX_ROWS * ZMK_MATRIX_COLS] = { #if DT_PROP_HAS_IDX(ZMK_KEYMAP_NODE, layers, 0) TRANSFORMED_LAYER(0), #endif @@ -51,73 +59,60 @@ static zmk_key zmk_keymap[ZMK_KEYMAP_LAYERS_LEN][ZMK_MATRIX_ROWS * ZMK_MATRIX_CO #endif }; -#else - -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 -}; - -#endif - #define SET_LAYER_STATE(layer, state) \ if (layer >= 32) \ { \ - return false; \ + return -EINVAL; \ } \ WRITE_BIT(zmk_keymap_layer_state, layer, state); \ - return true; + return 0; -bool zmk_keymap_layer_activate(u8_t layer) +int zmk_keymap_layer_activate(u8_t layer) { SET_LAYER_STATE(layer, true); }; -bool zmk_keymap_layer_deactivate(u8_t layer) +int 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) +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 ((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); + 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, binding->behavior_dev); + + behavior = device_get_binding(binding->behavior_dev); - zmk_key key = zmk_keymap[layer][key_index]; - if (key == ZC_TRNS) - { + 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); + } + - return key; + 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 ZC_NO; + return -ENOTSUP; } diff --git a/app/src/kscan.c b/app/src/kscan.c index 1f54a14..29a6019 100644 --- a/app/src/kscan.c +++ b/app/src/kscan.c @@ -11,8 +11,8 @@ LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL); -#include <zmk/keymap.h> -#include <zmk/handlers.h> +#include <zmk/matrix_transform.h> +#include <zmk/events.h> #define ZMK_KSCAN_EVENT_STATE_PRESSED 0 #define ZMK_KSCAN_EVENT_STATE_RELEASED 1 @@ -49,11 +49,13 @@ void zmk_kscan_process_msgq(struct k_work *item) 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); + u32_t position = zmk_matrix_transform_row_column_to_position(ev.row, ev.column); + LOG_DBG("Row: %d, col: %d, position: %d, pressed: %s\n", ev.row, ev.column, position, (pressed ? "true" : "false")); + if (pressed) { + zmk_events_position_pressed(position); + } else { + zmk_events_position_released(position); + } } } diff --git a/app/src/kscan_mock.c b/app/src/kscan_mock.c index 7d2d24d..b0ba90b 100644 --- a/app/src/kscan_mock.c +++ b/app/src/kscan_mock.c @@ -9,6 +9,7 @@ #include <device.h> #include <drivers/kscan.h> #include <logging/log.h> + LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL); #include <zmk/kscan-mock.h> diff --git a/app/src/matrix_transform.c b/app/src/matrix_transform.c new file mode 100644 index 0000000..7e8b481 --- /dev/null +++ b/app/src/matrix_transform.c @@ -0,0 +1,30 @@ + +#include <zephyr.h> +#include <zmk/matrix_transform.h> +#include <zmk/matrix.h> +#include <dt-bindings/zmk/matrix-transform.h> + +#define HAS_TRANSFORM DT_HAS_CHOSEN(zmk_matrix_transform) + +#if HAS_TRANSFORM +#define ZMK_KEYMAP_TRANSFORM_NODE DT_CHOSEN(zmk_matrix_transform) +#define ZMK_KEYMAP_LEN DT_PROP_LEN(ZMK_KEYMAP_TRANSFORM_NODE, map) + +#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) }; + +#endif + +u32_t zmk_matrix_transform_row_column_to_position(u32_t row, u32_t column) +{ + u32_t matrix_index = (row * ZMK_MATRIX_COLS) + column; + +#if HAS_TRANSFORM + return transform[matrix_index]; +#else + return matrix_index; +#endif /* HAS_TRANSFORM */ +}; |