Merge branch 'led-indicators' of https://github.com/bortoz/zmk into A…

…ltar-I-led-indicators

app/CMakeLists.txt

@@ -37,6 +37,8 @@ target_sources(app PRIVATE src/behaviors/behavior_reset.c)
 target_sources_ifdef(CONFIG_ZMK_EXT_POWER app PRIVATE src/behaviors/behavior_ext_power.c)
 if ((NOT CONFIG_ZMK_SPLIT) OR CONFIG_ZMK_SPLIT_ROLE_CENTRAL)
   target_sources(app PRIVATE src/hid.c)
+  target_sources_ifdef(CONFIG_ZMK_USB app PRIVATE src/usb_hid.c)
+
   target_sources(app PRIVATE src/behaviors/behavior_key_press.c)
   target_sources_ifdef(CONFIG_ZMK_BEHAVIOR_KEY_TOGGLE app PRIVATE src/behaviors/behavior_key_toggle.c)
   target_sources(app PRIVATE src/behaviors/behavior_hold_tap.c)
@@ -65,6 +67,7 @@ if ((NOT CONFIG_ZMK_SPLIT) OR CONFIG_ZMK_SPLIT_ROLE_CENTRAL)
   target_sources(app PRIVATE src/events/layer_state_changed.c)
   target_sources(app PRIVATE src/events/modifiers_state_changed.c)
   target_sources(app PRIVATE src/events/keycode_state_changed.c)
+  target_sources(app PRIVATE src/hid_indicators.c)
 
   if (CONFIG_ZMK_BLE)
     target_sources(app PRIVATE src/events/ble_active_profile_changed.c)
