hids.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018 Nordic Semiconductor ASA
 *
 * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
 */
 
#ifndef BT_HIDS_H_
#define BT_HIDS_H_
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <bluetooth/gatt_pool.h>
#include <zephyr/bluetooth/gatt.h>
#include <bluetooth/conn_ctx.h>
 
#ifndef CONFIG_BT_HIDS_INPUT_REP_MAX
#define CONFIG_BT_HIDS_INPUT_REP_MAX 0
#endif
 
#ifndef CONFIG_BT_HIDS_OUTPUT_REP_MAX
#define CONFIG_BT_HIDS_OUTPUT_REP_MAX 0
#endif
 
#ifndef CONFIG_BT_HIDS_FEATURE_REP_MAX
#define CONFIG_BT_HIDS_FEATURE_REP_MAX 0
#endif
 
#define BT_HIDS_BOOT_MOUSE_REP_LEN     3
#define BT_HIDS_BOOT_KB_INPUT_REP_LEN  8
#define BT_HIDS_BOOT_KB_OUTPUT_REP_LEN 1
 
#define BT_HIDS_INFORMATION_LEN 4
 
#define BT_HIDS_SCI_INFORMATION_MAX_GROUPS BT_CONN_LE_MAX_CONN_INTERVAL_GROUPS
 
#define BT_HIDS_SCI_INFORMATION_MAX_LEN (1 + 1 + BT_HIDS_SCI_INFORMATION_MAX_GROUPS * (2 + 2 + 2))
#define BT_HIDS_SCI_INFORMATION_MIN_LEN  2
 
#define BT_HIDS_MAX_MINIMAL_TRANSPORT_INTERVAL_US 1250
 
#define BT_HIDS_DEF(_name, ...)                                        \
        BT_CONN_CTX_DEF(_name,                                                 \
                        CONFIG_BT_HIDS_MAX_CLIENT_COUNT,                       \
                        _BT_HIDS_CONN_CTX_SIZE_CALC(__VA_ARGS__));             \
        static struct bt_hids _name =                                  \
        {                                                                      \
                .gp = BT_GATT_POOL_INIT(CONFIG_BT_HIDS_ATTR_MAX),              \
                .conn_ctx = &_CONCAT(_name, _ctx_lib),                         \
        }
 
 
#define _BT_HIDS_CONN_CTX_SIZE_CALC(...)                   \
        (FOR_EACH(_BT_HIDS_GET_ARG1, (+), __VA_ARGS__)  + \
        sizeof(struct bt_hids_conn_data))
#define _BT_HIDS_GET_ARG1(...) GET_ARG_N(1, __VA_ARGS__)
 
enum bt_hids_pm {
        BT_HIDS_PM_BOOT = 0x00,
        BT_HIDS_PM_REPORT = 0x01
};
 
enum bt_hids_report_type {
        BT_HIDS_REPORT_TYPE_RESERVED = 0x00,
 
        BT_HIDS_REPORT_TYPE_INPUT = 0x01,
 
        BT_HIDS_REPORT_TYPE_OUTPUT = 0x02,
 
        BT_HIDS_REPORT_TYPE_FEATURE = 0x03
};
 
struct bt_hids_info {
        uint16_t bcd_hid;
 
        uint8_t b_country_code;
 
        uint8_t flags;
};
 
enum bt_hids_flags {
        BT_HIDS_REMOTE_WAKE = BIT(0),
        BT_HIDS_NORMALLY_CONNECTABLE = BIT(1),
        BT_HIDS_SCI_SUPPORTED = BIT(2),
        BT_HIDS_SCI_LOW_POWER_MODE_SUPPORTED = BIT(3),
};
 
__deprecated enum bt_hids_control_point {
        BT_HIDS_CONTROL_POINT_SUSPEND = 0x00,
 
        BT_HIDS_CONTROL_POINT_EXIT_SUSPEND = 0x01,
};
 
enum bt_hids_sci_mode_value {
        BT_HIDS_SCI_MODE_NONE = 0x00,
        BT_HIDS_SCI_MODE_DEFAULT = 0x02,
        BT_HIDS_SCI_MODE_FAST = 0x03,
        BT_HIDS_SCI_MODE_LOW_POWER = 0x04,
        BT_HIDS_SCI_MODE_FULL_RANGE = 0x05,
};
 
enum bt_hids_pm_evt {
        BT_HIDS_PM_EVT_BOOT_MODE_ENTERED,
        BT_HIDS_PM_EVT_REPORT_MODE_ENTERED,
};
 
