kb01/zmk
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

cherry pick and refactor from #999 by @bortoz

Browse source
This commit is contained in:
snoyer 2022-10-07 17:27:19 +04:00
parent 605d88f266
commit f906d740ac
12 changed files with 261 additions and 6 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
app/CMakeLists.txt
View file

@ -63,6 +63,8 @@ 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/events/led_indicator_changed.c)
target_sources(app PRIVATE src/led_indicators_generic.c)
if (CONFIG_ZMK_BLE)
target_sources(app PRIVATE src/events/ble_active_profile_changed.c)

1
app/include/zmk/ble.h
View file

@ -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();

16
app/include/zmk/events/led_indicator_changed.h Normal file
View file

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

34
app/include/zmk/hid.h
View file

@ -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];
@ -136,6 +163,9 @@ int zmk_hid_unregister_mods(zmk_mod_flags_t explicit_modifiers);
int zmk_hid_implicit_modifiers_press(zmk_mod_flags_t implicit_modifiers);
int zmk_hid_implicit_modifiers_release();
int zmk_hid_masked_modifiers_set(zmk_mod_flags_t masked_modifiers);
int zmk_hid_masked_modifiers_clear();
int zmk_hid_keyboard_press(zmk_key_t key);
int zmk_hid_keyboard_release(zmk_key_t key);
void zmk_hid_keyboard_clear();

26
app/include/zmk/led_indicators.h Normal file
View file

@ -0,0 +1,26 @@
/*
* Copyright (c) 2022 The ZMK Contributors
*
* SPDX-License-Identifier: MIT
*/
#pragma once
#include <zmk/endpoints_types.h>
#include <zmk/hid.h>
#include <zmk/led_indicators_types.h>
#define ZMK_LED_INDICATORS_NUMLOCK_BIT BIT(0)
#define ZMK_LED_INDICATORS_CAPSLOCK_BIT BIT(1)
#define ZMK_LED_INDICATORS_SCROLLLOCK_BIT BIT(2)
#define ZMK_LED_INDICATORS_COMPOSE_BIT BIT(3)
#define ZMK_LED_INDICATORS_KANA_BIT BIT(4)
zmk_led_indicators_flags_t zmk_led_indicators_get_current_flags();
zmk_led_indicators_flags_t zmk_led_indicators_get_flags(enum zmk_endpoint endpoint,
uint8_t profile);
void zmk_led_indicators_update_flags(zmk_led_indicators_flags_t leds, enum zmk_endpoint endpoint,
uint8_t profile);
void zmk_led_indicators_process_report(struct zmk_hid_led_report_body *report,
enum zmk_endpoint endpoint, uint8_t profile);

9
app/include/zmk/led_indicators_types.h Normal file
View file

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

9
app/src/ble.c
View file

@ -227,6 +227,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));

10
app/src/events/led_indicator_changed.c Normal file
View file

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

5
app/src/hid.c
View file

@ -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.

38
app/src/hog.c
View file

@ -15,8 +15,10 @@ LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
#include <bluetooth/gatt.h>
#include <zmk/ble.h>
#include <zmk/endpoints_types.h>
#include <zmk/hog.h>
#include <zmk/hid.h>
#include <zmk/led_indicators.h>
enum {
HIDS_REMOTE_WAKE = BIT(0),
@ -47,12 +49,19 @@ 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,
.type = HIDS_INPUT,
};
@ -85,6 +94,27 @@ 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 (flags & BT_GATT_WRITE_FLAG_PREPARE) {
return 0;
}
if (len != sizeof(struct zmk_hid_led_report_body)) {
LOG_ERR("LED report is malformed: length=%d", len);
return BT_GATT_ERR(BT_ATT_ERR_INVALID_ATTRIBUTE_LEN);
}
struct zmk_hid_led_report_body *report =
(struct zmk_hid_led_report_body *)((uint8_t *)buf + offset);
uint8_t profile = zmk_ble_profile_index(bt_conn_get_dst(conn));
zmk_led_indicators_process_report(report, ZMK_ENDPOINT_BLE, profile);
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 +164,10 @@ 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_WRITE_WITHOUT_RESP,
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 +258,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),
};

83
app/src/led_indicators_generic.c Normal file
View file

