Fix consumer keys w/ refactored behaviors.

8 files changed, 133 insertions, 121 deletions

diff --git a/app/src/behaviors/behavior_hid.c b/app/src/behaviors/behavior_hid.c
index 0aeade5..1ac7404 100644
--- a/app/src/behaviors/behavior_hid.c
+++ b/app/src/behaviors/behavior_hid.c
@@ -24,22 +24,53 @@ static int behavior_hid_init(struct device *dev)
 	return 0;
 };
 
-static int on_keycode_pressed(struct device *dev, u32_t keycode)
+static int on_keycode_pressed(struct device *dev, u8_t usage_page, u32_t keycode)
 {
-  enum zmk_hid_report_changes changes;
+  int err;
   LOG_DBG("keycode %d", keycode);
   
-  changes = zmk_hid_press_key(keycode);
-  return zmk_endpoints_send_report(changes);
+  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, u32_t keycode)
+static int on_keycode_released(struct device *dev, u8_t usage_page, u32_t keycode)
 {
-  enum zmk_hid_report_changes changes;
+  int err;
   LOG_DBG("keycode %d", keycode);
   
-  changes = zmk_hid_release_key(keycode);
-  return zmk_endpoints_send_report(changes);
+  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)
@@ -47,7 +78,7 @@ 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(Keypad);
+  return zmk_endpoints_send_report(USAGE_KEYPAD);
 }
 
 static int on_modifiers_released(struct device *dev, zmk_mod_flags modifiers)
@@ -55,7 +86,7 @@ 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(Keypad);
+  return zmk_endpoints_send_report(USAGE_KEYPAD);
 }
 
 static const struct behavior_driver_api behavior_hid_driver_api = {
diff --git a/app/src/behaviors/behavior_key_press.c b/app/src/behaviors/behavior_key_press.c
index 1b3e670..7213b3c 100644
--- a/app/src/behaviors/behavior_key_press.c
+++ b/app/src/behaviors/behavior_key_press.c
@@ -14,7 +14,9 @@
 
 LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
 
-struct behavior_key_press_config { };
+struct behavior_key_press_config {
+  u8_t usage_page;
+};
 struct behavior_key_press_data { };
 
 static int behavior_key_press_init(struct device *dev)
@@ -22,44 +24,34 @@ static int behavior_key_press_init(struct device *dev)
 	return 0;
 };
 
-
-// They keycode is passed by the "keymap" based on the parameter created as part of the assignment.
-// Other drivers instead might activate a layer, update the consumer page state, or update the RGB state, etc.
-// Returns:
-//  * > 0 -  indicate successful processing, and halt further handling,
-//  * 0 - Indicate successful processing, and continue propagation.
-//  * < 0 - Indicate error processing, report and halt further propagation.
 static int on_keymap_binding_pressed(struct device *dev, u32_t position, u32_t keycode, u32_t _)
 {
-  LOG_DBG("position %d keycode %d", position, keycode);
-  return zmk_events_keycode_pressed(keycode);
+  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);
 }
 
-
-// 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 keycode, u32_t _)
 {
-  LOG_DBG("position %d keycode %d", position, keycode);
-  return zmk_events_keycode_released(keycode);
+  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 = {
-  // 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
-  // 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_key_press_config behavior_key_press_config = {};
-
-static struct behavior_key_press_data behavior_key_press_data;
-
-DEVICE_AND_API_INIT(behavior_key_press, DT_INST_LABEL(0), behavior_key_press_init,
-                    &behavior_key_press_data,
-                    &behavior_key_press_config,
-                    APPLICATION, CONFIG_KERNEL_INIT_PRIORITY_DEFAULT,
-                    &behavior_key_press_driver_api);
+#define KP_INST(n) \
+  static const struct behavior_key_press_config behavior_key_press_config_##n = { \
+    .usage_page = DT_INST_PROP(n, usage_page) \
+  }; \
+  static struct behavior_key_press_data behavior_key_press_data_##n; \
+  DEVICE_AND_API_INIT(behavior_key_press_##n, DT_INST_LABEL(n), behavior_key_press_init, \
+                      &behavior_key_press_data_##n, \
+                      &behavior_key_press_config_##n, \
+                      APPLICATION, CONFIG_KERNEL_INIT_PRIORITY_DEFAULT, \
+                      &behavior_key_press_driver_api);
+
+DT_INST_FOREACH_STATUS_OKAY(KP_INST)
\ No newline at end of file
diff --git a/app/src/behaviors/behavior_mod_tap.c b/app/src/behaviors/behavior_mod_tap.c
index 7684c29..2e6e339 100644
--- a/app/src/behaviors/behavior_mod_tap.c
+++ b/app/src/behaviors/behavior_mod_tap.c
@@ -40,17 +40,17 @@ static int on_keymap_binding_released(struct device *dev, u32_t position, u32_t
   struct behavior_mod_tap_data *data = dev->driver_data;
   LOG_DBG("mods: %d, keycode: %d", mods, keycode);
   
-  zmk_events_modifiers_released(mods);
+zmk_events_modifiers_released(mods);
   if (data->pending_press_positions & BIT(position)) {
-    zmk_events_keycode_pressed(keycode);
+    zmk_events_keycode_pressed(USAGE_KEYPAD, keycode);
     k_msleep(10);
-    zmk_events_keycode_released(keycode);
+    zmk_events_keycode_released(USAGE_KEYPAD, keycode);
   }
 
   return 0;
 }
 
-static int on_keycode_pressed(struct device *dev, u32_t keycode)
+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;
@@ -58,8 +58,7 @@ static int on_keycode_pressed(struct device *dev, u32_t keycode)
   return 0;
 }
 