enum bt_hids_cp_evt {
        BT_HIDS_CP_EVT_HOST_SUSP = 0x00,
        BT_HIDS_CP_EVT_HOST_EXIT_SUSP = 0x01,
        BT_HIDS_CP_EVT_HOST_SCI_DEFAULT_REQ = 0x02,
        BT_HIDS_CP_EVT_HOST_SCI_FAST_REQ = 0x03,
        BT_HIDS_CP_EVT_HOST_SCI_LOW_POWER_REQ = 0x04,
        BT_HIDS_CP_EVT_HOST_SCI_FULL_RANGE_REQ = 0x05,
};
 
enum bt_hids_notify_evt {
        BT_HIDS_CCCD_EVT_NOTIFY_ENABLED,
        BT_HIDS_CCCD_EVT_NOTIFY_DISABLED,
};
 
struct bt_hids_rep {
        uint8_t id;
 
        uint8_t *data;
 
        uint8_t size;
};
 
typedef void (*bt_hids_notify_handler_t) (enum bt_hids_notify_evt evt);
 
typedef void (*bt_hids_notify_ext_handler_t) (uint8_t report_id, enum bt_hids_notify_evt evt);
 
typedef void (*bt_hids_rep_handler_t) (struct bt_hids_rep *rep,
                                       struct bt_conn *conn,
                                       bool write);
 
struct bt_hids_inp_rep {
        struct bt_gatt_ccc_managed_user_data ccc;
 
        uint8_t id;
 
        uint8_t idx;
 
        uint8_t att_ind;
 
        uint8_t size;
 
        uint8_t offset;
 
        uint8_t perm;
 
        const uint8_t *rep_mask;
 
        bt_hids_notify_handler_t handler;
 
        bt_hids_notify_ext_handler_t handler_ext;
};
 
 
struct bt_hids_outp_feat_rep {
        uint8_t id;
 
        uint8_t idx;
 
        uint8_t size;
 
        uint8_t offset;
 
        uint8_t att_ind;
 
        uint8_t perm;
 
        bt_hids_rep_handler_t handler;
};
 
struct bt_hids_boot_mouse_inp_rep {
        struct bt_gatt_ccc_managed_user_data ccc;
 
        uint8_t att_ind;
 
        bt_hids_notify_handler_t handler;
};
 
struct bt_hids_boot_kb_inp_rep {
        struct bt_gatt_ccc_managed_user_data ccc;
 
        uint8_t att_ind;
 
        bt_hids_notify_handler_t handler;
};
 
struct bt_hids_boot_kb_outp_rep {
        uint8_t att_ind;
 
        bt_hids_rep_handler_t handler;
};
 
struct bt_hids_inp_rep_group {
        struct bt_hids_inp_rep reports[CONFIG_BT_HIDS_INPUT_REP_MAX];
 
        uint8_t cnt;
};
 
struct bt_hids_outp_rep_group {
        struct bt_hids_outp_feat_rep reports[CONFIG_BT_HIDS_OUTPUT_REP_MAX];
 
        uint8_t cnt;
};
 
struct bt_hids_feat_rep_group {
        struct bt_hids_outp_feat_rep reports[CONFIG_BT_HIDS_FEATURE_REP_MAX];
 
        uint8_t cnt;
};
 
struct bt_hids_rep_map {
        uint8_t const *data;
 
        uint16_t size;
};
 
typedef void (*bt_hids_pm_evt_handler_t) (enum bt_hids_pm_evt evt,
                                          struct bt_conn *conn);
 
 
struct bt_hids_pm_data {
        bt_hids_pm_evt_handler_t evt_handler;
};
 
typedef void (*bt_hids_cp_evt_handler_t) (enum bt_hids_cp_evt evt);
 
typedef void (*bt_hids_conn_cp_evt_handler_t) (enum bt_hids_cp_evt evt, struct bt_conn *conn);
 
struct bt_hids_cp {
        uint8_t value;
 
        bt_hids_cp_evt_handler_t evt_handler;
 
        bt_hids_conn_cp_evt_handler_t conn_evt_handler;
};
 
#if defined(CONFIG_BT_HIDS_SCI)
struct bt_hids_sci_mode_data {
        struct bt_gatt_ccc_managed_user_data ccc;
 
        uint8_t att_ind;
};
#endif /* CONFIG_BT_HIDS_SCI */
 
struct bt_hids_init_param {
        struct bt_hids_info info;
 
        struct bt_hids_inp_rep_group inp_rep_group_init;
 
        struct bt_hids_outp_rep_group outp_rep_group_init;
 