@@ -80,11 +83,12 @@ target_sources_ifdef(CONFIG_ZMK_BACKLIGHT app PRIVATE src/behaviors/behavior_bac
 target_sources_ifdef(CONFIG_ZMK_BATTERY_REPORTING app PRIVATE src/events/battery_state_changed.c)
 target_sources_ifdef(CONFIG_ZMK_BATTERY_REPORTING app PRIVATE src/battery.c)
 
+target_sources(app PRIVATE src/events/hid_indicators_changed.c)
+
 target_sources_ifdef(CONFIG_ZMK_SPLIT app PRIVATE src/events/split_peripheral_status_changed.c)
 add_subdirectory(src/split)
 
 target_sources_ifdef(CONFIG_USB_DEVICE_STACK app PRIVATE src/usb.c)
-target_sources_ifdef(CONFIG_ZMK_USB app PRIVATE src/usb_hid.c)
 target_sources_ifdef(CONFIG_ZMK_RGB_UNDERGLOW app PRIVATE src/rgb_underglow.c)
 target_sources_ifdef(CONFIG_ZMK_BACKLIGHT app PRIVATE src/backlight.c)
 target_sources(app PRIVATE src/workqueue.c)

app/include/zmk/ble.h

@@ -26,6 +26,7 @@ int zmk_ble_prof_prev();
 int zmk_ble_prof_select(uint8_t index);
 
 int zmk_ble_active_profile_index();
+int zmk_ble_profile_index(const bt_addr_le_t *addr);
 bt_addr_le_t *zmk_ble_active_profile_addr();
 bool zmk_ble_active_profile_is_open();
 bool zmk_ble_active_profile_is_connected();

app/include/zmk/events/hid_indicators_changed.h

@@ -0,0 +1,16 @@
+/*
+ * Copyright (c) 2022 The ZMK Contributors
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#pragma once
+
+#include <zmk/hid_indicators_types.h>
+#include <zmk/event_manager.h>
+
+struct zmk_hid_indicators_changed {
+    zmk_hid_indicators indicators;
+};
+
+ZMK_EVENT_DECLARE(zmk_hid_indicators_changed);

app/include/zmk/hid.h

@@ -17,11 +17,15 @@
 
 #define COLLECTION_REPORT 0x03
 
+#define HID_REPORT_ID_KEYBOARD 0x01
+#define HID_REPORT_ID_LEDS 0x01
+#define HID_REPORT_ID_CONSUMER 0x02
+
 static const uint8_t zmk_hid_report_desc[] = {
     HID_USAGE_PAGE(HID_USAGE_GEN_DESKTOP),
     HID_USAGE(HID_USAGE_GD_KEYBOARD),
     HID_COLLECTION(HID_COLLECTION_APPLICATION),
-    HID_REPORT_ID(0x01),
+    HID_REPORT_ID(HID_REPORT_ID_KEYBOARD),
     HID_USAGE_PAGE(HID_USAGE_KEY),
     HID_USAGE_MIN8(HID_USAGE_KEY_KEYBOARD_LEFTCONTROL),
     HID_USAGE_MAX8(HID_USAGE_KEY_KEYBOARD_RIGHT_GUI),
@@ -39,6 +43,20 @@ static const uint8_t zmk_hid_report_desc[] = {
     /* INPUT (Cnst,Var,Abs) */
     HID_INPUT(0x03),
 
+    HID_USAGE_PAGE(HID_USAGE_LED),
+    HID_USAGE_MIN8(HID_USAGE_LED_NUM_LOCK),
+    HID_USAGE_MAX8(HID_USAGE_LED_KANA),
+    HID_REPORT_SIZE(0x01),
+    HID_REPORT_COUNT(0x05),
+    /* OUTPUT (Data,Var,Abs) */
+    HID_OUTPUT(0x02),
+
+    HID_USAGE_PAGE(HID_USAGE_LED),
+    HID_REPORT_SIZE(0x03),
+    HID_REPORT_COUNT(0x01),
+    /* OUTPUT (Cnst,Var,Abs) */
+    HID_OUTPUT(0x03),
+
     HID_USAGE_PAGE(HID_USAGE_KEY),
 
 #if IS_ENABLED(CONFIG_ZMK_HID_REPORT_TYPE_NKRO)
@@ -67,7 +85,7 @@ static const uint8_t zmk_hid_report_desc[] = {
     HID_USAGE_PAGE(HID_USAGE_CONSUMER),
     HID_USAGE(HID_USAGE_CONSUMER_CONSUMER_CONTROL),
     HID_COLLECTION(HID_COLLECTION_APPLICATION),
-    HID_REPORT_ID(0x02),
+    HID_REPORT_ID(HID_REPORT_ID_CONSUMER),
     HID_USAGE_PAGE(HID_USAGE_CONSUMER),
 
 #if IS_ENABLED(CONFIG_ZMK_HID_CONSUMER_REPORT_USAGES_BASIC)
@@ -113,6 +131,15 @@ struct zmk_hid_keyboard_report {
     struct zmk_hid_keyboard_report_body body;
 } __packed;
 
+struct zmk_hid_led_report_body {
+    uint8_t leds;
+} __packed;
+
+struct zmk_hid_led_report {
+    uint8_t report_id;
+    struct zmk_hid_led_report_body body;
+} __packed;
+
 struct zmk_hid_consumer_report_body {
 #if IS_ENABLED(CONFIG_ZMK_HID_CONSUMER_REPORT_USAGES_BASIC)
     uint8_t keys[CONFIG_ZMK_HID_CONSUMER_REPORT_SIZE];

app/include/zmk/hid_indicators.h

@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 The ZMK Contributors
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#pragma once
+
+#include <zmk/endpoints_types.h>
+#include <zmk/hid.h>
+#include <zmk/hid_indicators_types.h>
+
+zmk_hid_indicators zmk_hid_indicators_get_current_profile(void);
+zmk_hid_indicators zmk_hid_indicators_get_profile(struct zmk_endpoint_instance endpoint);
+void zmk_hid_indicators_set_profile(zmk_hid_indicators indicators,
+                                    struct zmk_endpoint_instance endpoint);
+
+void zmk_hid_indicators_process_report(struct zmk_hid_led_report_body *report,
+                                       struct zmk_endpoint_instance endpoint);

app/include/zmk/hid_indicators_types.h

@@ -0,0 +1,9 @@
+/*
+ * Copyright (c) 2022 The ZMK Contributors
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#pragma once
+
+typedef uint8_t zmk_hid_indicators;

app/include/zmk/split/bluetooth/central.h

@@ -3,6 +3,9 @@
 
 #include <zephyr/bluetooth/addr.h>
 #include <zmk/behavior.h>
+#include <zmk/hid_indicators_types.h>
 
 int zmk_split_bt_invoke_behavior(uint8_t source, struct zmk_behavior_binding *binding,
-                                 struct zmk_behavior_binding_event event, bool state);
+                                 struct zmk_behavior_binding_event event, bool state);
+
+int zmk_split_bt_update_hid_indicator(zmk_hid_indicators indicators);

app/src/ble.c

@@ -224,6 +224,15 @@ int zmk_ble_clear_bonds() {
 
 int zmk_ble_active_profile_index() { return active_profile; }
 
+int zmk_ble_profile_index(const bt_addr_le_t *addr) {
+    for (int i = 0; i < ZMK_BLE_PROFILE_COUNT; i++) {
+        if (bt_addr_le_cmp(addr, &profiles[i].peer) == 0) {
+            return i;
+        }
+    }
+    return -ENODEV;
+}
+
 #if IS_ENABLED(CONFIG_SETTINGS)
 static void ble_save_profile_work(struct k_work *work) {
     settings_save_one("ble/active_profile", &active_profile, sizeof(active_profile));

app/src/endpoints.c

@@ -116,9 +116,7 @@ int zmk_endpoints_toggle_transport(void) {
     return zmk_endpoints_select_transport(new_transport);
 }
 
-struct zmk_endpoint_instance zmk_endpoints_selected(void) {
-    return current_instance;
-}
+struct zmk_endpoint_instance zmk_endpoints_selected(void) { return current_instance; }
 
 static int send_keyboard_report(void) {
     struct zmk_hid_keyboard_report *keyboard_report = zmk_hid_get_keyboard_report();

app/src/events/hid_indicators_changed.c

@@ -0,0 +1,10 @@
+/*
+ * Copyright (c) 2022 The ZMK Contributors
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#include <zephyr/kernel.h>
+#include <zmk/events/hid_indicators_changed.h>
+
+ZMK_EVENT_IMPL(zmk_hid_indicators_changed);

app/src/hid.c

@@ -12,9 +12,10 @@ LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
 #include <dt-bindings/zmk/modifiers.h>
 
 static struct zmk_hid_keyboard_report keyboard_report = {
-    .report_id = 1, .body = {.modifiers = 0, ._reserved = 0, .keys = {0}}};
+    .report_id = HID_REPORT_ID_KEYBOARD, .body = {.modifiers = 0, ._reserved = 0, .keys = {0}}};
 
-static struct zmk_hid_consumer_report consumer_report = {.report_id = 2, .body = {.keys = {0}}};
+static struct zmk_hid_consumer_report consumer_report = {.report_id = HID_REPORT_ID_CONSUMER,
+                                                         .body = {.keys = {0}}};
 
 // Keep track of how often a modifier was pressed.
 // Only release the modifier if the count is 0.

app/src/hid_indicators.c

@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2022 The ZMK Contributors
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#include <zephyr/kernel.h>
+#include <zephyr/logging/log.h>
+
+#include <zmk/ble.h>
+#include <zmk/endpoints.h>
+#include <zmk/hid_indicators.h>
+#include <zmk/events/hid_indicators_changed.h>
+#include <zmk/events/endpoint_changed.h>
+#include <zmk/split/bluetooth/central.h>
+
+LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
+
+static zmk_hid_indicators hid_indicators[ZMK_ENDPOINT_COUNT];
+
+zmk_hid_indicators zmk_hid_indicators_get_current_profile(void) {
+    return zmk_hid_indicators_get_profile(zmk_endpoints_selected());
+}
+
+zmk_hid_indicators zmk_hid_indicators_get_profile(struct zmk_endpoint_instance endpoint) {
+    int profile = zmk_endpoint_instance_to_index(endpoint);
+    return hid_indicators[profile];
+}
+
+static void raise_led_changed_event(struct k_work *_work) {
+    zmk_hid_indicators indicators = zmk_hid_indicators_get_current_profile();
+
+    ZMK_EVENT_RAISE(new_zmk_hid_indicators_changed(
+        (struct zmk_hid_indicators_changed){.indicators = indicators}));
+
+#if IS_ENABLED(CONFIG_ZMK_SPLIT) && IS_ENABLED(CONFIG_ZMK_BLE)
+    zmk_split_bt_update_hid_indicator(indicators);
+#endif
+}
+
+static K_WORK_DEFINE(led_changed_work, raise_led_changed_event);
+
+void zmk_hid_indicators_set_profile(zmk_hid_indicators indicators,
+                                    struct zmk_endpoint_instance endpoint) {
+    int profile = zmk_endpoint_instance_to_index(endpoint);
+
+    // This write is not happening on the main thread. To prevent potential data races, every
+    // operation involving hid_indicators must be atomic. Currently, each function either reads
+    // or writes only one entry at a time, so it is safe to do these operations without a lock.
+    hid_indicators[profile] = indicators;
+
+    k_work_submit(&led_changed_work);
+}
+
+void zmk_hid_indicators_process_report(struct zmk_hid_led_report_body *report,
+                                       struct zmk_endpoint_instance endpoint) {
+    uint8_t indicators = report->leds;
+    zmk_hid_indicators_set_profile(indicators, endpoint);
+
+    LOG_DBG("Update HID indicators: endpoint=%d, indicators=%x", endpoint.transport, indicators);
+}
+
+static int profile_listener(const zmk_event_t *eh) {
+    raise_led_changed_event(NULL);
+    return 0;
+}
+
+static ZMK_LISTENER(profile_listener, profile_listener);
+static ZMK_SUBSCRIPTION(profile_listener, zmk_endpoint_changed);

app/src/hog.c

@@ -15,8 +15,10 @@ LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
 #include <zephyr/bluetooth/gatt.h>
 
 #include <zmk/ble.h>
+#include <zmk/endpoints_types.h>
 #include <zmk/hog.h>
 #include <zmk/hid.h>
+#include <zmk/hid_indicators.h>
 
 enum {
     HIDS_REMOTE_WAKE = BIT(0),
@@ -47,12 +49,17 @@ enum {
 };
 
 static struct hids_report input = {
-    .id = 0x01,
+    .id = HID_REPORT_ID_KEYBOARD,
     .type = HIDS_INPUT,
 };
 
+static struct hids_report led_indicators = {
+    .id = HID_REPORT_ID_LEDS,
+    .type = HIDS_OUTPUT,
+};
+
 static struct hids_report consumer_input = {
-    .id = 0x02,
+    .id = HID_REPORT_ID_CONSUMER,
     .type = HIDS_INPUT,
 };
 
@@ -85,6 +92,31 @@ static ssize_t read_hids_input_report(struct bt_conn *conn, const struct bt_gatt
                              sizeof(struct zmk_hid_keyboard_report_body));
 }
 
+static ssize_t write_hids_leds_report(struct bt_conn *conn, const struct bt_gatt_attr *attr,
+                                      const void *buf, uint16_t len, uint16_t offset,
+                                      uint8_t flags) {
+    if (offset != 0) {
+        return BT_GATT_ERR(BT_ATT_ERR_INVALID_OFFSET);
+    }
+    if (len != sizeof(struct zmk_hid_led_report_body)) {
+        return BT_GATT_ERR(BT_ATT_ERR_INVALID_ATTRIBUTE_LEN);
+    }
+
+    struct zmk_hid_led_report_body *report = (struct zmk_hid_led_report_body *)buf;
+    int profile = zmk_ble_profile_index(bt_conn_get_dst(conn));
+    if (profile < 0) {
+        return BT_GATT_ERR(BT_ATT_ERR_UNLIKELY);
+    }
+
+    struct zmk_endpoint_instance endpoint = {.transport = ZMK_TRANSPORT_BLE,
+                                             .ble = {
+                                                 .profile_index = profile,
+                                             }};
+    zmk_hid_indicators_process_report(report, endpoint);
+
+    return len;
+}
+
 static ssize_t read_hids_consumer_input_report(struct bt_conn *conn,
                                                const struct bt_gatt_attr *attr, void *buf,
                                                uint16_t len, uint16_t offset) {
@@ -134,6 +166,14 @@ BT_GATT_SERVICE_DEFINE(
     BT_GATT_CCC(input_ccc_changed, BT_GATT_PERM_READ_ENCRYPT | BT_GATT_PERM_WRITE_ENCRYPT),
     BT_GATT_DESCRIPTOR(BT_UUID_HIDS_REPORT_REF, BT_GATT_PERM_READ_ENCRYPT, read_hids_report_ref,
                        NULL, &input),
+
+    BT_GATT_CHARACTERISTIC(BT_UUID_HIDS_REPORT,
+                           BT_GATT_CHRC_READ | BT_GATT_CHRC_WRITE | BT_GATT_CHRC_WRITE_WITHOUT_RESP,
+                           BT_GATT_PERM_READ_ENCRYPT | BT_GATT_PERM_WRITE_ENCRYPT, NULL,
+                           write_hids_leds_report, NULL),
+    BT_GATT_DESCRIPTOR(BT_UUID_HIDS_REPORT_REF, BT_GATT_PERM_READ_ENCRYPT, read_hids_report_ref,
+                       NULL, &led_indicators),
+
     BT_GATT_CHARACTERISTIC(BT_UUID_HIDS_REPORT, BT_GATT_CHRC_READ | BT_GATT_CHRC_NOTIFY,
                            BT_GATT_PERM_READ_ENCRYPT, read_hids_consumer_input_report, NULL, NULL),
     BT_GATT_CCC(input_ccc_changed, BT_GATT_PERM_READ_ENCRYPT | BT_GATT_PERM_WRITE_ENCRYPT),
@@ -224,7 +264,7 @@ void send_consumer_report_callback(struct k_work *work) {
         }
 
         struct bt_gatt_notify_params notify_params = {
-            .attr = &hog_svc.attrs[10],
+            .attr = &hog_svc.attrs[12],
             .data = &report,
             .len = sizeof(report),
         };