kkkjtr
/
bleSDK_expansion_board
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
bleSDK_expansion_board/ble/prf/prf_hids.c

928 lines
30 KiB
C
Raw Blame History

/**
****************************************************************************************
*
* @file prf_hids.c
*
* @brief HID Service Profile - Template Source.
*
* < Implementation according to user's application-specific >
****************************************************************************************
*/
#if (PRF_HIDS)
/*
* INCLUDE FILES
****************************************************************************************
*/
#include "prf.h"
#include "hid_desc.h" // application-specific, #include "prf_hids.h"
#if (DBG_HIDS)
#include "dbg.h"
#define DEBUG(format, ...) debug("<%s,%d>" format "\r\n", __MODULE__, __LINE__, ##__VA_ARGS__)
#else
#define DEBUG(format, ...)
#define debugHex(dat,len)
#endif
/*
* DEFINITIONS
****************************************************************************************
*/
/// Support Boot Protocol Mode or Not
#if !defined(HID_BOOT_SUP)
#define HID_BOOT_SUP (0)
#define HID_BOOT_KB (0)
#define HID_BOOT_MOUSE (0)
#endif
/// Support Report Protocol Mode or Not
#if !defined(HID_REPORT_SUP)
#define HID_REPORT_SUP (1)
#define HID_RPT_KB (1)
#define HID_RPT_MEDIA (1)
#define HID_RPT_SYSTEM (1)
#define HID_RPT_MOUSE (1)
#define HID_RPT_PTP (0)
#endif
/// Support Number of HID Connections
#if !defined(HID_CONN_MAX)
#define HID_CONN_MAX (1) // always one, BLE_CONNECTION_MAX
#endif
/// Macro for Client Config value operation
#define HID_RPT_NTF_GET(conidx, ntf_idx) \
((hids_env.conn[conidx].rpt_ntfs >> (ntf_idx)) & PRF_CLI_START_NTF)
#define HID_RPT_NTF_CLR(conidx, ntf_idx) \
hids_env.conn[conidx].rpt_ntfs &= ~(PRF_CLI_START_NTF << (ntf_idx))
#define HID_RPT_NTF_SET(conidx, ntf_idx, conf) \
hids_env.conn[conidx].rpt_ntfs = (hids_env.conn[conidx].rpt_ntfs & ~(PRF_CLI_START_NTF << (ntf_idx))) | ((conf) << (ntf_idx))
/**
****************************************************************************************
* @section ENVIRONMENT DEFINITION
****************************************************************************************
*/
typedef struct hid_conn_tag
{
// Client Config of peer devices, max_bits=RPT_IDX_NB
uint8_t rpt_ntfs;
// keyboard Locks (bit0:num lock, bit1:caps lock, bit2:scroll lock)
uint8_t led_lock;
// Control Point key @see enum hid_ctrl_pt
uint8_t ctrl_pt;
// Boot or Report mode, @see enum hid_proto_mode
uint8_t proto_mode;
} hid_conn_t;
/// HIDS Server Environment Sariable
typedef struct hids_env_tag
{
// Service Start Handle
uint16_t start_hdl;
// Number of notify pkt
uint8_t nb_pkt;
// Connection Info
hid_conn_t conn[HID_CONN_MAX];
} hids_env_t;
/// Global Variable Declarations
__VAR_ENV hids_env_t hids_env;
/**
****************************************************************************************
* @section ATTRIBUTES DEFINITION
****************************************************************************************
*/
/// HID Attributes Index
enum hid_att_idx
{
// Service Declaration, *MUST* Start at 0
HID_IDX_SVC,
// HID Information
HID_IDX_HID_INFO_CHAR,
HID_IDX_HID_INFO_VAL,
// HID Control Point
HID_IDX_HID_CTRL_PT_CHAR,
HID_IDX_HID_CTRL_PT_VAL,
// Report Map
HID_IDX_REPORT_MAP_CHAR, //5
HID_IDX_REPORT_MAP_VAL,
#if (HID_BOOT_SUP)
// Protocol Mode(0-BOOT, 1-REPORT)
HID_IDX_PROTO_MODE_CHAR,
HID_IDX_PROTO_MODE_VAL,
#if (HID_BOOT_KB)
// Boot Keyboard Input Report
HID_IDX_BOOT_KB_IN_RPT_CHAR,
HID_IDX_BOOT_KB_IN_RPT_VAL, //10
HID_IDX_BOOT_KB_IN_RPT_NTF_CFG,
// Boot Keyboard Output Report
HID_IDX_BOOT_KB_OUT_RPT_CHAR,
HID_IDX_BOOT_KB_OUT_RPT_VAL,
#endif //(HID_BOOT_KB)
#if (HID_BOOT_MOUSE)
// Boot Mouse Input Report
HID_IDX_BOOT_MOUSE_IN_RPT_CHAR,
HID_IDX_BOOT_MOUSE_IN_RPT_VAL, //15
HID_IDX_BOOT_MOUSE_IN_RPT_NTF_CFG,
#endif //(HID_BOOT_MOUSE)
#endif //(HID_BOOT_SUP)
#if (HID_REPORT_SUP)
#if (HID_RPT_KB)
// Keyboard Report IN
HID_IDX_KB_IN_RPT_CHAR,
HID_IDX_KB_IN_RPT_VAL,
HID_IDX_KB_IN_RPT_REF,
HID_IDX_KB_IN_RPT_NTF_CFG, //20
// Keyboard Report OUT
HID_IDX_KB_OUT_RPT_CHAR,
HID_IDX_KB_OUT_RPT_VAL,
HID_IDX_KB_OUT_RPT_REF,
#endif //(HID_RPT_KB)
#if (HID_RPT_MEDIA)
// Media IN Report
HID_IDX_MEDIA_IN_RPT_CHAR,
HID_IDX_MEDIA_IN_RPT_VAL, //25
HID_IDX_MEDIA_IN_RPT_REF,
HID_IDX_MEDIA_IN_RPT_NTF_CFG,
#endif //(HID_RPT_MEDIA)
#if (HID_RPT_SYSTEM)
// System IN Report
HID_IDX_SYS_IN_RPT_CHAR,
HID_IDX_SYS_IN_RPT_VAL,
HID_IDX_SYS_IN_RPT_REF, //30
HID_IDX_SYS_IN_RPT_NTF_CFG,
#endif //(HID_RPT_SYSTEM)
#if (HID_RPT_MOUSE)
// Mouse IN Report
HID_IDX_MOUSE_IN_RPT_CHAR,
HID_IDX_MOUSE_IN_RPT_VAL,
HID_IDX_MOUSE_IN_RPT_REF,
HID_IDX_MOUSE_IN_RPT_NTF_CFG, //35
#endif //(HID_RPT_MOUSE)
#if (HID_RPT_PTP)
// TouchPad IN Report
HID_IDX_TP_IN_RPT_CHAR,
HID_IDX_TP_IN_RPT_VAL,
HID_IDX_TP_IN_RPT_REF,
HID_IDX_TP_IN_RPT_NTF_CFG,
// MaxCnt FEAT Report
HID_IDX_MAXCNT_FEAT_RPT_CHAR, //40
HID_IDX_MAXCNT_FEAT_RPT_VAL,
HID_IDX_MAXCNT_FEAT_RPT_REF,
// PTPHQA FEAT Report
HID_IDX_PTPHQA_FEAT_RPT_CHAR,
HID_IDX_PTPHQA_FEAT_RPT_VAL,
HID_IDX_PTPHQA_FEAT_RPT_REF, //45
#endif //(HID_RPT_PTP)
#endif //(HID_REPORT_SUP)
// Max Index, *NOTE* Minus 1(Svc Decl) is .nb_att
HID_IDX_NB,
};
/// Attributes Description
const att_decl_t hid_atts[] =
{
// HID Information Char. Declaration and Value
ATT_ELMT_DECL_CHAR( HID_IDX_HID_INFO_CHAR ),
ATT_ELMT( HID_IDX_HID_INFO_VAL, ATT_CHAR_HID_INFO, PROP_RD, HID_INFO_SIZE ),
// HID Control Point Char. Declaration
ATT_ELMT_DECL_CHAR( HID_IDX_HID_CTRL_PT_CHAR ),
ATT_ELMT( HID_IDX_HID_CTRL_PT_VAL, ATT_CHAR_HID_CTRL_PT, PROP_WC, HID_CTRL_PT_SIZE ),
// Report Map Char. Declaration and Value
ATT_ELMT_DECL_CHAR( HID_IDX_REPORT_MAP_CHAR ),
ATT_ELMT( HID_IDX_REPORT_MAP_VAL, ATT_CHAR_REPORT_MAP, PROP_RD, 0 ),
#if (HID_BOOT_SUP)
// Protocol Mode Char. Declaration and Value
ATT_ELMT_DECL_CHAR( HID_IDX_PROTO_MODE_CHAR ),
ATT_ELMT( HID_IDX_PROTO_MODE_VAL, ATT_CHAR_PROTOCOL_MODE, PROP_RD | PROP_WC, HID_PROTO_MODE_SIZE ),
#if (HID_BOOT_KB)
// Boot Keyboard Input Report Char. Declaration and Value and CCC Descriptor
ATT_ELMT_DECL_CHAR( HID_IDX_BOOT_KB_IN_RPT_CHAR ),
ATT_ELMT( HID_IDX_BOOT_KB_IN_RPT_VAL, ATT_CHAR_BOOT_KB_IN_REPORT, PROP_RD | PROP_NTF, HID_BOOT_REPORT_MAX_LEN ),
ATT_ELMT_DESC_CLI_CHAR_CFG( HID_IDX_BOOT_KB_IN_RPT_NTF_CFG ),
// Boot Keyboard Output Report Char. Declaration and Value
ATT_ELMT_DECL_CHAR( HID_IDX_BOOT_KB_OUT_RPT_CHAR ),
ATT_ELMT( HID_IDX_BOOT_KB_OUT_RPT_VAL, ATT_CHAR_BOOT_KB_OUT_REPORT, PROP_RD | PROP_WR | PROP_WC, HID_BOOT_REPORT_MAX_LEN ),
#endif //(HID_BOOT_KB)
#if (HID_BOOT_MOUSE)
// Boot Mouse Input Report Char. Declaration and Value and CCC Descriptor
ATT_ELMT_DECL_CHAR( HID_IDX_BOOT_MOUSE_IN_RPT_CHAR ),
ATT_ELMT( HID_IDX_BOOT_MOUSE_IN_RPT_VAL, ATT_CHAR_BOOT_MOUSE_IN_REPORT, PROP_RD | PROP_NTF, HID_BOOT_REPORT_MAX_LEN ),
ATT_ELMT_DESC_CLI_CHAR_CFG( HID_IDX_BOOT_MOUSE_IN_RPT_NTF_CFG ),
#endif //(HID_BOOT_MOUSE)
#endif //(HID_BOOT_SUP)
#if (HID_REPORT_SUP)
#if (HID_RPT_KB)
// Keyboard IN Report Char. Declaration and Value, Report Ref. and CCC Descriptor
ATT_ELMT_DECL_CHAR( HID_IDX_KB_IN_RPT_CHAR ),
ATT_ELMT( HID_IDX_KB_IN_RPT_VAL, ATT_CHAR_REPORT, PROP_RD | PROP_NTF, HID_REPORT_MAX_LEN ),
ATT_ELMT_DESC_REPORT_REF( HID_IDX_KB_IN_RPT_REF ),
ATT_ELMT_DESC_CLI_CHAR_CFG( HID_IDX_KB_IN_RPT_NTF_CFG ),
// Keyboard OUT Report Char. Declaration and Value, Report Ref. Descriptor
ATT_ELMT_DECL_CHAR( HID_IDX_KB_OUT_RPT_CHAR ),
// Report Characteristic Value
ATT_ELMT( HID_IDX_KB_OUT_RPT_VAL, ATT_CHAR_REPORT, PROP_RD | PROP_WR | PROP_WC, HID_REPORT_MAX_LEN ),
// Report Characteristic - Report Reference Descriptor
ATT_ELMT_DESC_REPORT_REF( HID_IDX_KB_OUT_RPT_REF ),
#endif //(HID_RPT_KB)
#if (HID_RPT_MEDIA)
// Media IN Report Char. Declaration and Value, Report Ref. and CCC Descriptor
ATT_ELMT_DECL_CHAR( HID_IDX_MEDIA_IN_RPT_CHAR ),
ATT_ELMT( HID_IDX_MEDIA_IN_RPT_VAL, ATT_CHAR_REPORT, PROP_RD | PROP_NTF, HID_REPORT_MAX_LEN ),
ATT_ELMT_DESC_REPORT_REF( HID_IDX_MEDIA_IN_RPT_REF ),
ATT_ELMT_DESC_CLI_CHAR_CFG( HID_IDX_MEDIA_IN_RPT_NTF_CFG ),
#endif //(HID_RPT_MEDIA)
#if (HID_RPT_SYSTEM)
// System IN Report Char. Declaration and Value, Report Ref. and CCC Descriptor
ATT_ELMT_DECL_CHAR( HID_IDX_SYS_IN_RPT_CHAR ),
ATT_ELMT( HID_IDX_SYS_IN_RPT_VAL, ATT_CHAR_REPORT, PROP_RD | PROP_NTF, HID_REPORT_MAX_LEN ),
ATT_ELMT_DESC_REPORT_REF( HID_IDX_SYS_IN_RPT_REF ),
ATT_ELMT_DESC_CLI_CHAR_CFG( HID_IDX_SYS_IN_RPT_NTF_CFG ),
#endif //(HID_RPT_SYSTEM)
#if (HID_RPT_MOUSE)
// Mouse IN Report Char. Declaration and Value, Report Ref. and CCC Descriptor
ATT_ELMT_DECL_CHAR( HID_IDX_MOUSE_IN_RPT_CHAR ),
ATT_ELMT( HID_IDX_MOUSE_IN_RPT_VAL, ATT_CHAR_REPORT, PROP_RD | PROP_NTF, HID_REPORT_MAX_LEN ),
ATT_ELMT_DESC_REPORT_REF( HID_IDX_MOUSE_IN_RPT_REF ),
ATT_ELMT_DESC_CLI_CHAR_CFG( HID_IDX_MOUSE_IN_RPT_NTF_CFG ),
#endif //(HID_RPT_MOUSE)
#if (HID_RPT_PTP)
// TouchPad IN Report Char. Declaration and Value, Report Ref. and CCC Descriptor
ATT_ELMT_DECL_CHAR( HID_IDX_TP_IN_RPT_CHAR ),
ATT_ELMT( HID_IDX_TP_IN_RPT_VAL, ATT_CHAR_REPORT, PROP_RD | PROP_NTF, HID_REPORT_MAX_LEN ),
ATT_ELMT_DESC_REPORT_REF( HID_IDX_TP_IN_RPT_REF ),
ATT_ELMT_DESC_CLI_CHAR_CFG( HID_IDX_TP_IN_RPT_NTF_CFG ),
// Max Count Feature Report Char. Declaration and Value, Report Ref. Descriptor
ATT_ELMT_DECL_CHAR( HID_IDX_MAXCNT_FEAT_RPT_CHAR ),
ATT_ELMT( HID_IDX_MAXCNT_FEAT_RPT_VAL, ATT_CHAR_REPORT, PROP_RD | PROP_WR, HID_REPORT_MAX_LEN ),
ATT_ELMT_DESC_REPORT_REF( HID_IDX_MAXCNT_FEAT_RPT_REF ),
// PTPHQA Feature Report Char. Declaration and Value, Report Ref. Descriptor
ATT_ELMT_DECL_CHAR( HID_IDX_PTPHQA_FEAT_RPT_CHAR ),
ATT_ELMT( HID_IDX_PTPHQA_FEAT_RPT_VAL, ATT_CHAR_REPORT, PROP_RD | PROP_WR, HID_REPORT_MAX_LEN ),
ATT_ELMT_DESC_REPORT_REF( HID_IDX_PTPHQA_FEAT_RPT_REF ),
#endif //(HID_RPT_PTP)
#endif //(HID_REPORT_SUP)
};
/// Service Description
const struct svc_decl hid_svc_db =
{
.uuid = ATT_SVC_HID,
.info = SVC_UUID(16) | SVC_SEC(UNAUTH),
.atts = hid_atts,
.nb_att = HID_IDX_NB - 1,
};
/*
* FUNCTION DECLARATIONS
****************************************************************************************
*/
/**
****************************************************************************************
* @section SVC FUNCTIONS
****************************************************************************************
*/
/// Retrieve attribute index form handle
static uint8_t hids_get_att_idx(uint16_t handle)
{
ASSERT_ERR((handle >= hids_env.start_hdl) && (handle < hids_env.start_hdl + HID_IDX_NB));
return (handle - hids_env.start_hdl);
}
/// Retrieve Report attribute handle from rpt_idx (@see rpt_ntf_idx) or ATT_INVALID_HDL
static uint16_t hids_get_rpt_handle(uint8_t rpt_idx)
{
uint8_t att_idx = 0;
switch (rpt_idx)
{
#if (HID_BOOT_SUP)
#if (HID_BOOT_KB)
case RPT_IDX_BOOT_KB:
{
att_idx = HID_IDX_BOOT_KB_IN_RPT_VAL;
} break;
#endif //(HID_BOOT_KB)
#if (HID_BOOT_MOUSE)
case RPT_IDX_BOOT_MOUSE:
{
att_idx = HID_IDX_BOOT_MOUSE_IN_RPT_VAL;
} break;
#endif //(HID_BOOT_MOUSE)
#endif //(HID_BOOT_SUP)
#if (HID_REPORT_SUP)
#if (HID_RPT_KB)
case RPT_IDX_KB:
{
att_idx = HID_IDX_KB_IN_RPT_VAL;
} break;
#endif //(HID_RPT_KB)
#if (HID_RPT_MEDIA)
case RPT_IDX_MEDIA:
{
att_idx = HID_IDX_MEDIA_IN_RPT_VAL;
} break;
#endif //(HID_RPT_MEDIA)
#if (HID_RPT_SYSTEM)
case RPT_IDX_SYSTEM:
{
att_idx = HID_IDX_SYS_IN_RPT_VAL;
} break;
#endif //(HID_RPT_SYSTEM)
#if (HID_RPT_MOUSE)
case RPT_IDX_MOUSE:
{
att_idx = HID_IDX_MOUSE_IN_RPT_VAL;
} break;
#endif //(HID_RPT_MOUSE)
#if (HID_RPT_PTP)
case RPT_IDX_TP:
{
att_idx = HID_IDX_TP_IN_RPT_VAL;
} break;
#endif //(HID_RPT_PTP)
#endif //(HID_REPORT_SUP)
default:
{
att_idx = 0; // error index
} break;
}
return (att_idx) ? (hids_env.start_hdl + att_idx) : ATT_INVALID_HDL;
}
/// update configuration if value for stop or NTF start
static uint8_t hids_rpt_ntf_cfg(uint8_t conidx, uint8_t rpt_idx, const struct atts_write_ind *ind)
{
uint8_t status = PRF_ERR_APP_ERROR;
if ((!ind->more) && (ind->length == sizeof(uint16_t)))
{
uint16_t cli_cfg = read16p(ind->value);
//if ((cli_cfg == PRF_CLI_STOP_NTFIND) || (cli_cfg == PRF_CLI_START_NTF))
if (cli_cfg <= PRF_CLI_START_NTF)
{
DEBUG(" RPT_NTF_CFG(idx:%d,cfg:%d)", rpt_idx, cli_cfg);
HID_RPT_NTF_SET(conidx, rpt_idx, cli_cfg);
status = LE_SUCCESS;
}
}
return status;
}
/// Confirm ATTS_WRITE_REQ
static void hids_att_write_cfm(uint8_t conidx, uint8_t att_idx, uint16_t handle, const struct atts_write_ind *ind)
{
uint8_t status = LE_SUCCESS;
switch (att_idx)
{
case HID_IDX_HID_CTRL_PT_VAL:
{
ASSERT_ERR(ind->length == HID_CTRL_PT_SIZE);
DEBUG(" HID_CTRL_PT:%d", ind->value[0]);
hids_env.conn[conidx].ctrl_pt = ind->value[0];
} break;
#if (HID_BOOT_SUP)
case HID_IDX_PROTO_MODE_VAL:
{
ASSERT_ERR(ind->length == HID_PROTO_MODE_SIZE);
DEBUG(" PROTO_MODE:%d", ind->value[0]);
hids_env.conn[conidx].proto_mode = ind->value[0];
} break;
#if (HID_BOOT_KB)
case HID_IDX_BOOT_KB_IN_RPT_NTF_CFG:
{
status = hids_rpt_ntf_cfg(conidx, RPT_IDX_BOOT_KB, ind);
} break;
case HID_IDX_BOOT_KB_OUT_RPT_VAL:
{
ASSERT_ERR(ind->length == HID_KB_OUT_RPT_SIZE);
DEBUG(" Led_Lock(b0:num,b1:caps,b2:scroll):0x%02x", ind->value[0]);
hids_env.conn[conidx].led_lock = ind->value[0];
hids_led_lock(ind->value[0]);
} break;
#endif //(HID_BOOT_KB)
#if (HID_BOOT_MOUSE)
case HID_IDX_BOOT_MOUSE_IN_RPT_NTF_CFG:
{
status = hids_rpt_ntf_cfg(conidx, RPT_IDX_BOOT_MOUSE, ind);
} break;
#endif //(HID_BOOT_MOUSE)
#endif //(HID_BOOT_SUP)
#if (HID_REPORT_SUP)
#if (HID_RPT_KB)
case HID_IDX_KB_IN_RPT_NTF_CFG:
{
status = hids_rpt_ntf_cfg(conidx, RPT_IDX_KB, ind);
} break;
case HID_IDX_KB_OUT_RPT_VAL:
{
ASSERT_ERR(ind->length == HID_KB_OUT_RPT_SIZE);
DEBUG(" Led_Lock(b0:num,b1:caps,b2:scroll):0x%02x", ind->value[0]);
hids_env.conn[conidx].led_lock = ind->value[0];
hids_led_lock(ind->value[0]);
} break;
#endif //(HID_RPT_KB)
#if (HID_RPT_MEDIA)
case HID_IDX_MEDIA_IN_RPT_NTF_CFG:
{
status = hids_rpt_ntf_cfg(conidx, RPT_IDX_MEDIA, ind);
} break;
#endif //(HID_RPT_MEDIA)
#if (HID_RPT_SYSTEM)
case HID_IDX_SYS_IN_RPT_NTF_CFG:
{
status = hids_rpt_ntf_cfg(conidx, RPT_IDX_SYSTEM, ind);
} break;
#endif //(HID_RPT_SYSTEM)
#if (HID_RPT_MOUSE)
case HID_IDX_MOUSE_IN_RPT_NTF_CFG:
{
status = hids_rpt_ntf_cfg(conidx, RPT_IDX_MOUSE, ind);
} break;
#endif //(HID_RPT_MOUSE)
#if (HID_RPT_PTP)
case HID_IDX_TP_IN_RPT_NTF_CFG:
{
status = hids_rpt_ntf_cfg(conidx, RPT_IDX_TP, ind);
} break;
case HID_IDX_MAXCNT_FEAT_RPT_VAL:
case HID_IDX_PTPHQA_FEAT_RPT_VAL:
{
// maybe do something
} break;
#endif //(HID_RPT_PTP)
#endif //(HID_REPORT_SUP)
default:
{
status = PRF_ERR_APP_ERROR;
} break;
}
// Send write confirm, if no more data.
if (!ind->more)
gatt_write_cfm(conidx, status, handle);
}
/// Confirm ATTS_READ_REQ
static void hids_att_read_cfm(uint8_t conidx, uint8_t att_idx, uint16_t handle)
{
uint16_t length = 0;
switch (att_idx)
{
case HID_IDX_HID_INFO_VAL:
{
struct hid_info_tag hid_info;
hid_info.bcdHID = HID_INFO_BCDHID;
hid_info.bCountryCode = HID_INFO_BCODE;
hid_info.flags = HID_INFO_FLAGS;
DEBUG(" Read HID_INFO(bcd:0x%04X)", hid_info.bcdHID);
gatt_read_cfm(conidx, LE_SUCCESS, handle, HID_INFO_SIZE, (uint8_t *)&hid_info);
} break;
case HID_IDX_REPORT_MAP_VAL:
{
const uint8_t *report_map = hid_get_report_map(&length);
DEBUG(" Read REPORT_MAP(size:%d)", length);
gatt_read_cfm(conidx, LE_SUCCESS, handle, length, report_map);
} break;
#if (HID_BOOT_SUP)
case HID_IDX_PROTO_MODE_VAL:
{
DEBUG(" Read PROTO_MODE(mode:%d)", hids_env.conn[conidx].proto_mode);
gatt_read_cfm(conidx, LE_SUCCESS, handle, HID_PROTO_MODE_SIZE, &(hids_env.conn[conidx].proto_mode));
} break;
#if (HID_BOOT_KB)
case HID_IDX_BOOT_KB_IN_RPT_VAL:
{
gatt_read_cfm(conidx, LE_SUCCESS, handle, HID_BOOT_KB_RPT_SIZE, NULL); // zero array
} break;
case HID_IDX_BOOT_KB_IN_RPT_NTF_CFG:
{
uint16_t ntf_cfg = HID_RPT_NTF_GET(conidx, RPT_IDX_BOOT_KB);
gatt_read_cfm(conidx, LE_SUCCESS, handle, sizeof(uint16_t), (uint8_t *)&ntf_cfg);
} break;
case HID_IDX_BOOT_KB_OUT_RPT_VAL:
{
gatt_read_cfm(conidx, LE_SUCCESS, handle, HID_KB_OUT_RPT_SIZE, &(hids_env.conn[conidx].led_lock));
} break;
#endif //(HID_BOOT_KB)
#if (HID_BOOT_MOUSE)
case HID_IDX_BOOT_MOUSE_IN_RPT_VAL:
{
gatt_read_cfm(conidx, LE_SUCCESS, handle, HID_BOOT_MOUSE_RPT_SIZE, NULL); // zero array
} break;
case HID_IDX_BOOT_MOUSE_IN_RPT_NTF_CFG:
{
uint16_t ntf_cfg = HID_RPT_NTF_GET(conidx, RPT_IDX_BOOT_MOUSE);
gatt_read_cfm(conidx, LE_SUCCESS, handle, sizeof(uint16_t), (uint8_t *)&ntf_cfg);
} break;
#endif //(HID_BOOT_MOUSE)
#endif //(HID_BOOT_SUP)
#if (HID_REPORT_SUP)
#if (HID_RPT_KB)
case HID_IDX_KB_IN_RPT_VAL:
{
gatt_read_cfm(conidx, LE_SUCCESS, handle, RPT_LEN_KB, NULL); // zero array
} break;
case HID_IDX_KB_IN_RPT_REF:
{
struct hid_report_ref refer;
refer.report_id = RPT_ID_KB;
refer.report_type = HID_REPORT_INPUT;
gatt_read_cfm(conidx, LE_SUCCESS, handle, HID_REPORT_REF_SIZE, (uint8_t *)&refer);
} break;
case HID_IDX_KB_IN_RPT_NTF_CFG:
{
uint16_t ntf_cfg = HID_RPT_NTF_GET(conidx, RPT_IDX_KB);
gatt_read_cfm(conidx, LE_SUCCESS, handle, sizeof(uint16_t), (uint8_t *)&ntf_cfg);
} break;
case HID_IDX_KB_OUT_RPT_VAL:
{
gatt_read_cfm(conidx, LE_SUCCESS, handle, HID_KB_OUT_RPT_SIZE, &(hids_env.conn[conidx].led_lock));
} break;
case HID_IDX_KB_OUT_RPT_REF:
{
struct hid_report_ref refer;
refer.report_id = RPT_ID_KB;
refer.report_type = HID_REPORT_OUTPUT;
gatt_read_cfm(conidx, LE_SUCCESS, handle, HID_REPORT_REF_SIZE, (uint8_t *)&refer);
} break;
#endif //(HID_RPT_KB)
#if (HID_RPT_MEDIA)
case HID_IDX_MEDIA_IN_RPT_VAL:
{
gatt_read_cfm(conidx, LE_SUCCESS, handle, RPT_LEN_MEDIA, NULL); // zero array
} break;
case HID_IDX_MEDIA_IN_RPT_REF:
{
struct hid_report_ref refer;
refer.report_id = RPT_ID_MEDIA;
refer.report_type = HID_REPORT_INPUT;
gatt_read_cfm(conidx, LE_SUCCESS, handle, HID_REPORT_REF_SIZE, (uint8_t *)&refer);
} break;
case HID_IDX_MEDIA_IN_RPT_NTF_CFG:
{
uint16_t ntf_cfg = HID_RPT_NTF_GET(conidx, RPT_IDX_MEDIA);
gatt_read_cfm(conidx, LE_SUCCESS, handle, sizeof(uint16_t), (uint8_t *)&ntf_cfg);
} break;
#endif //(HID_RPT_MEDIA)
#if (HID_RPT_SYSTEM)
case HID_IDX_SYS_IN_RPT_VAL:
{
gatt_read_cfm(conidx, LE_SUCCESS, handle, RPT_LEN_SYSTEM, NULL); // zero array
} break;
case HID_IDX_SYS_IN_RPT_REF:
{
struct hid_report_ref refer;
refer.report_id = RPT_ID_SYSTEM;
refer.report_type = HID_REPORT_INPUT;
gatt_read_cfm(conidx, LE_SUCCESS, handle, HID_REPORT_REF_SIZE, (uint8_t *)&refer);
} break;
case HID_IDX_SYS_IN_RPT_NTF_CFG:
{
uint16_t ntf_cfg = HID_RPT_NTF_GET(conidx, RPT_IDX_SYSTEM);
gatt_read_cfm(conidx, LE_SUCCESS, handle, sizeof(uint16_t), (uint8_t *)&ntf_cfg);
} break;
#endif //(HID_RPT_SYSTEM)
#if (HID_RPT_MOUSE)
case HID_IDX_MOUSE_IN_RPT_VAL:
{
gatt_read_cfm(conidx, LE_SUCCESS, handle, RPT_LEN_MOUSE, NULL); // zero array
} break;
case HID_IDX_MOUSE_IN_RPT_REF:
{
struct hid_report_ref refer;
refer.report_id = RPT_ID_MOUSE;
refer.report_type = HID_REPORT_INPUT;
gatt_read_cfm(conidx, LE_SUCCESS, handle, HID_REPORT_REF_SIZE, (uint8_t *)&refer);
} break;
case HID_IDX_MOUSE_IN_RPT_NTF_CFG:
{
uint16_t ntf_cfg = HID_RPT_NTF_GET(conidx, RPT_IDX_MOUSE);
gatt_read_cfm(conidx, LE_SUCCESS, handle, sizeof(uint16_t), (uint8_t *)&ntf_cfg);
} break;
#endif //(HID_RPT_MOUSE)
#if (HID_RPT_PTP)
case HID_IDX_TP_IN_RPT_VAL:
{
gatt_read_cfm(conidx, LE_SUCCESS, handle, RPT_LEN_TP, NULL); // zero array
} break;
case HID_IDX_TP_IN_RPT_REF:
{
struct hid_report_ref refer;
refer.report_id = RPT_ID_TP;
refer.report_type = HID_REPORT_INPUT;
gatt_read_cfm(conidx, LE_SUCCESS, handle, HID_REPORT_REF_SIZE, (uint8_t *)&refer);
} break;
case HID_IDX_TP_IN_RPT_NTF_CFG:
{
uint16_t ntf_cfg = HID_RPT_NTF_GET(conidx, RPT_IDX_TP);
gatt_read_cfm(conidx, LE_SUCCESS, handle, sizeof(uint16_t), (uint8_t *)&ntf_cfg);
} break;
case HID_IDX_MAXCNT_FEAT_RPT_VAL:
{
uint8_t finger = PTP_MAX_FINGER_CNT;
gatt_read_cfm(conidx, LE_SUCCESS, handle, sizeof(uint8_t), &finger);
} break;
case HID_IDX_MAXCNT_FEAT_RPT_REF:
{
struct hid_report_ref refer;
refer.report_id = RPT_ID_MAXCNT;
refer.report_type = HID_REPORT_FEATURE;
gatt_read_cfm(conidx, LE_SUCCESS, handle, HID_REPORT_REF_SIZE, (uint8_t *)&refer);
} break;
case HID_IDX_PTPHQA_FEAT_RPT_VAL:
{
const uint8_t *ptp_hqa = hid_get_ptphqa_blob(&length);
gatt_read_cfm(conidx, LE_SUCCESS, handle, length, ptp_hqa);
} break;
case HID_IDX_PTPHQA_FEAT_RPT_REF:
{
struct hid_report_ref refer;
refer.report_id = RPT_ID_PTPHQA;
refer.report_type = HID_REPORT_FEATURE;
gatt_read_cfm(conidx, LE_SUCCESS, handle, HID_REPORT_REF_SIZE, (uint8_t *)&refer);
} break;
#endif //(HID_RPT_PTP)
#endif //(HID_REPORT_SUP)
default:
{
// error response
gatt_read_cfm(conidx, PRF_ERR_APP_ERROR, handle, 0, NULL);
} break;
}
}
/// Handles reception of the atts request from peer device
static void hids_svc_func(uint8_t conidx, uint8_t opcode, uint16_t handle, const void *param)
{
uint8_t att_idx = hids_get_att_idx(handle);
ASSERT_ERR(coindx < HID_CONN_MAX);
DEBUG("svc_func(cid:%d,op:0x%x,hdl:0x%x,att:%d)", conidx, opcode, handle, att_idx);
switch (opcode)
{
case ATTS_READ_REQ:
{
hids_att_read_cfm(conidx, att_idx, handle);
} break;
case ATTS_WRITE_REQ:
{
const struct atts_write_ind *ind = param;
DEBUG(" write_req(hdl:0x%x,att:%d,wr:0x%x,len:%d)", handle, att_idx, ind->wrcode, ind->length);
hids_att_write_cfm(conidx, att_idx, handle, ind);
} break;
case ATTS_INFO_REQ:
{
uint16_t length = ATT_MAX_LEN_GET(att_idx, hid_atts);
// Send length-info confirm for prepWR judging.
DEBUG(" info_cfm(hdl:0x%x,att:%d,len:%d)", handle, att_idx, length);
gatt_info_cfm(conidx, LE_SUCCESS, handle, length);
} break;
case ATTS_CMP_EVT:
{
const struct atts_cmp_evt *evt = param;
hids_env.nb_pkt++; // release
DEBUG(" cmp_evt(op:0x%x,sta:0x%x,nb:%d)", evt->operation, evt->status, hids_env.nb_pkt);
// add 'if' to avoid warning #117-D: "evt" never referenced
if (evt->operation == GATT_NOTIFY)
{
// Notify result
}
} break;
default:
{
// nothing to do
} break;
}
}
/**
****************************************************************************************
* @section API FUNCTIONS
****************************************************************************************
*/
/**
****************************************************************************************
* @brief Add HID Service Profile in the DB
* Customize via pre-define @see HID_START_HDL
*
* @return Result status, LE_SUCCESS or Error Reason
****************************************************************************************
*/
uint8_t hids_prf_init(void)
{
uint8_t status = LE_SUCCESS;
// Init Environment
hids_env.start_hdl = HID_START_HDL;
hids_env.nb_pkt = HID_NB_PKT_MAX;
for (uint8_t conidx = 0; conidx < HID_CONN_MAX; conidx++)
{
hids_env.conn[conidx].rpt_ntfs = RPT_NTF_ALL;
hids_env.conn[conidx].led_lock = 0;
hids_env.conn[conidx].proto_mode = HID_REPORT_PROTOCOL_MODE;
hids_env.conn[conidx].ctrl_pt = HID_CTRL_PT_EXIT_SUSPEND;
}
// Create Service in database
status = attmdb_svc_create(&hids_env.start_hdl, NULL, &hid_svc_db, hids_svc_func);
DEBUG("svc_init(sta:0x%X,shdl:%d,atts:%d)", status, hids_env.start_hdl, HID_IDX_NB-1);
return status;
}
/**
****************************************************************************************
* @brief Show LED Lock of Keyboard Output, User Implement! (__weak func)
*
* @param[in] leds Bits of Led_Lock(b0:num,b1:caps,b2:scroll)
****************************************************************************************
*/
__weak void hids_led_lock(uint8_t leds)
{
// todo LED play...
}
/**
****************************************************************************************
* @brief Enable HID Notification Configurations.
*
* @param[in] conidx Connection index
* @param[in] rpt_ntf Notification Config Bits @see enum rpt_ntf_idx
****************************************************************************************
*/
void hids_set_ccc(uint8_t conidx, uint8_t rpt_ntf)
{
//if (gapc_get_conhdl(conidx) != GAP_INVALID_CONHDL)
{
// update configuration
hids_env.conn[conidx].rpt_ntfs = rpt_ntf;
}
}
/**
****************************************************************************************
* @brief Send HID Report to Host peer.
*
* @param[in] conidx Connection Index
* @param[in] rep_idx Report Index
* @param[in] rep_len Report Length
* @param[in] rep_val Report Value
*
* @return Status of the operation @see prf_err
****************************************************************************************
*/
uint8_t hids_report_send(uint8_t conidx, uint8_t rep_idx, uint16_t rep_len, const uint8_t* rep_val)
{
uint8_t status = PRF_ERR_REQ_DISALLOWED;
if ((rep_len > 0) && (hids_env.nb_pkt > 0))
{
if (HID_RPT_NTF_GET(conidx, rep_idx) == PRF_CLI_START_NTF)
{
uint16_t handle = hids_get_rpt_handle(rep_idx);
if (handle != ATT_INVALID_HDL)
{
hids_env.nb_pkt--; // allocate
DEBUG("hid_ntf_send(len:%d,nb:%d)", rep_len, hids_env.nb_pkt);
debugHex(rep_val, rep_len);
gatt_ntf_send(conidx, handle, rep_len, rep_val);
status = LE_SUCCESS;
}
}
else
{
status = PRF_ERR_NTF_DISABLED;
}
}
return status;
}
#endif //(PRF_HIDS)
Reference in New Issue View Git Blame Copy Permalink