diff --git a/app/include/drivers/behavior.h b/app/include/drivers/behavior.h
index 1db556c5..cf259b13 100644
--- a/app/include/drivers/behavior.h
+++ b/app/include/drivers/behavior.h
@@ -10,6 +10,7 @@
 #include <stddef.h>
 #include <device.h>
 #include <zmk/keys.h>
+#include <zmk/behavior.h>
 
 /**
  * @cond INTERNAL_HIDDEN
@@ -19,10 +20,10 @@
  * (Internal use only.)
  */
 
-typedef int (*behavior_keymap_binding_callback_t)(struct device *dev, u32_t position, u32_t param1,
-                                                  u32_t param2, s64_t timestamp);
-typedef int (*behavior_sensor_keymap_binding_callback_t)(struct device *dev, struct device *sensor,
-                                                         u32_t param1, u32_t param2);
+typedef int (*behavior_keymap_binding_callback_t)(struct zmk_behavior_binding *binding,
+                                                  struct zmk_behavior_binding_event event);
+typedef int (*behavior_sensor_keymap_binding_callback_t)(struct zmk_behavior_binding *binding,
+                                                         struct device *sensor);
 
 __subsystem struct behavior_driver_api {
     behavior_keymap_binding_callback_t binding_pressed;
@@ -42,19 +43,19 @@ __subsystem struct behavior_driver_api {
  * @retval 0 If successful.
  * @retval Negative errno code if failure.
  */
-__syscall int behavior_keymap_binding_pressed(struct device *dev, u32_t position, u32_t param1,
-                                              u32_t param2, s64_t timestamp);
+__syscall int behavior_keymap_binding_pressed(struct zmk_behavior_binding *binding,
+                                              struct zmk_behavior_binding_event event);
 
-static inline int z_impl_behavior_keymap_binding_pressed(struct device *dev, u32_t position,
-                                                         u32_t param1, u32_t param2,
-                                                         s64_t timestamp) {
+static inline int z_impl_behavior_keymap_binding_pressed(struct zmk_behavior_binding *binding,
+                                                         struct zmk_behavior_binding_event event) {
+    struct device *dev = device_get_binding(binding->behavior_dev);
     const struct behavior_driver_api *api = (const struct behavior_driver_api *)dev->driver_api;
 
     if (api->binding_pressed == NULL) {
         return -ENOTSUP;
     }
 
-    return api->binding_pressed(dev, position, param1, param2, timestamp);
+    return api->binding_pressed(binding, event);
 }
 
 /**
@@ -65,19 +66,19 @@ static inline int z_impl_behavior_keymap_binding_pressed(struct device *dev, u32
  * @retval 0 If successful.
  * @retval Negative errno code if failure.
  */
-__syscall int behavior_keymap_binding_released(struct device *dev, u32_t position, u32_t param1,
-                                               u32_t param2, s64_t timestamp);
+__syscall int behavior_keymap_binding_released(struct zmk_behavior_binding *binding,
+                                               struct zmk_behavior_binding_event event);
 
-static inline int z_impl_behavior_keymap_binding_released(struct device *dev, u32_t position,
-                                                          u32_t param1, u32_t param2,
-                                                          s64_t timestamp) {
+static inline int z_impl_behavior_keymap_binding_released(struct zmk_behavior_binding *binding,
+                                                          struct zmk_behavior_binding_event event) {
+    struct device *dev = device_get_binding(binding->behavior_dev);
     const struct behavior_driver_api *api = (const struct behavior_driver_api *)dev->driver_api;
 
     if (api->binding_released == NULL) {
         return -ENOTSUP;
     }
 
-    return api->binding_released(dev, position, param1, param2, timestamp);
+    return api->binding_released(binding, event);
 }
 
 /**
@@ -90,19 +91,20 @@ static inline int z_impl_behavior_keymap_binding_released(struct device *dev, u3
  * @retval 0 If successful.
  * @retval Negative errno code if failure.
  */
-__syscall int behavior_sensor_keymap_binding_triggered(struct device *dev, struct device *sensor,
-                                                       u32_t param1, u32_t param2);
+__syscall int behavior_sensor_keymap_binding_triggered(struct zmk_behavior_binding *binding,
+                                                       struct device *sensor);
 
-static inline int z_impl_behavior_sensor_keymap_binding_triggered(struct device *dev,
-                                                                  struct device *sensor,
-                                                                  u32_t param1, u32_t param2) {
+static inline int
+z_impl_behavior_sensor_keymap_binding_triggered(struct zmk_behavior_binding *binding,
+                                                struct device *sensor) {
+    struct device *dev = device_get_binding(binding->behavior_dev);
     const struct behavior_driver_api *api = (const struct behavior_driver_api *)dev->driver_api;
 
     if (api->sensor_binding_triggered == NULL) {
         return -ENOTSUP;
     }
 
-    return api->sensor_binding_triggered(dev, sensor, param1, param2);
+    return api->sensor_binding_triggered(binding, sensor);
 }
 
 /**
diff --git a/app/include/zmk/behavior.h b/app/include/zmk/behavior.h
index 6f5815f1..428ae243 100644
--- a/app/include/zmk/behavior.h
+++ b/app/include/zmk/behavior.h
@@ -10,4 +10,10 @@ struct zmk_behavior_binding {
     char *behavior_dev;
     u32_t param1;
     u32_t param2;
+};
+
+struct zmk_behavior_binding_event {
+    int layer;
+    u32_t position;
+    s64_t timestamp;
 };
\ No newline at end of file
diff --git a/app/include/zmk/events/keycode-state-changed.h b/app/include/zmk/events/keycode-state-changed.h
index 7246b83d..1e2c24e8 100644
--- a/app/include/zmk/events/keycode-state-changed.h
+++ b/app/include/zmk/events/keycode-state-changed.h
@@ -14,20 +14,15 @@ struct keycode_state_changed {
     u8_t usage_page;
     u32_t keycode;
     bool state;
-    u32_t position;
-    s32_t timestamp;
 };
 
 ZMK_EVENT_DECLARE(keycode_state_changed);
 
 inline struct keycode_state_changed *create_keycode_state_changed(u8_t usage_page, u32_t keycode,
-                                                                  bool state, s32_t position,
-                                                                  s32_t timestamp) {
+                                                                  bool state) {
     struct keycode_state_changed *ev = new_keycode_state_changed();
     ev->usage_page = usage_page;
     ev->keycode = keycode;
     ev->state = state;
-    ev->position = position;
-    ev->timestamp = timestamp;
     return ev;
 }
\ No newline at end of file
diff --git a/app/src/behaviors/behavior_bt.c b/app/src/behaviors/behavior_bt.c
index e62c64be..922c1571 100644
--- a/app/src/behaviors/behavior_bt.c
+++ b/app/src/behaviors/behavior_bt.c
@@ -8,18 +8,18 @@
 
 #include <device.h>
 #include <drivers/behavior.h>
-
 #include <dt-bindings/zmk/bt.h>
-
 #include <bluetooth/conn.h>
-
 #include <logging/log.h>
+#include <zmk/behavior.h>
+
 LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
 
 #include <zmk/ble.h>
 
-static int on_keymap_binding_pressed(struct device *dev, u32_t position, u32_t command, u32_t arg, s64_t timestamp) {
-    switch (command) {
+static int on_keymap_binding_pressed(struct zmk_behavior_binding *binding,
+                                     struct zmk_behavior_binding_event event) {
+    switch (binding->param1) {
     case BT_CLR_CMD:
         return zmk_ble_clear_bonds();
     case BT_NXT_CMD:
@@ -27,9 +27,9 @@ static int on_keymap_binding_pressed(struct device *dev, u32_t position, u32_t c
     case BT_PRV_CMD:
         return zmk_ble_prof_prev();
     case BT_SEL_CMD:
-        return zmk_ble_prof_select(arg);
+        return zmk_ble_prof_select(binding->param2);
     default:
-        LOG_ERR("Unknown BT command: %d", command);
+        LOG_ERR("Unknown BT command: %d", binding->param1);
     }
 
     return -ENOTSUP;
@@ -37,8 +37,8 @@ static int on_keymap_binding_pressed(struct device *dev, u32_t position, u32_t c
 
 static int behavior_bt_init(struct device *dev) { return 0; };
 
-static int on_keymap_binding_released(struct device *dev, u32_t position, u32_t command,
-                                      u32_t arg, s64_t timestamp) {
+static int on_keymap_binding_released(struct zmk_behavior_binding *binding,
+                                      struct zmk_behavior_binding_event event) {
     return 0;
 }
 
diff --git a/app/src/behaviors/behavior_hold_tap.c b/app/src/behaviors/behavior_hold_tap.c
index ac286e33..8b3620ef 100644
--- a/app/src/behaviors/behavior_hold_tap.c
+++ b/app/src/behaviors/behavior_hold_tap.c
@@ -10,7 +10,6 @@
 #include <drivers/behavior.h>
 #include <logging/log.h>
 #include <zmk/behavior.h>
-
 #include <zmk/matrix.h>
 #include <zmk/endpoints.h>
 #include <zmk/event-manager.h>
@@ -18,6 +17,7 @@
 #include <zmk/events/keycode-state-changed.h>
 #include <zmk/events/modifiers-state-changed.h>
 #include <zmk/hid.h>
+#include <zmk/behavior.h>
 
 LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
 
@@ -49,6 +49,7 @@ struct behavior_hold_tap_config {
 // this data is specific for each hold-tap
 struct active_hold_tap {
     s32_t position;
+    // todo: move these params into the config->behaviors->tap and
     u32_t param_hold;
     u32_t param_tap;
     s64_t timestamp;
@@ -254,7 +255,7 @@ static inline char *flavor_str(enum flavor flavor) {
     return "UNKNOWN FLAVOR";
 }
 
-static void decide_hold_tap(struct active_hold_tap *hold_tap, enum decision_moment event) {
+static void decide_hold_tap(struct active_hold_tap *hold_tap, enum decision_moment event_type) {
     if (hold_tap->is_decided) {
         return;
     }
@@ -266,11 +267,11 @@ static void decide_hold_tap(struct active_hold_tap *hold_tap, enum decision_mome
 
     switch (hold_tap->config->flavor) {
     case ZMK_BHV_HOLD_TAP_FLAVOR_HOLD_PREFERRED:
-        decide_hold_preferred(hold_tap, event);
+        decide_hold_preferred(hold_tap, event_type);
     case ZMK_BHV_HOLD_TAP_FLAVOR_BALANCED:
-        decide_balanced(hold_tap, event);
+        decide_balanced(hold_tap, event_type);
     case ZMK_BHV_HOLD_TAP_FLAVOR_TAP_PREFERRED:
-        decide_tap_preferred(hold_tap, event);
+        decide_tap_preferred(hold_tap, event_type);
     }
 
     if (!hold_tap->is_decided) {
@@ -278,26 +279,31 @@ static void decide_hold_tap(struct active_hold_tap *hold_tap, enum decision_mome
     }
 
     LOG_DBG("%d decided %s (%s event %d)", hold_tap->position, hold_tap->is_hold ? "hold" : "tap",
-            flavor_str(hold_tap->config->flavor), event);
+            flavor_str(hold_tap->config->flavor), event_type);
     undecided_hold_tap = NULL;
 
-    struct zmk_behavior_binding *behavior;
+    struct zmk_behavior_binding_event event = {
+        .position = hold_tap->position,
+        .timestamp = hold_tap->timestamp,
+    };
+
+    struct zmk_behavior_binding binding;
     if (hold_tap->is_hold) {
-        behavior = &hold_tap->config->behaviors->hold;
-        struct device *behavior_device = device_get_binding(behavior->behavior_dev);
-        behavior_keymap_binding_pressed(behavior_device, hold_tap->position, hold_tap->param_hold,
-                                        0, hold_tap->timestamp);
+        binding.behavior_dev = hold_tap->config->behaviors->hold.behavior_dev;
+        binding.param1 = hold_tap->param_hold;
+        binding.param2 = 0;
     } else {
-        behavior = &hold_tap->config->behaviors->tap;
-        struct device *behavior_device = device_get_binding(behavior->behavior_dev);
-        behavior_keymap_binding_pressed(behavior_device, hold_tap->position, hold_tap->param_tap, 0,
-                                        hold_tap->timestamp);
+        binding.behavior_dev = hold_tap->config->behaviors->tap.behavior_dev;
+        binding.param1 = hold_tap->param_tap;
+        binding.param2 = 0;
     }
+    behavior_keymap_binding_pressed(&binding, event);
     release_captured_events();
 }
 
-static int on_hold_tap_binding_pressed(struct device *dev, u32_t position, u32_t param_hold,
-                                       u32_t param_tap, s64_t timestamp) {
+static int on_hold_tap_binding_pressed(struct zmk_behavior_binding *binding,
+                                       struct zmk_behavior_binding_event event) {
+    struct device *dev = device_get_binding(binding->behavior_dev);
     const struct behavior_hold_tap_config *cfg = dev->config_info;
 
     if (undecided_hold_tap != NULL) {
@@ -307,14 +313,14 @@ static int on_hold_tap_binding_pressed(struct device *dev, u32_t position, u32_t
     }
 
     struct active_hold_tap *hold_tap =
-        store_hold_tap(position, param_hold, param_tap, timestamp, cfg);
+        store_hold_tap(event.position, binding->param1, binding->param2, event.timestamp, cfg);
     if (hold_tap == NULL) {
         LOG_ERR("unable to store hold-tap info, did you press more than %d hold-taps?",
                 ZMK_BHV_HOLD_TAP_MAX_HELD);
         return 0;
     }
 
-    LOG_DBG("%d new undecided hold_tap", position);
+    LOG_DBG("%d new undecided hold_tap", event.position);
     undecided_hold_tap = hold_tap;
 
     // if this behavior was queued we have to adjust the timer to only
@@ -327,9 +333,9 @@ static int on_hold_tap_binding_pressed(struct device *dev, u32_t position, u32_t
     return 0;
 }
 
-static int on_hold_tap_binding_released(struct device *dev, u32_t position, u32_t _, u32_t __,
-                                        s64_t timestamp) {
-    struct active_hold_tap *hold_tap = find_hold_tap(position);
+static int on_hold_tap_binding_released(struct zmk_behavior_binding *binding,
+                                        struct zmk_behavior_binding_event event) {
+    struct active_hold_tap *hold_tap = find_hold_tap(event.position);
     if (hold_tap == NULL) {
         LOG_ERR("ACTIVE_HOLD_TAP_CLEANED_UP_TOO_EARLY");
         return 0;
@@ -338,32 +344,37 @@ static int on_hold_tap_binding_released(struct device *dev, u32_t position, u32_
     // If these events were queued, the timer event may be queued too late or not at all.
     // We insert a timer event before the TH_KEY_UP event to verify.
     int work_cancel_result = k_delayed_work_cancel(&hold_tap->work);
-    if (timestamp > (hold_tap->timestamp + hold_tap->config->tapping_term_ms)) {
+    if (event.timestamp > (hold_tap->timestamp + hold_tap->config->tapping_term_ms)) {
         decide_hold_tap(hold_tap, HT_TIMER_EVENT);
     }
 
     decide_hold_tap(hold_tap, HT_KEY_UP);
 
-    struct zmk_behavior_binding *behavior;
+    // todo: set up the binding and data items inside of the active_hold_tap struct
+    struct zmk_behavior_binding_event sub_behavior_data = {
+        .position = hold_tap->position,
+        .timestamp = hold_tap->timestamp,
+    };
+
+    struct zmk_behavior_binding sub_behavior_binding;
     if (hold_tap->is_hold) {
-        behavior = &hold_tap->config->behaviors->hold;
-        struct device *behavior_device = device_get_binding(behavior->behavior_dev);
-        behavior_keymap_binding_released(behavior_device, hold_tap->position, hold_tap->param_hold,
-                                         0, timestamp);
+        sub_behavior_binding.behavior_dev = hold_tap->config->behaviors->hold.behavior_dev;
+        sub_behavior_binding.param1 = hold_tap->param_hold;
+        sub_behavior_binding.param2 = 0;
     } else {
-        behavior = &hold_tap->config->behaviors->tap;
-        struct device *behavior_device = device_get_binding(behavior->behavior_dev);
-        behavior_keymap_binding_released(behavior_device, hold_tap->position, hold_tap->param_tap,
-                                         0, timestamp);
+        sub_behavior_binding.behavior_dev = hold_tap->config->behaviors->tap.behavior_dev;
+        sub_behavior_binding.param1 = hold_tap->param_tap;
+        sub_behavior_binding.param2 = 0;
     }
+    behavior_keymap_binding_released(&sub_behavior_binding, sub_behavior_data);
 
     if (work_cancel_result == -EINPROGRESS) {
         // let the timer handler clean up
         // if we'd clear now, the timer may call back for an uninitialized active_hold_tap.
-        LOG_DBG("%d hold-tap timer work in event queue", position);
+        LOG_DBG("%d hold-tap timer work in event queue", event.position);
         hold_tap->work_is_cancelled = true;
     } else {
-        LOG_DBG("%d cleaning up hold-tap", position);
+        LOG_DBG("%d cleaning up hold-tap", event.position);
         clear_hold_tap(hold_tap);
     }
 
@@ -482,6 +493,7 @@ static int behavior_hold_tap_init(struct device *dev) {
 struct behavior_hold_tap_data {};
 static struct behavior_hold_tap_data behavior_hold_tap_data;
 
+/* todo: get rid of unused param1 and param2. */
 #define _TRANSFORM_ENTRY(idx, node)                                                                \
     {                                                                                              \
         .behavior_dev = DT_LABEL(DT_INST_PHANDLE_BY_IDX(node, bindings, idx)),                     \
diff --git a/app/src/behaviors/behavior_key_press.c b/app/src/behaviors/behavior_key_press.c
index fcba451c..d691e9fe 100644
--- a/app/src/behaviors/behavior_key_press.c
+++ b/app/src/behaviors/behavior_key_press.c
@@ -12,6 +12,7 @@
 
 #include <zmk/event-manager.h>
 #include <zmk/events/keycode-state-changed.h>
+#include <zmk/behavior.h>
 
 LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
 
@@ -22,22 +23,24 @@ 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 _,
-                                     s64_t timestamp) {
+static int on_keymap_binding_pressed(struct zmk_behavior_binding *binding,
+                                     struct zmk_behavior_binding_event event) {
+    struct device *dev = device_get_binding(binding->behavior_dev);
     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);
+    LOG_DBG("position %d usage_page 0x%02X keycode 0x%02X", event.position, cfg->usage_page,
+            binding->param1);
 
-    return ZMK_EVENT_RAISE(
-        create_keycode_state_changed(cfg->usage_page, keycode, true, position, timestamp));
+    return ZMK_EVENT_RAISE(create_keycode_state_changed(cfg->usage_page, binding->param1, true));
 }
 
-static int on_keymap_binding_released(struct device *dev, u32_t position, u32_t keycode, u32_t _,
-                                      s64_t timestamp) {
+static int on_keymap_binding_released(struct zmk_behavior_binding *binding,
+                                      struct zmk_behavior_binding_event event) {
+    struct device *dev = device_get_binding(binding->behavior_dev);
     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);
+    LOG_DBG("position %d usage_page 0x%02X keycode 0x%02X", event.position, cfg->usage_page,
+            binding->param1);
 
-    return ZMK_EVENT_RAISE(
-        create_keycode_state_changed(cfg->usage_page, keycode, false, position, timestamp));
+    return ZMK_EVENT_RAISE(create_keycode_state_changed(cfg->usage_page, binding->param1, false));
 }
 
 static const struct behavior_driver_api behavior_key_press_driver_api = {
diff --git a/app/src/behaviors/behavior_momentary_layer.c b/app/src/behaviors/behavior_momentary_layer.c
index ddd6192e..b1fb14b0 100644
--- a/app/src/behaviors/behavior_momentary_layer.c
+++ b/app/src/behaviors/behavior_momentary_layer.c
@@ -11,6 +11,7 @@
 #include <logging/log.h>
 
 #include <zmk/keymap.h>
+#include <zmk/behavior.h>
 
 LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
 
@@ -19,16 +20,16 @@ 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 _,
-                                     s64_t _timestamp) {
-    LOG_DBG("position %d layer %d", position, layer);
-    return zmk_keymap_layer_activate(layer);
+static int mo_keymap_binding_pressed(struct zmk_behavior_binding *binding,
+                                     struct zmk_behavior_binding_event event) {
+    LOG_DBG("position %d layer %d", event.position, binding->param1);
+    return zmk_keymap_layer_activate(binding->param1);
 }
 
-static int mo_keymap_binding_released(struct device *dev, u32_t position, u32_t layer, u32_t _,
-                                      s64_t _timestamp) {
-    LOG_DBG("position %d layer %d", position, layer);
-    return zmk_keymap_layer_deactivate(layer);
+static int mo_keymap_binding_released(struct zmk_behavior_binding *binding,
+                                      struct zmk_behavior_binding_event event) {
+    LOG_DBG("position %d layer %d", event.position, binding->param1);
+    return zmk_keymap_layer_deactivate(binding->param1);
 }
 
 static const struct behavior_driver_api behavior_mo_driver_api = {
diff --git a/app/src/behaviors/behavior_none.c b/app/src/behaviors/behavior_none.c
index 00fbcdb0..96ea9d5d 100644
--- a/app/src/behaviors/behavior_none.c
+++ b/app/src/behaviors/behavior_none.c
@@ -11,6 +11,8 @@
 #include <drivers/behavior.h>
 #include <logging/log.h>
 
+#include <zmk/behavior.h>
+
 LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
 
 struct behavior_none_config {};
@@ -18,13 +20,13 @@ struct behavior_none_data {};
 
 static int behavior_none_init(struct device *dev) { return 0; };
 
-static int on_keymap_binding_pressed(struct device *dev, u32_t position, u32_t _param1,
-                                     u32_t _param2, s64_t _timestamp) {
+static int on_keymap_binding_pressed(struct zmk_behavior_binding *binding,
+                                     struct zmk_behavior_binding_event event) {
     return 0;
 }
 
-static int on_keymap_binding_released(struct device *dev, u32_t position, u32_t _param1,
-                                      u32_t _param2, s64_t _timestamp) {
+static int on_keymap_binding_released(struct zmk_behavior_binding *binding,
+                                      struct zmk_behavior_binding_event event) {
     return 0;
 }
 
diff --git a/app/src/behaviors/behavior_reset.c b/app/src/behaviors/behavior_reset.c
index 03c5172d..d1233a51 100644
--- a/app/src/behaviors/behavior_reset.c
+++ b/app/src/behaviors/behavior_reset.c
@@ -11,6 +11,8 @@
 #include <drivers/behavior.h>
 #include <logging/log.h>
 
+#include <zmk/behavior.h>
+
 LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
 
 struct behavior_reset_config {
@@ -19,8 +21,9 @@ struct behavior_reset_config {
 
 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, s64_t _timestamp) {
+static int on_keymap_binding_pressed(struct zmk_behavior_binding *binding,
+                                     struct zmk_behavior_binding_event event) {
+    struct device *dev = device_get_binding(binding->behavior_dev);
     const struct behavior_reset_config *cfg = dev->config_info;
 
     // TODO: Correct magic code for going into DFU?
diff --git a/app/src/behaviors/behavior_rgb_underglow.c b/app/src/behaviors/behavior_rgb_underglow.c
index f5c2d260..2ee6716a 100644
--- a/app/src/behaviors/behavior_rgb_underglow.c
+++ b/app/src/behaviors/behavior_rgb_underglow.c
@@ -12,14 +12,15 @@
 
 #include <dt-bindings/zmk/rgb.h>
 #include <zmk/rgb_underglow.h>
+#include <zmk/keymap.h>
 
 LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
 
 static int behavior_rgb_underglow_init(struct device *dev) { return 0; }
 
-static int on_keymap_binding_pressed(struct device *dev, u32_t position, u32_t action, u32_t _,
-                                     s64_t _timestamp) {
-    switch (action) {
+static int on_keymap_binding_pressed(struct zmk_behavior_binding *binding,
+                                     struct zmk_behavior_binding_event event) {
+    switch (binding->param1) {
     case RGB_TOG:
         return zmk_rgb_underglow_toggle();
     case RGB_HUI:
diff --git a/app/src/behaviors/behavior_sensor_rotate_key_press.c b/app/src/behaviors/behavior_sensor_rotate_key_press.c
index 1a0bf03a..71c4376c 100644
--- a/app/src/behaviors/behavior_sensor_rotate_key_press.c
+++ b/app/src/behaviors/behavior_sensor_rotate_key_press.c
@@ -23,15 +23,16 @@ struct behavior_sensor_rotate_key_press_data {};
 
 static int behavior_sensor_rotate_key_press_init(struct device *dev) { return 0; };
 
-static int on_sensor_binding_triggered(struct device *dev, struct device *sensor,
-                                       u32_t increment_keycode, u32_t decrement_keycode) {
+static int on_sensor_binding_triggered(struct zmk_behavior_binding *binding,
+                                       struct device *sensor) {
+    struct device *dev = device_get_binding(binding->behavior_dev);
     const struct behavior_sensor_rotate_key_press_config *cfg = dev->config_info;
     struct sensor_value value;
     int err;
     u32_t keycode;
     struct keycode_state_changed *ev;
     LOG_DBG("usage_page 0x%02X inc keycode 0x%02X dec keycode 0x%02X", cfg->usage_page,
-            increment_keycode, decrement_keycode);
+            binding->param1, binding->param2);
 
     err = sensor_channel_get(sensor, SENSOR_CHAN_ROTATION, &value);
 
@@ -42,10 +43,10 @@ static int on_sensor_binding_triggered(struct device *dev, struct device *sensor
 
     switch (value.val1) {
     case 1:
-        keycode = increment_keycode;
+        keycode = binding->param1;
         break;
     case -1:
-        keycode = decrement_keycode;
+        keycode = binding->param2;
         break;
     default:
         return -ENOTSUP;
diff --git a/app/src/behaviors/behavior_toggle_layer.c b/app/src/behaviors/behavior_toggle_layer.c
index 302de6b8..b3c69614 100644
--- a/app/src/behaviors/behavior_toggle_layer.c
+++ b/app/src/behaviors/behavior_toggle_layer.c
@@ -11,6 +11,7 @@
 #include <logging/log.h>
 
 #include <zmk/keymap.h>
+#include <zmk/behavior.h>
 
 LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
 
@@ -19,15 +20,15 @@ struct behavior_tog_data {};
 
 static int behavior_tog_init(struct device *dev) { return 0; };
 
-static int tog_keymap_binding_pressed(struct device *dev, u32_t position, u32_t layer, u32_t _,
-                                      s64_t _timestamp) {
-    LOG_DBG("position %d layer %d", position, layer);
-    return zmk_keymap_layer_toggle(layer);
+static int tog_keymap_binding_pressed(struct zmk_behavior_binding *binding,
+                                      struct zmk_behavior_binding_event event) {
+    LOG_DBG("position %d layer %d", event.position, binding->param1);
+    return zmk_keymap_layer_toggle(binding->param1);
 }
 
-static int tog_keymap_binding_released(struct device *dev, u32_t position, u32_t layer, u32_t _,
-                                       s64_t _timestamp) {
-    LOG_DBG("position %d layer %d", position, layer);
+static int tog_keymap_binding_released(struct zmk_behavior_binding *binding,
+                                       struct zmk_behavior_binding_event event) {
+    LOG_DBG("position %d layer %d", event.position, binding->param1);
     return 0;
 }
 
diff --git a/app/src/behaviors/behavior_transparent.c b/app/src/behaviors/behavior_transparent.c
index a46a92e0..cede3699 100644
--- a/app/src/behaviors/behavior_transparent.c
+++ b/app/src/behaviors/behavior_transparent.c
@@ -11,6 +11,8 @@
 #include <drivers/behavior.h>
 #include <logging/log.h>
 
+#include <zmk/behavior.h>
+
 LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
 
 struct behavior_transparent_config {};
@@ -18,13 +20,13 @@ 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, s64_t _timestamp) {
+static int on_keymap_binding_pressed(struct zmk_behavior_binding *binding,
+                                     struct zmk_behavior_binding_event event) {
     return 1;
 }
 
-static int on_keymap_binding_released(struct device *dev, u32_t position, u32_t _param1,
-                                      u32_t _param2, s64_t _timestamp) {
+static int on_keymap_binding_released(struct zmk_behavior_binding *binding,
+                                      struct zmk_behavior_binding_event event) {
     return 1;
 }
 
diff --git a/app/src/keymap.c b/app/src/keymap.c
index 4e4c9f65..74fe60db 100644
--- a/app/src/keymap.c
+++ b/app/src/keymap.c
@@ -107,6 +107,11 @@ bool is_active_layer(u8_t layer, u32_t layer_state) {
 int zmk_keymap_apply_position_state(int layer, u32_t position, bool pressed, s64_t timestamp) {
     struct zmk_behavior_binding *binding = &zmk_keymap[layer][position];
     struct device *behavior;
+    struct zmk_behavior_binding_event event = {
+        .layer = layer,
+        .position = position,
+        .timestamp = timestamp,
+    };
 
     LOG_DBG("layer: %d position: %d, binding name: %s", layer, position,
             log_strdup(binding->behavior_dev));
@@ -119,11 +124,9 @@ int zmk_keymap_apply_position_state(int layer, u32_t position, bool pressed, s64
     }
 
     if (pressed) {
-        return behavior_keymap_binding_pressed(behavior, position, binding->param1, binding->param2,
-                                               timestamp);
+        return behavior_keymap_binding_pressed(binding, event);
     } else {
-        return behavior_keymap_binding_released(behavior, position, binding->param1,
-                                                binding->param2, timestamp);
+        return behavior_keymap_binding_released(binding, event);
     }
 }
 
@@ -171,8 +174,7 @@ int zmk_keymap_sensor_triggered(u8_t sensor_number, struct device *sensor) {
                 continue;
             }
 
-            ret = behavior_sensor_keymap_binding_triggered(behavior, sensor, binding->param1,
-                                                           binding->param2);
+            ret = behavior_sensor_keymap_binding_triggered(binding, sensor);
 
             if (ret > 0) {
                 LOG_DBG("behavior processing to continue to next layer");