/* * Copyright (c) 2020 The ZMK Contributors * * SPDX-License-Identifier: MIT */ #include #include #include LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL); #include #include #include #include #include enum { HIDS_REMOTE_WAKE = BIT(0), HIDS_NORMALLY_CONNECTABLE = BIT(1), }; struct hids_info { uint16_t version; /* version number of base USB HID Specification */ uint8_t code; /* country HID Device hardware is localized for. */ uint8_t flags; } __packed; struct hids_report { uint8_t id; /* report id */ uint8_t type; /* report type */ } __packed; static struct hids_info info = { .version = 0x0000, .code = 0x00, .flags = HIDS_NORMALLY_CONNECTABLE | HIDS_REMOTE_WAKE, }; enum { HIDS_INPUT = 0x01, HIDS_OUTPUT = 0x02, HIDS_FEATURE = 0x03, }; static struct hids_report input = { .id = 0x01, .type = HIDS_INPUT, }; static struct hids_report consumer_input = { .id = 0x02, .type = HIDS_INPUT, }; static bool host_requests_notification = false; static uint8_t ctrl_point; // static uint8_t proto_mode; static ssize_t read_hids_info(struct bt_conn *conn, const struct bt_gatt_attr *attr, void *buf, uint16_t len, uint16_t offset) { return bt_gatt_attr_read(conn, attr, buf, len, offset, attr->user_data, sizeof(struct hids_info)); } static ssize_t read_hids_report_ref(struct bt_conn *conn, const struct bt_gatt_attr *attr, void *buf, uint16_t len, uint16_t offset) { return bt_gatt_attr_read(conn, attr, buf, len, offset, attr->user_data, sizeof(struct hids_report)); } static ssize_t read_hids_report_map(struct bt_conn *conn, const struct bt_gatt_attr *attr, void *buf, uint16_t len, uint16_t offset) { return bt_gatt_attr_read(conn, attr, buf, len, offset, zmk_hid_report_desc, sizeof(zmk_hid_report_desc)); } static ssize_t read_hids_input_report(struct bt_conn *conn, const struct bt_gatt_attr *attr, void *buf, uint16_t len, uint16_t offset) { struct zmk_hid_keyboard_report_body *report_body = &zmk_hid_get_keyboard_report()->body; return bt_gatt_attr_read(conn, attr, buf, len, offset, report_body, sizeof(struct zmk_hid_keyboard_report_body)); } 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) { struct zmk_hid_consumer_report_body *report_body = &zmk_hid_get_consumer_report()->body; return bt_gatt_attr_read(conn, attr, buf, len, offset, report_body, sizeof(struct zmk_hid_consumer_report_body)); } // static ssize_t write_proto_mode(struct bt_conn *conn, // const struct bt_gatt_attr *attr, // const void *buf, uint16_t len, uint16_t offset, // uint8_t flags) // { // printk("PROTO CHANGED\n"); // return 0; // } static void input_ccc_changed(const struct bt_gatt_attr *attr, uint16_t value) { host_requests_notification = (value == BT_GATT_CCC_NOTIFY) ? 1 : 0; } static ssize_t write_ctrl_point(struct bt_conn *conn, const struct bt_gatt_attr *attr, const void *buf, uint16_t len, uint16_t offset, uint8_t flags) { uint8_t *value = attr->user_data; if (offset + len > sizeof(ctrl_point)) { return BT_GATT_ERR(BT_ATT_ERR_INVALID_OFFSET); } memcpy(value + offset, buf, len); return len; } /* HID Service Declaration */ BT_GATT_SERVICE_DEFINE( hog_svc, BT_GATT_PRIMARY_SERVICE(BT_UUID_HIDS), // BT_GATT_CHARACTERISTIC(BT_UUID_HIDS_PROTOCOL_MODE, BT_GATT_CHRC_WRITE_WITHOUT_RESP, // BT_GATT_PERM_WRITE, NULL, write_proto_mode, &proto_mode), BT_GATT_CHARACTERISTIC(BT_UUID_HIDS_INFO, BT_GATT_CHRC_READ, BT_GATT_PERM_READ, read_hids_info, NULL, &info), BT_GATT_CHARACTERISTIC(BT_UUID_HIDS_REPORT_MAP, BT_GATT_CHRC_READ, BT_GATT_PERM_READ_ENCRYPT, read_hids_report_map, NULL, NULL), BT_GATT_CHARACTERISTIC(BT_UUID_HIDS_REPORT, BT_GATT_CHRC_READ | BT_GATT_CHRC_NOTIFY, BT_GATT_PERM_READ_ENCRYPT, read_hids_input_report, NULL, NULL), 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_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), BT_GATT_DESCRIPTOR(BT_UUID_HIDS_REPORT_REF, BT_GATT_PERM_READ_ENCRYPT, read_hids_report_ref, NULL, &consumer_input), BT_GATT_CHARACTERISTIC(BT_UUID_HIDS_CTRL_POINT, BT_GATT_CHRC_WRITE_WITHOUT_RESP, BT_GATT_PERM_WRITE, NULL, write_ctrl_point, &ctrl_point)); struct bt_conn *destination_connection() { struct bt_conn *conn; bt_addr_le_t *addr = zmk_ble_active_profile_addr(); LOG_DBG("Address pointer %p", addr); if (!bt_addr_le_cmp(addr, BT_ADDR_LE_ANY)) { LOG_WRN("Not sending, no active address for current profile"); return NULL; } else if ((conn = bt_conn_lookup_addr_le(BT_ID_DEFAULT, addr)) == NULL) { LOG_WRN("Not sending, not connected to active profile"); return NULL; } return conn; } K_THREAD_STACK_DEFINE(hog_q_stack, CONFIG_ZMK_BLE_THREAD_STACK_SIZE); struct k_work_q hog_work_q; K_MSGQ_DEFINE(zmk_hog_keyboard_msgq, sizeof(struct zmk_hid_keyboard_report_body), CONFIG_ZMK_BLE_KEYBOARD_REPORT_QUEUE_SIZE, 4); void send_keyboard_report_callback(struct k_work *work) { struct zmk_hid_keyboard_report_body report; while (k_msgq_get(&zmk_hog_keyboard_msgq, &report, K_NO_WAIT) == 0) { struct bt_conn *conn = destination_connection(); if (conn == NULL) { return; } struct bt_gatt_notify_params notify_params = { .attr = &hog_svc.attrs[5], .data = &report, .len = sizeof(report), }; int err = bt_gatt_notify_cb(conn, ¬ify_params); if (err) { LOG_ERR("Error notifying %d", err); } bt_conn_unref(conn); } } K_WORK_DEFINE(hog_keyboard_work, send_keyboard_report_callback); int zmk_hog_send_keyboard_report(struct zmk_hid_keyboard_report_body *report) { int err = k_msgq_put(&zmk_hog_keyboard_msgq, report, K_MSEC(100)); if (err) { switch (err) { case -EAGAIN: { LOG_WRN("Keyboard message queue full, popping first message and queueing again"); struct zmk_hid_keyboard_report_body discarded_report; k_msgq_get(&zmk_hog_keyboard_msgq, &discarded_report, K_NO_WAIT); return zmk_hog_send_keyboard_report(report); } default: LOG_WRN("Failed to queue keyboard report to send (%d)", err); return err; } } k_work_submit_to_queue(&hog_work_q, &hog_keyboard_work); return 0; }; K_MSGQ_DEFINE(zmk_hog_consumer_msgq, sizeof(struct zmk_hid_consumer_report_body), CONFIG_ZMK_BLE_CONSUMER_REPORT_QUEUE_SIZE, 4); void send_consumer_report_callback(struct k_work *work) { struct zmk_hid_consumer_report_body report; while (k_msgq_get(&zmk_hog_consumer_msgq, &report, K_NO_WAIT) == 0) { struct bt_conn *conn = destination_connection(); if (conn == NULL) { return; } struct bt_gatt_notify_params notify_params = { .attr = &hog_svc.attrs[10], .data = &report, .len = sizeof(report), }; int err = bt_gatt_notify_cb(conn, ¬ify_params); if (err) { LOG_DBG("Error notifying %d", err); } bt_conn_unref(conn); } }; K_WORK_DEFINE(hog_consumer_work, send_consumer_report_callback); int zmk_hog_send_consumer_report(struct zmk_hid_consumer_report_body *report) { int err = k_msgq_put(&zmk_hog_consumer_msgq, report, K_MSEC(100)); if (err) { switch (err) { case -EAGAIN: { LOG_WRN("Consumer message queue full, popping first message and queueing again"); struct zmk_hid_consumer_report_body discarded_report; k_msgq_get(&zmk_hog_consumer_msgq, &discarded_report, K_NO_WAIT); return zmk_hog_send_consumer_report(report); } default: LOG_WRN("Failed to queue consumer report to send (%d)", err); return err; } } k_work_submit_to_queue(&hog_work_q, &hog_consumer_work); return 0; }; int zmk_hog_init(const struct device *_arg) { static const struct k_work_queue_config queue_config = {.name = "HID Over GATT Send Work"}; k_work_queue_start(&hog_work_q, hog_q_stack, K_THREAD_STACK_SIZEOF(hog_q_stack), CONFIG_ZMK_BLE_THREAD_PRIORITY, &queue_config); return 0; } SYS_INIT(zmk_hog_init, APPLICATION, CONFIG_ZMK_BLE_INIT_PRIORITY);