@ -0,0 +1,83 @@
/*
* Copyright (c) 2022 The ZMK Contributors
*
* SPDX-License-Identifier: MIT
*/
#include <kernel.h>
#include <logging/log.h>
#include <zmk/ble.h>
#include <zmk/endpoints.h>
#include <zmk/led_indicators.h>
#include <zmk/events/led_indicator_changed.h>
#include <zmk/events/endpoint_selection_changed.h>
LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
#define NUM_USB_PROFILES (COND_CODE_1(IS_ENABLED(CONFIG_ZMK_USB), (1), (0)))
#define NUM_BLE_PROFILES (COND_CODE_1(IS_ENABLED(CONFIG_ZMK_BLE), (CONFIG_BT_MAX_CONN), (0)))
#define NUM_PROFILES (NUM_USB_PROFILES + NUM_BLE_PROFILES)
static zmk_led_indicators_flags_t led_flags[NUM_PROFILES];
static size_t profile_index(enum zmk_endpoint endpoint, uint8_t profile) {
switch (endpoint) {
case ZMK_ENDPOINT_USB:
return 0;
case ZMK_ENDPOINT_BLE:
return NUM_USB_PROFILES + profile;
}
CODE_UNREACHABLE;
}
zmk_led_indicators_flags_t zmk_led_indicators_get_current_flags() {
enum zmk_endpoint endpoint = zmk_endpoints_selected();
uint8_t profile = 0;
#if IS_ENABLED(CONFIG_ZMK_BLE)
if (endpoint == ZMK_ENDPOINT_USB) {
profile = zmk_ble_active_profile_index();
}
#endif
return zmk_led_indicators_get_flags(endpoint, profile);
}
zmk_led_indicators_flags_t zmk_led_indicators_get_flags(enum zmk_endpoint endpoint,
uint8_t profile) {
size_t index = profile_index(endpoint, profile);
return led_flags[index];
}
static void raise_led_indicators_changed_event(struct k_work *_work) {
ZMK_EVENT_RAISE(new_zmk_led_indicators_changed(
(struct zmk_led_indicators_changed){.leds = zmk_led_indicators_get_current_flags()}));
}
static K_WORK_DEFINE(led_changed_work, raise_led_indicators_changed_event);
void zmk_led_indicators_update_flags(zmk_led_indicators_flags_t leds, enum zmk_endpoint endpoint,
uint8_t profile) {
size_t index = profile_index(endpoint, profile);
led_flags[index] = leds;
k_work_submit(&led_changed_work);
}
void zmk_led_indicators_process_report(struct zmk_hid_led_report_body *report,
enum zmk_endpoint endpoint, uint8_t profile) {
zmk_led_indicators_flags_t leds = report->leds;
zmk_led_indicators_update_flags(leds, endpoint, profile);
LOG_DBG("Update LED indicators: endpoint=%d, profile=%d, flags=%x", endpoint, profile, leds);
}
static int endpoint_listener(const zmk_event_t *eh) {
raise_led_indicators_changed_event(NULL);
return 0;
}
static ZMK_LISTENER(endpoint_listener, endpoint_listener);
static ZMK_SUBSCRIPTION(endpoint_listener, zmk_endpoint_selection_changed);

34
app/src/usb_hid.c
View file

@ -13,6 +13,7 @@
#include <zmk/usb.h>
#include <zmk/hid.h>
#include <zmk/keymap.h>
#include <zmk/led_indicators.h>
#include <zmk/event_manager.h>
LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
@ -23,8 +24,41 @@ static K_SEM_DEFINE(hid_sem, 1, 1);
static void in_ready_cb(const struct device *dev) { k_sem_give(&hid_sem); }
#define HID_GET_REPORT_TYPE_MASK 0xff00
#define HID_GET_REPORT_ID_MASK 0x00ff
#define HID_REPORT_TYPE_INPUT 0x100
#define HID_REPORT_TYPE_OUTPUT 0x200
#define HID_REPORT_TYPE_FEATURE 0x300
static int set_report_cb(const struct device *dev, struct usb_setup_packet *setup, int32_t *len,
uint8_t **data) {
if ((setup->wValue & HID_GET_REPORT_TYPE_MASK) != HID_REPORT_TYPE_OUTPUT) {
LOG_ERR("Unsupported report type %d requested",
(setup->wValue & HID_GET_REPORT_TYPE_MASK) >> 8);
return -ENOTSUP;
}
switch (setup->wValue & HID_GET_REPORT_ID_MASK) {
case HID_REPORT_ID_LEDS:
if (*len != sizeof(struct zmk_hid_led_report)) {
LOG_ERR("LED set report is malformed: length=%d", *len);
} else {
struct zmk_hid_led_report *report = (struct zmk_hid_led_report *)*data;
zmk_led_indicators_process_report(&report->body, ZMK_ENDPOINT_USB, 0);
}
break;
default:
LOG_ERR("Invalid report ID %d requested", setup->wValue & HID_GET_REPORT_ID_MASK);
return -EINVAL;
}
return 0;
}
static const struct hid_ops ops = {
.int_in_ready = in_ready_cb,
.set_report = set_report_cb,
};
int zmk_usb_hid_send_report(const uint8_t *report, size_t len) {