-
-static int on_keycode_released(struct device *dev, u32_t keycode)
+static int on_keycode_released(struct device *dev, u8_t usage_page, u32_t keycode)
 {
   LOG_DBG("releasing: %d", keycode);
   return 0;
diff --git a/app/src/behaviors/behavior_momentary_layer.c b/app/src/behaviors/behavior_momentary_layer.c
index f85d33d..904051e 100644
--- a/app/src/behaviors/behavior_momentary_layer.c
+++ b/app/src/behaviors/behavior_momentary_layer.c
@@ -24,14 +24,14 @@ static int behavior_mo_init(struct device *dev)
 };
 
 
-static int on_keymap_binding_pressed(struct device *dev, u32_t position, u32_t layer, u32_t _)
+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 on_keymap_binding_released(struct device *dev, u32_t position, u32_t layer, u32_t _)
+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);
 
@@ -39,8 +39,8 @@ static int on_keymap_binding_released(struct device *dev, u32_t position, u32_t
 }
 
 static const struct behavior_driver_api behavior_mo_driver_api = {
-  .binding_pressed = on_keymap_binding_pressed,
-  .binding_released = on_keymap_binding_released
+  .binding_pressed = mo_keymap_binding_pressed,
+  .binding_released = mo_keymap_binding_released
 };
 
 
diff --git a/app/src/endpoints.c b/app/src/endpoints.c
index 2f31e10..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,15 +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;
-    LOG_DBG("");
-    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)
@@ -61,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)
@@ -80,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
index 376f370..fabb93e 100644
--- a/app/src/events.c
+++ b/app/src/events.c
@@ -33,22 +33,22 @@ int zmk_events_position_released(u32_t position)
     return 0;
 };
 
-int zmk_events_keycode_pressed(u32_t keycode)
+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, keycode);
+        behavior_keycode_pressed(dev, usage_page, keycode);
     }
     return 0;
 };
 
-int zmk_events_keycode_released(u32_t keycode)
+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, keycode);
+        behavior_keycode_released(dev, usage_page, keycode);
     }
     return 0;
 };
diff --git a/app/src/hid.c b/app/src/hid.c
index 2bcb621..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 >= LCTL && code <= RGUI)
     {
         return zmk_hid_register_mod(code - 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;
-    // }
+   
+    if (code > ZMK_HID_MAX_KEYCODE)
+    {
+        return -EINVAL;
+    }
+
+    // TOGGLE_BOOT_KEY(0U, code);
+
+    TOGGLE_KEY(code, true);
+
+    return 0;
 };
 
-enum zmk_hid_report_changes zmk_hid_release_key(zmk_key code)
+int zmk_hid_keypad_release(zmk_key code)
 {
     if (code >= LCTL && code <= RGUI)
     {
         return zmk_hid_unregister_mod(code - LCTL);
     }
 
-    // if (ZK_IS_CONSUMER(code))
-    // {
-    //     TOGGLE_CONSUMER(code, false);
-    //     return Consumer;
-    // }
-    // else
-    // {
-        if (code > ZMK_HID_MAX_KEYCODE)
-        {
-            return -EINVAL;
-        }
+    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 e14626a..dd0fee4 100644
--- a/app/src/keymap.c
+++ b/app/src/keymap.c
@@ -62,17 +62,17 @@ static struct zmk_behavior_binding zmk_keymap[ZMK_KEYMAP_LAYERS_LEN][ZMK_MATRIX_
 #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);
 };
@@ -87,7 +87,7 @@ int zmk_keymap_position_state_changed(u32_t position, bool pressed)
 			struct device *behavior;
 			int ret;
 
-			LOG_DBG("position: %d, binding name: %s", position, binding->behavior_dev);
+			LOG_DBG("layer: %d position: %d, binding name: %s", layer, position, binding->behavior_dev);
 
 			behavior = device_get_binding(binding->behavior_dev);