        struct bt_hids_feat_rep_group feat_rep_group_init;
 
        struct bt_hids_rep_map rep_map;
 
        bt_hids_pm_evt_handler_t pm_evt_handler;
 
        bt_hids_cp_evt_handler_t cp_evt_handler;
 
        bt_hids_conn_cp_evt_handler_t conn_cp_evt_handler;
 
        bt_hids_notify_handler_t boot_mouse_notif_handler;
 
        bt_hids_notify_handler_t boot_kb_notif_handler;
 
        bt_hids_rep_handler_t boot_kb_outp_rep_handler;
 
        bool is_mouse;
 
        bool is_kb;
};
 
struct bt_hids {
        struct bt_gatt_pool gp;
 
        struct bt_hids_inp_rep_group inp_rep_group;
 
        struct bt_hids_outp_rep_group outp_rep_group;
 
        struct bt_hids_feat_rep_group feat_rep_group;
 
        struct bt_hids_boot_mouse_inp_rep boot_mouse_inp_rep;
 
        struct bt_hids_boot_kb_inp_rep boot_kb_inp_rep;
 
        struct bt_hids_boot_kb_outp_rep boot_kb_outp_rep;
 
        struct bt_hids_rep_map rep_map;
 
        struct bt_hids_pm_data pm;
 
        struct bt_hids_cp cp;
 
#if defined(CONFIG_BT_HIDS_SCI)
        struct bt_hids_sci_mode_data sci_mode_data;
#endif
        uint8_t info[BT_HIDS_INFORMATION_LEN];
 
        bool is_mouse;
 
        bool is_kb;
 
        struct bt_conn_ctx_lib *conn_ctx;
};
 
struct bt_hids_conn_data {
        uint8_t pm_ctx_value;
 
        uint8_t hids_boot_mouse_inp_rep_ctx[BT_HIDS_BOOT_MOUSE_REP_LEN];
 
        uint8_t hids_boot_kb_inp_rep_ctx[BT_HIDS_BOOT_KB_INPUT_REP_LEN];
 
        uint8_t hids_boot_kb_outp_rep_ctx[BT_HIDS_BOOT_KB_OUTPUT_REP_LEN];
 
        uint8_t *inp_rep_ctx;
 
        uint8_t *outp_rep_ctx;
 
        uint8_t *feat_rep_ctx;
 
#if defined(CONFIG_BT_HIDS_SCI)
        uint8_t sci_mode;
#endif
};
 
 
int bt_hids_init(struct bt_hids *hids_obj,
                 const struct bt_hids_init_param *init_param);
 
int bt_hids_uninit(struct bt_hids *hids_obj);
 
int bt_hids_connected(struct bt_hids *hids_obj, struct bt_conn *conn);
 
int bt_hids_disconnected(struct bt_hids *hids_obj, struct bt_conn *conn);
 
int bt_hids_inp_rep_send_userdata(struct bt_hids *hids_obj, struct bt_conn *conn,
                                  uint8_t rep_index, uint8_t const *rep, uint8_t len,
                                  bt_gatt_complete_func_t cb, void *userdata);
 
static inline int bt_hids_inp_rep_send(struct bt_hids *hids_obj, struct bt_conn *conn,
                                       uint8_t rep_index, uint8_t const *rep, uint8_t len,
                                       bt_gatt_complete_func_t cb)
{
        return bt_hids_inp_rep_send_userdata(hids_obj, conn, rep_index, rep, len, cb, NULL);
}
 
int bt_hids_boot_mouse_inp_rep_send(struct bt_hids *hids_obj,
                                    struct bt_conn *conn,
                                    const uint8_t *buttons,
                                    int8_t x_delta, int8_t y_delta,
                                    bt_gatt_complete_func_t cb);
 
int bt_hids_boot_kb_inp_rep_send(struct bt_hids *hids_obj, struct bt_conn *conn,
                                 uint8_t const *rep, uint16_t len,
                                 bt_gatt_complete_func_t cb);
 
int bt_hids_sci_mode_get(struct bt_conn *conn, enum bt_hids_sci_mode_value *mode);
 
int bt_hids_sci_mode_change_request(struct bt_conn *conn,
                                    enum bt_hids_sci_mode_value mode);
 
bool bt_hids_sci_mode_validate(enum bt_hids_sci_mode_value mode,
                               const struct bt_conn_le_conn_rate_changed *params);
 
int bt_hids_sci_mode_updated(struct bt_conn *conn, enum bt_hids_sci_mode_value mode);
 
#ifdef __cplusplus
}
#endif
 
#endif /* BT_HIDS_H_ */