Mirrors/esp-idf
1
0
Fork 0
mirror of https://github.com/espressif/esp-idf.git synced 2026-10-01 10:40:47 +03:00
Code Issues Packages Projects Releases Wiki Activity

fix(bt/bluedroid): fixed the vulerabilities from AI code review in HID

Browse Source
This commit is contained in:
Jin Cheng
2026-05-09 11:04:35 +08:00
committed by Jin Cheng
parent c504a04a93
commit f45c7f0aaa
15 changed files with 387 additions and 187 deletions
Download Patch File Download Diff File Expand all files Collapse all files
components/bt/host/bluedroid/api/esp_hidd_api.c
+27 -3
View File
@@ -1,5 +1,5 @@
/*
* SPDX-FileCopyrightText: 2015-2025 Espressif Systems (Shanghai) CO LTD
* SPDX-FileCopyrightText: 2015-2026 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*
@@ -20,7 +20,7 @@ esp_err_t esp_bt_hid_device_register_callback(esp_hd_cb_t callback)
ESP_BLUEDROID_STATUS_CHECK(ESP_BLUEDROID_STATUS_ENABLED);
if (callback == NULL) {
return ESP_FAIL;
return ESP_ERR_INVALID_ARG;
}
btc_profile_cb_set(BTC_PID_HD, callback);
@@ -58,6 +58,16 @@ esp_err_t esp_bt_hid_device_register_app(esp_hidd_app_param_t* app_param, esp_hi
{
ESP_BLUEDROID_STATUS_CHECK(ESP_BLUEDROID_STATUS_ENABLED);
if ((app_param == NULL) || (in_qos == NULL) || (out_qos == NULL)) {
return ESP_ERR_INVALID_ARG;
}
if ((app_param->desc_list_len <= 0) || (app_param->desc_list_len > ESP_HIDD_APP_DESC_LIST_LEN_MAX) || (app_param->desc_list == NULL)) {
return ESP_ERR_INVALID_ARG;
}
if ((app_param->name == NULL) || (app_param->description == NULL) || (app_param->provider == NULL)) {
return ESP_ERR_INVALID_ARG;
}
btc_msg_t msg;
btc_hidd_args_t args;
memset(&args, 0, sizeof(btc_hidd_args_t));
@@ -69,7 +79,8 @@ esp_err_t esp_bt_hid_device_register_app(esp_hidd_app_param_t* app_param, esp_hi
msg.pid = BTC_PID_HD;
msg.act = BTC_HD_REGISTER_APP_EVT;
bt_status_t stat = btc_transfer_context(&msg, &args, sizeof(btc_hidd_args_t), NULL, NULL);
bt_status_t stat = btc_transfer_context(&msg, &args, sizeof(btc_hidd_args_t),
btc_hd_arg_deep_copy, btc_hd_call_arg_deep_free);
return (stat == BT_STATUS_SUCCESS) ? ESP_OK : ESP_FAIL;
}
@@ -90,6 +101,10 @@ esp_err_t esp_bt_hid_device_connect(esp_bd_addr_t bd_addr)
{
ESP_BLUEDROID_STATUS_CHECK(ESP_BLUEDROID_STATUS_ENABLED);
if (bd_addr == NULL) {
return ESP_ERR_INVALID_ARG;
}
btc_msg_t msg;
btc_hidd_args_t args;
memset(&args, 0, sizeof(btc_hidd_args_t));
@@ -120,6 +135,10 @@ esp_err_t esp_bt_hid_device_send_report(esp_hidd_report_type_t type, uint8_t id,
{
ESP_BLUEDROID_STATUS_CHECK(ESP_BLUEDROID_STATUS_ENABLED);
if ((type < ESP_HIDD_REPORT_TYPE_OTHER) || (type > ESP_HIDD_REPORT_TYPE_INTRDATA) || (data == NULL) || (len == 0)) {
return ESP_ERR_INVALID_ARG;
}
btc_msg_t msg;
msg.sig = BTC_SIG_API_CALL;
msg.pid = BTC_PID_HD;
@@ -141,6 +160,11 @@ esp_err_t esp_bt_hid_device_report_error(esp_hidd_handshake_error_t error)
{
ESP_BLUEDROID_STATUS_CHECK(ESP_BLUEDROID_STATUS_ENABLED);
if ((error < ESP_HID_PAR_HANDSHAKE_RSP_SUCCESS) || (error > ESP_HID_PAR_HANDSHAKE_RSP_ERR_FATAL) ||
((error > ESP_HID_PAR_HANDSHAKE_RSP_ERR_INVALID_PARAM) && (error < ESP_HID_PAR_HANDSHAKE_RSP_ERR_UNKNOWN))) {
return ESP_ERR_INVALID_ARG;
}
btc_msg_t msg;
msg.sig = BTC_SIG_API_CALL;
msg.pid = BTC_PID_HD;
components/bt/host/bluedroid/api/esp_hidh_api.c
+46 -5
View File
@@ -1,5 +1,5 @@
/*
* SPDX-FileCopyrightText: 2015-2025 Espressif Systems (Shanghai) CO LTD
* SPDX-FileCopyrightText: 2015-2026 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*
@@ -18,9 +18,8 @@
esp_err_t esp_bt_hid_host_register_callback(esp_hh_cb_t callback)
{
ESP_BLUEDROID_STATUS_CHECK(ESP_BLUEDROID_STATUS_ENABLED);
if (callback == NULL) {
return ESP_FAIL;
return ESP_ERR_INVALID_ARG;
}
btc_profile_cb_set(BTC_PID_HH, callback);
@@ -30,7 +29,6 @@ esp_err_t esp_bt_hid_host_register_callback(esp_hh_cb_t callback)
esp_err_t esp_bt_hid_host_init(void)
{
ESP_BLUEDROID_STATUS_CHECK(ESP_BLUEDROID_STATUS_ENABLED);
btc_msg_t msg;
msg.sig = BTC_SIG_API_CALL;
@@ -44,7 +42,6 @@ esp_err_t esp_bt_hid_host_init(void)
esp_err_t esp_bt_hid_host_deinit(void)
{
ESP_BLUEDROID_STATUS_CHECK(ESP_BLUEDROID_STATUS_ENABLED);
btc_msg_t msg;
msg.sig = BTC_SIG_API_CALL;
@@ -61,6 +58,10 @@ esp_err_t esp_bt_hid_host_connect(esp_bd_addr_t bd_addr)
btc_msg_t msg;
btc_hidh_args_t arg;
if (bd_addr == NULL) {
return ESP_ERR_INVALID_ARG;
}
msg.sig = BTC_SIG_API_CALL;
msg.pid = BTC_PID_HH;
msg.act = BTC_HH_CONNECT_EVT;
@@ -77,6 +78,10 @@ esp_err_t esp_bt_hid_host_disconnect(esp_bd_addr_t bd_addr)
btc_msg_t msg;
btc_hidh_args_t arg;
if (bd_addr == NULL) {
return ESP_ERR_INVALID_ARG;
}
msg.sig = BTC_SIG_API_CALL;
msg.pid = BTC_PID_HH;
msg.act = BTC_HH_DISCONNECT_EVT;
@@ -93,6 +98,10 @@ esp_err_t esp_bt_hid_host_virtual_cable_unplug(esp_bd_addr_t bd_addr)
btc_msg_t msg;
btc_hidh_args_t arg;
if (bd_addr == NULL) {
return ESP_ERR_INVALID_ARG;
}
msg.sig = BTC_SIG_API_CALL;
msg.pid = BTC_PID_HH;
msg.act = BTC_HH_UNPLUG_EVT;
@@ -106,6 +115,10 @@ esp_err_t esp_bt_hid_host_virtual_cable_unplug(esp_bd_addr_t bd_addr)
esp_err_t esp_bt_hid_host_set_info(esp_bd_addr_t bd_addr, esp_hidh_hid_info_t *hid_info)
{
ESP_BLUEDROID_STATUS_CHECK(ESP_BLUEDROID_STATUS_ENABLED);
if ((bd_addr == NULL) || (hid_info == NULL) || (hid_info->dl_len < 0) || (hid_info->dl_len > BTHH_MAX_DSC_LEN)) {
return ESP_ERR_INVALID_ARG;
}
btc_msg_t msg;
btc_hidh_args_t arg;
@@ -127,6 +140,10 @@ esp_err_t esp_bt_hid_host_get_protocol(esp_bd_addr_t bd_addr)
btc_msg_t msg;
btc_hidh_args_t arg;
if (bd_addr == NULL) {
return ESP_ERR_INVALID_ARG;
}
msg.sig = BTC_SIG_API_CALL;
msg.pid = BTC_PID_HH;
msg.act = BTC_HH_GET_PROTO_EVT;
@@ -143,6 +160,10 @@ esp_err_t esp_bt_hid_host_set_protocol(esp_bd_addr_t bd_addr, esp_hidh_protocol_
btc_msg_t msg;
btc_hidh_args_t arg;
if (bd_addr == NULL) {
return ESP_ERR_INVALID_ARG;
}
msg.sig = BTC_SIG_API_CALL;
msg.pid = BTC_PID_HH;
msg.act = BTC_HH_SET_PROTO_EVT;
@@ -160,6 +181,10 @@ esp_err_t esp_bt_hid_host_get_idle(esp_bd_addr_t bd_addr)
btc_msg_t msg;
btc_hidh_args_t arg;
if (bd_addr == NULL) {
return ESP_ERR_INVALID_ARG;
}
msg.sig = BTC_SIG_API_CALL;
msg.pid = BTC_PID_HH;
msg.act = BTC_HH_GET_IDLE_EVT;
@@ -176,6 +201,10 @@ esp_err_t esp_bt_hid_host_set_idle(esp_bd_addr_t bd_addr, uint16_t idle_time)
btc_msg_t msg;
btc_hidh_args_t arg;
if (bd_addr == NULL) {
return ESP_ERR_INVALID_ARG;
}
msg.sig = BTC_SIG_API_CALL;
msg.pid = BTC_PID_HH;
msg.act = BTC_HH_SET_IDLE_EVT;
@@ -194,6 +223,10 @@ esp_err_t esp_bt_hid_host_get_report(esp_bd_addr_t bd_addr, esp_hidh_report_type
btc_msg_t msg;
btc_hidh_args_t arg;
if (bd_addr == NULL) {
return ESP_ERR_INVALID_ARG;
}
msg.sig = BTC_SIG_API_CALL;
msg.pid = BTC_PID_HH;
msg.act = BTC_HH_GET_REPORT_EVT;
@@ -211,6 +244,10 @@ esp_err_t esp_bt_hid_host_set_report(esp_bd_addr_t bd_addr, esp_hidh_report_type
size_t len)
{
ESP_BLUEDROID_STATUS_CHECK(ESP_BLUEDROID_STATUS_ENABLED);
if ((bd_addr == NULL) || (report == NULL) || (len == 0)) {
return ESP_ERR_INVALID_ARG;
}
btc_msg_t msg;
btc_hidh_args_t arg;
@@ -231,6 +268,10 @@ esp_err_t esp_bt_hid_host_set_report(esp_bd_addr_t bd_addr, esp_hidh_report_type
esp_err_t esp_bt_hid_host_send_data(esp_bd_addr_t bd_addr, uint8_t *data, size_t len)
{
ESP_BLUEDROID_STATUS_CHECK(ESP_BLUEDROID_STATUS_ENABLED);
if ((bd_addr == NULL) || (data == NULL) || (len == 0)) {
return ESP_ERR_INVALID_ARG;
}
btc_msg_t msg;
btc_hidh_args_t arg;
components/bt/host/bluedroid/api/include/api/esp_hidd_api.h
+3
View File
@@ -28,6 +28,9 @@ extern "C" {
#define ESP_HID_CLASS_MIC (0x20<<2) /*!< pointing device */
#define ESP_HID_CLASS_COM (0x30<<2) /*!< combo keyboard/pointing */
/** Maximum length of HID Device descriptor list */
#define ESP_HIDD_APP_DESC_LIST_LEN_MAX 2048
/**
* @brief HIDD handshake result code
*/
components/bt/host/bluedroid/bta/hd/bta_hd_act.c
+5 -1
View File
@@ -51,6 +51,7 @@ static bool check_descriptor(uint8_t *data, uint16_t length, bool *has_report_id
break;
case 0x85: // Report ID
*has_report_id = TRUE;
/* fall through */
default:
ptr += (item & 0x03);
break;
@@ -524,6 +525,7 @@ extern void bta_hd_intr_data_act(tBTA_HD_DATA *p_data)
{
tBTA_HD_CBACK_DATA *p_cback = (tBTA_HD_CBACK_DATA *)p_data;
if (!p_cback || !p_cback->p_data) {
APPL_TRACE_ERROR("no DATA request on intr");
return;
}
@@ -568,6 +570,7 @@ extern void bta_hd_get_report_act(tBTA_HD_DATA *p_data)
{
tBTA_HD_CBACK_DATA *p_cback = (tBTA_HD_CBACK_DATA *)p_data;
if (!p_cback || !p_cback->p_data) {
APPL_TRACE_ERROR("no DATA request on GET_REPORT");
return;
}
@@ -626,6 +629,7 @@ extern void bta_hd_set_report_act(tBTA_HD_DATA *p_data)
{
tBTA_HD_CBACK_DATA *p_cback = (tBTA_HD_CBACK_DATA *)p_data;
if (!p_cback || !p_cback->p_data) {
APPL_TRACE_ERROR("no DATA request on SET_REPORT");
return;
}
@@ -826,7 +830,7 @@ static void bta_hd_cback(BD_ADDR bd_addr, uint8_t event, uint32_t data, BT_HDR *
}
if (sm_event != BTA_HD_INVALID_EVT &&
(p_buf = (tBTA_HD_CBACK_DATA *)osi_malloc(sizeof(tBTA_HD_CBACK_DATA) + sizeof(BT_HDR))) != NULL) {
(p_buf = (tBTA_HD_CBACK_DATA *)osi_malloc(sizeof(tBTA_HD_CBACK_DATA))) != NULL) {
p_buf->hdr.event = sm_event;
bdcpy(p_buf->addr, bd_addr);
p_buf->data = data;
components/bt/host/bluedroid/bta/hd/bta_hd_api.c
+6 -2
View File
@@ -49,9 +49,9 @@ void BTA_HdEnable(tBTA_HD_CBACK *p_cback)
{
tBTA_HD_API_ENABLE *p_buf;
APPL_TRACE_API("%s", __func__);
bta_sys_register(BTA_ID_HD, &bta_hd_reg);
p_buf = (tBTA_HD_API_ENABLE *)osi_malloc((uint16_t)sizeof(tBTA_HD_API_ENABLE));
p_buf = (tBTA_HD_API_ENABLE *)osi_malloc(sizeof(tBTA_HD_API_ENABLE));
if (p_buf != NULL) {
bta_sys_register(BTA_ID_HD, &bta_hd_reg);
memset(p_buf, 0, sizeof(tBTA_HD_API_ENABLE));
p_buf->hdr.event = BTA_HD_API_ENABLE_EVT;
p_buf->p_cback = p_cback;
@@ -89,6 +89,10 @@ void BTA_HdDisable(void)
******************************************************************************/
extern void BTA_HdRegisterApp(tBTA_HD_APP_INFO *p_app_info, tBTA_HD_QOS_INFO *p_in_qos, tBTA_HD_QOS_INFO *p_out_qos)
{
if (p_app_info == NULL || p_in_qos == NULL || p_out_qos == NULL) {
APPL_TRACE_ERROR("bad app_info(%p), in_qos(%p) or out_qos(%p)", p_app_info, p_in_qos, p_out_qos);
return;
}
/* Validate descriptor length before copying */
if (p_app_info->descriptor.dl_len > BTA_HD_APP_DESCRIPTOR_LEN) {
components/bt/host/bluedroid/bta/hd/bta_hd_main.c
+1 -3
View File
@@ -18,7 +18,7 @@
******************************************************************************/
/******************************************************************************
*
* This file contains the HID host main functions and state machine.
* This file contains the HID device main functions and state machine.
*
******************************************************************************/
#include "common/bt_target.h"
@@ -204,13 +204,11 @@ void bta_hd_sm_execute(uint16_t event, tBTA_HD_DATA *p_data)
tBTA_HD_ST_TBL state_table;
tBTA_HD_STATE prev_state;
uint8_t action;
tBTA_HD cback_data;
APPL_TRACE_EVENT("%s: state=%s (%d) event=%s (%d)", __func__, bta_hd_state_code(bta_hd_cb.state), bta_hd_cb.state,
bta_hd_evt_code(event), event);
prev_state = bta_hd_cb.state;
memset(&cback_data, 0, sizeof(tBTA_HD));
state_table = bta_hd_st_tbl[bta_hd_cb.state];
event &= 0xff;
components/bt/host/bluedroid/bta/hh/bta_hh_act.c
+1 -1
View File
@@ -756,7 +756,7 @@ void bta_hh_ctrl_dat_act(tBTA_HH_DEV_CB *p_cb, tBTA_HH_DATA *p_data)
/* fall through */
case BTA_HH_SET_RPT_EVT:
/* fall through */
case BTA_HH_SET_IDLE_EVT :
case BTA_HH_SET_IDLE_EVT:
/* fall through */
default:
#if BTA_HH_DEBUG
components/bt/host/bluedroid/bta/hh/bta_hh_api.c
+12 -8
View File
@@ -67,7 +67,7 @@ void BTA_HhEnable(tBTA_SEC sec_mask, tBTA_HH_CBACK *p_cback)
bta_sys_register(BTA_ID_HH, &bta_hh_reg);
APPL_TRACE_API("%s sec_mask:0x%x p_cback:%p", __func__, sec_mask, p_cback);
p_buf = (tBTA_HH_API_ENABLE *)osi_malloc((UINT16)sizeof(tBTA_HH_API_ENABLE));
p_buf = (tBTA_HH_API_ENABLE *)osi_malloc(sizeof(tBTA_HH_API_ENABLE));
if (p_buf != NULL) {
memset(p_buf, 0, sizeof(tBTA_HH_API_ENABLE));
@@ -114,7 +114,7 @@ void BTA_HhClose(UINT8 dev_handle)
{
BT_HDR *p_buf;
if ((p_buf = (BT_HDR *)osi_malloc((UINT16)sizeof(BT_HDR))) != NULL) {
if ((p_buf = (BT_HDR *)osi_malloc(sizeof(BT_HDR))) != NULL) {
memset(p_buf, 0, sizeof(BT_HDR));
p_buf->event = BTA_HH_API_CLOSE_EVT;
p_buf->layer_specific = (UINT16) dev_handle;
@@ -137,7 +137,7 @@ void BTA_HhOpen(BD_ADDR dev_bda, tBTA_HH_PROTO_MODE mode, tBTA_SEC sec_mask)
{
tBTA_HH_API_CONN *p_buf;
p_buf = (tBTA_HH_API_CONN *)osi_malloc((UINT16)sizeof(tBTA_HH_API_CONN));
p_buf = (tBTA_HH_API_CONN *)osi_malloc(sizeof(tBTA_HH_API_CONN));
if (p_buf != NULL) {
memset((void *)p_buf, 0, sizeof(tBTA_HH_API_CONN));
@@ -301,6 +301,10 @@ void BTA_HhSendCtrl(UINT8 dev_handle, tBTA_HH_TRANS_CTRL_TYPE c_type)
void BTA_HhSendData(UINT8 dev_handle, BD_ADDR dev_bda, BT_HDR *p_data)
{
UNUSED(dev_bda);
if (p_data == NULL) {
APPL_TRACE_ERROR("ERROR! Invalid parameter!");
return;
}
#if (defined BTA_HH_LE_INCLUDED && BTA_HH_LE_INCLUDED == TRUE)
if (p_data->layer_specific != BTA_HH_RPTT_OUTPUT) {
APPL_TRACE_ERROR("ERROR! Wrong report type! Write Command only valid for output report!");
@@ -323,7 +327,7 @@ void BTA_HhGetDscpInfo(UINT8 dev_handle)
{
BT_HDR *p_buf;
if ((p_buf = (BT_HDR *)osi_malloc((UINT16)sizeof(BT_HDR))) != NULL) {
if ((p_buf = (BT_HDR *)osi_malloc(sizeof(BT_HDR))) != NULL) {
memset(p_buf, 0, sizeof(BT_HDR));
p_buf->event = BTA_HH_API_GET_DSCP_EVT;
p_buf->layer_specific = (UINT16) dev_handle;
@@ -353,7 +357,7 @@ void BTA_HhAddDev(BD_ADDR bda, tBTA_HH_ATTR_MASK attr_mask, UINT8 sub_class,
p_buf = (tBTA_HH_MAINT_DEV *)osi_malloc(len);
if (p_buf != NULL) {
memset(p_buf, 0, sizeof(tBTA_HH_MAINT_DEV));
memset(p_buf, 0, len);
p_buf->hdr.event = BTA_HH_API_MAINT_DEV_EVT;
p_buf->sub_event = BTA_HH_ADD_DEV_EVT;
@@ -390,7 +394,7 @@ void BTA_HhRemoveDev(UINT8 dev_handle )
{
tBTA_HH_MAINT_DEV *p_buf;
p_buf = (tBTA_HH_MAINT_DEV *)osi_malloc((UINT16)sizeof(tBTA_HH_MAINT_DEV));
p_buf = (tBTA_HH_MAINT_DEV *)osi_malloc(sizeof(tBTA_HH_MAINT_DEV));
if (p_buf != NULL) {
memset(p_buf, 0, sizeof(tBTA_HH_MAINT_DEV));
@@ -418,7 +422,7 @@ void BTA_HhUpdateLeScanParam(UINT8 dev_handle, UINT16 scan_int, UINT16 scan_win)
{
tBTA_HH_SCPP_UPDATE *p_buf;
p_buf = (tBTA_HH_SCPP_UPDATE *)osi_malloc((UINT16)sizeof(tBTA_HH_SCPP_UPDATE));
p_buf = (tBTA_HH_SCPP_UPDATE *)osi_malloc(sizeof(tBTA_HH_SCPP_UPDATE));
if (p_buf != NULL) {
memset(p_buf, 0, sizeof(tBTA_HH_SCPP_UPDATE));
@@ -468,7 +472,7 @@ void BTA_HhParseBootRpt(tBTA_HH_BOOT_RPT *p_data, UINT8 *p_report,
break;
default:
APPL_TRACE_DEBUG("Unknown boot report: %d", p_report[0]);;
APPL_TRACE_DEBUG("Unknown boot report: %d", p_report[0]);
break;
}
}
components/bt/host/bluedroid/bta/hh/bta_hh_cfg.c
+2 -2
View File
@@ -40,7 +40,7 @@
/* The type of devices supported by BTA HH and corresponding application ID */
tBTA_HH_SPT_TOD p_devt_list[BTA_HH_MAX_DEVT_SPT] = {
static const tBTA_HH_SPT_TOD p_devt_list[BTA_HH_MAX_DEVT_SPT] = {
{BTA_HH_DEVT_MIC, BTA_HH_APP_ID_MI},
{BTA_HH_DEVT_KBD, BTA_HH_APP_ID_KB},
{BTA_HH_DEVT_KBD | BTA_HH_DEVT_MIC, BTA_HH_APP_ID_KB},
@@ -53,7 +53,7 @@ tBTA_HH_SPT_TOD p_devt_list[BTA_HH_MAX_DEVT_SPT] = {
};
const tBTA_HH_CFG bta_hh_cfg = {
static const tBTA_HH_CFG bta_hh_cfg = {
BTA_HH_MAX_DEVT_SPT, /* number of supported type of devices */
p_devt_list, /* ToD & AppID list */
BTA_HH_DISC_BUF_SIZE /* HH SDP discovery database size */
components/bt/host/bluedroid/bta/hh/bta_hh_main.c
+93 -93
View File
@@ -115,116 +115,116 @@ const tBTA_HH_ACTION bta_hh_action[] = {
/* state table for idle state */
const UINT8 bta_hh_st_idle[][BTA_HH_NUM_COLS] = {
/* Event Action Next state */
/* BTA_HH_API_OPEN_EVT */ {BTA_HH_START_SDP, BTA_HH_W4_CONN_ST },
/* BTA_HH_API_CLOSE_EVT */ {BTA_HH_IGNORE, BTA_HH_IDLE_ST },
/* BTA_HH_INT_OPEN_EVT */ {BTA_HH_OPEN_ACT, BTA_HH_W4_CONN_ST },
/* BTA_HH_INT_CLOSE_EVT */ {BTA_HH_CLOSE_ACT, BTA_HH_IDLE_ST },
/* BTA_HH_INT_DATA_EVT */ {BTA_HH_IGNORE, BTA_HH_IDLE_ST },
/* BTA_HH_INT_CTRL_DATA */ {BTA_HH_IGNORE, BTA_HH_IDLE_ST },
/* BTA_HH_INT_HANDSK_EVT */ {BTA_HH_IGNORE, BTA_HH_IDLE_ST },
/* BTA_HH_SDP_CMPL_EVT */ {BTA_HH_IGNORE, BTA_HH_IDLE_ST },
/* BTA_HH_API_WRITE_DEV_EVT */ {BTA_HH_IGNORE, BTA_HH_IDLE_ST },
/* BTA_HH_API_GET_DSCP_EVT */ {BTA_HH_IGNORE, BTA_HH_IDLE_ST },
/* BTA_HH_API_MAINT_DEV_EVT */ {BTA_HH_MAINT_DEV_ACT, BTA_HH_IDLE_ST },
/* BTA_HH_OPEN_CMPL_EVT */ {BTA_HH_OPEN_CMPL_ACT, BTA_HH_CONN_ST }
/* Event Action Next state */
/* BTA_HH_API_OPEN_EVT */ {BTA_HH_START_SDP, BTA_HH_W4_CONN_ST },
/* BTA_HH_API_CLOSE_EVT */ {BTA_HH_IGNORE, BTA_HH_IDLE_ST },
/* BTA_HH_INT_OPEN_EVT */ {BTA_HH_OPEN_ACT, BTA_HH_W4_CONN_ST },
/* BTA_HH_INT_CLOSE_EVT */ {BTA_HH_CLOSE_ACT, BTA_HH_IDLE_ST },
/* BTA_HH_INT_DATA_EVT */ {BTA_HH_IGNORE, BTA_HH_IDLE_ST },
/* BTA_HH_INT_CTRL_DATA */ {BTA_HH_IGNORE, BTA_HH_IDLE_ST },
/* BTA_HH_INT_HANDSK_EVT */ {BTA_HH_IGNORE, BTA_HH_IDLE_ST },
/* BTA_HH_SDP_CMPL_EVT */ {BTA_HH_IGNORE, BTA_HH_IDLE_ST },
/* BTA_HH_API_WRITE_DEV_EVT */ {BTA_HH_IGNORE, BTA_HH_IDLE_ST },
/* BTA_HH_API_GET_DSCP_EVT */ {BTA_HH_IGNORE, BTA_HH_IDLE_ST },
/* BTA_HH_API_MAINT_DEV_EVT */ {BTA_HH_MAINT_DEV_ACT, BTA_HH_IDLE_ST },
/* BTA_HH_OPEN_CMPL_EVT */ {BTA_HH_OPEN_CMPL_ACT, BTA_HH_CONN_ST },
#if (defined BTA_HH_LE_INCLUDED && BTA_HH_LE_INCLUDED == TRUE)
/* BTA_HH_GATT_CLOSE_EVT */ , {BTA_HH_IGNORE, BTA_HH_IDLE_ST }
/* BTA_HH_GATT_OPEN_EVT */ , {BTA_HH_GATT_OPEN, BTA_HH_W4_CONN_ST }
/* BTA_HH_START_ENC_EVT */ , {BTA_HH_IGNORE, BTA_HH_IDLE_ST }
/* BTA_HH_ENC_CMPL_EVT */ , {BTA_HH_IGNORE, BTA_HH_IDLE_ST }
/* READ_CHAR_CMPL_EVT */ , {BTA_HH_IGNORE, BTA_HH_IDLE_ST }
/* BTA_HH_GATT_WRITE_CMPL_EVT*/ , {BTA_HH_IGNORE, BTA_HH_IDLE_ST }
/* READ_DESCR_CMPL_EVT */ , {BTA_HH_IGNORE, BTA_HH_IDLE_ST }
/* WRITE_DESCR_CMPL_EVT */ , {BTA_HH_IGNORE, BTA_HH_IDLE_ST }
/* SCPP_UPDATE_EVT */ , {BTA_HH_IGNORE, BTA_HH_IDLE_ST }
/* BTA_HH_GATT_ENC_CMPL_EVT */ , {BTA_HH_IGNORE, BTA_HH_IDLE_ST }
/* BTA_HH_GATT_CLOSE_EVT */ {BTA_HH_IGNORE, BTA_HH_IDLE_ST },
/* BTA_HH_GATT_OPEN_EVT */ {BTA_HH_GATT_OPEN, BTA_HH_W4_CONN_ST },
/* BTA_HH_START_ENC_EVT */ {BTA_HH_IGNORE, BTA_HH_IDLE_ST },
/* BTA_HH_ENC_CMPL_EVT */ {BTA_HH_IGNORE, BTA_HH_IDLE_ST },
/* READ_CHAR_CMPL_EVT */ {BTA_HH_IGNORE, BTA_HH_IDLE_ST },
/* BTA_HH_GATT_WRITE_CMPL_EVT */ {BTA_HH_IGNORE, BTA_HH_IDLE_ST },
/* READ_DESCR_CMPL_EVT */ {BTA_HH_IGNORE, BTA_HH_IDLE_ST },
/* WRITE_DESCR_CMPL_EVT */ {BTA_HH_IGNORE, BTA_HH_IDLE_ST },
/* SCPP_UPDATE_EVT */ {BTA_HH_IGNORE, BTA_HH_IDLE_ST },
/* BTA_HH_GATT_ENC_CMPL_EVT */ {BTA_HH_IGNORE, BTA_HH_IDLE_ST },
#endif
};
const UINT8 bta_hh_st_w4_conn[][BTA_HH_NUM_COLS] = {
/* Event Action Next state */
/* BTA_HH_API_OPEN_EVT */ {BTA_HH_IGNORE, BTA_HH_W4_CONN_ST },
/* BTA_HH_API_CLOSE_EVT */ {BTA_HH_IGNORE, BTA_HH_IDLE_ST },
/* BTA_HH_INT_OPEN_EVT */ {BTA_HH_OPEN_ACT, BTA_HH_W4_CONN_ST },
/* BTA_HH_INT_CLOSE_EVT */ {BTA_HH_OPEN_FAILURE, BTA_HH_IDLE_ST },
/* BTA_HH_INT_DATA_EVT */ {BTA_HH_IGNORE, BTA_HH_W4_CONN_ST },
/* BTA_HH_INT_CTRL_DATA */ {BTA_HH_IGNORE, BTA_HH_W4_CONN_ST },
/* BTA_HH_INT_HANDSK_EVT */ {BTA_HH_IGNORE, BTA_HH_W4_CONN_ST },
/* BTA_HH_SDP_CMPL_EVT */ {BTA_HH_SDP_CMPL, BTA_HH_W4_CONN_ST },
/* BTA_HH_API_WRITE_DEV_EVT */ {BTA_HH_WRITE_DEV_ACT, BTA_HH_W4_CONN_ST },
/* BTA_HH_API_GET_DSCP_EVT */ {BTA_HH_IGNORE, BTA_HH_W4_CONN_ST },
/* BTA_HH_API_MAINT_DEV_EVT */ {BTA_HH_MAINT_DEV_ACT, BTA_HH_IDLE_ST },
/* BTA_HH_OPEN_CMPL_EVT */ {BTA_HH_OPEN_CMPL_ACT, BTA_HH_CONN_ST }
/* Event Action Next state */
/* BTA_HH_API_OPEN_EVT */ {BTA_HH_IGNORE, BTA_HH_W4_CONN_ST },
/* BTA_HH_API_CLOSE_EVT */ {BTA_HH_IGNORE, BTA_HH_IDLE_ST },
/* BTA_HH_INT_OPEN_EVT */ {BTA_HH_OPEN_ACT, BTA_HH_W4_CONN_ST },
/* BTA_HH_INT_CLOSE_EVT */ {BTA_HH_OPEN_FAILURE, BTA_HH_IDLE_ST },
/* BTA_HH_INT_DATA_EVT */ {BTA_HH_IGNORE, BTA_HH_W4_CONN_ST },
/* BTA_HH_INT_CTRL_DATA */ {BTA_HH_IGNORE, BTA_HH_W4_CONN_ST },
/* BTA_HH_INT_HANDSK_EVT */ {BTA_HH_IGNORE, BTA_HH_W4_CONN_ST },
/* BTA_HH_SDP_CMPL_EVT */ {BTA_HH_SDP_CMPL, BTA_HH_W4_CONN_ST },
/* BTA_HH_API_WRITE_DEV_EVT */ {BTA_HH_WRITE_DEV_ACT, BTA_HH_W4_CONN_ST },
/* BTA_HH_API_GET_DSCP_EVT */ {BTA_HH_IGNORE, BTA_HH_W4_CONN_ST },
/* BTA_HH_API_MAINT_DEV_EVT */ {BTA_HH_MAINT_DEV_ACT, BTA_HH_IDLE_ST },
/* BTA_HH_OPEN_CMPL_EVT */ {BTA_HH_OPEN_CMPL_ACT, BTA_HH_CONN_ST },
#if (defined BTA_HH_LE_INCLUDED && BTA_HH_LE_INCLUDED == TRUE)
/* BTA_HH_GATT_CLOSE_EVT */ , {BTA_HH_LE_OPEN_FAIL, BTA_HH_IDLE_ST }
/* BTA_HH_GATT_OPEN_EVT */ , {BTA_HH_GATT_OPEN, BTA_HH_W4_CONN_ST }
/* BTA_HH_START_ENC_EVT */ , {BTA_HH_START_SEC, BTA_HH_W4_SEC }
/* BTA_HH_ENC_CMPL_EVT */ , {BTA_HH_IGNORE, BTA_HH_W4_CONN_ST }
/* READ_CHAR_CMPL_EVT */ , {BTA_HH_W4_LE_READ_CHAR, BTA_HH_W4_CONN_ST }
/* BTA_HH_GATT_WRITE_CMPL_EVT*/ , {BTA_HH_W4_LE_WRITE, BTA_HH_W4_CONN_ST }
/* READ_DESCR_CMPL_EVT */ , {BTA_HH_W4_LE_READ_DESCR, BTA_HH_W4_CONN_ST }
/* WRITE_DESCR_CMPL_EVT */ , {BTA_HH_WRITE_DESCR, BTA_HH_W4_CONN_ST }
/* SCPP_UPDATE_EVT */ , {BTA_HH_IGNORE, BTA_HH_W4_CONN_ST }
/* BTA_HH_GATT_ENC_CMPL_EVT */ , {BTA_HH_IGNORE, BTA_HH_W4_CONN_ST }
/* BTA_HH_GATT_CLOSE_EVT */ {BTA_HH_LE_OPEN_FAIL, BTA_HH_IDLE_ST },
/* BTA_HH_GATT_OPEN_EVT */ {BTA_HH_GATT_OPEN, BTA_HH_W4_CONN_ST },
/* BTA_HH_START_ENC_EVT */ {BTA_HH_START_SEC, BTA_HH_W4_SEC },
/* BTA_HH_ENC_CMPL_EVT */ {BTA_HH_IGNORE, BTA_HH_W4_CONN_ST },
/* READ_CHAR_CMPL_EVT */ {BTA_HH_W4_LE_READ_CHAR, BTA_HH_W4_CONN_ST },
/* BTA_HH_GATT_WRITE_CMPL_EVT */ {BTA_HH_W4_LE_WRITE, BTA_HH_W4_CONN_ST },
/* READ_DESCR_CMPL_EVT */ {BTA_HH_W4_LE_READ_DESCR, BTA_HH_W4_CONN_ST },
/* WRITE_DESCR_CMPL_EVT */ {BTA_HH_WRITE_DESCR, BTA_HH_W4_CONN_ST },
/* SCPP_UPDATE_EVT */ {BTA_HH_IGNORE, BTA_HH_W4_CONN_ST },
/* BTA_HH_GATT_ENC_CMPL_EVT */ {BTA_HH_IGNORE, BTA_HH_W4_CONN_ST },
#endif
};
const UINT8 bta_hh_st_connected[][BTA_HH_NUM_COLS] = {
/* Event Action Next state */
/* BTA_HH_API_OPEN_EVT */ {BTA_HH_IGNORE, BTA_HH_CONN_ST },
/* BTA_HH_API_CLOSE_EVT */ {BTA_HH_API_DISC_ACT, BTA_HH_CONN_ST },
/* BTA_HH_INT_OPEN_EVT */ {BTA_HH_OPEN_ACT, BTA_HH_CONN_ST },
/* BTA_HH_INT_CLOSE_EVT */ {BTA_HH_CLOSE_ACT, BTA_HH_IDLE_ST },
/* BTA_HH_INT_DATA_EVT */ {BTA_HH_DATA_ACT, BTA_HH_CONN_ST },
/* BTA_HH_INT_CTRL_DATA */ {BTA_HH_CTRL_DAT_ACT, BTA_HH_CONN_ST },
/* BTA_HH_INT_HANDSK_EVT */ {BTA_HH_HANDSK_ACT, BTA_HH_CONN_ST },
/* BTA_HH_SDP_CMPL_EVT */ {BTA_HH_IGNORE, BTA_HH_CONN_ST },
/* BTA_HH_API_WRITE_DEV_EVT */ {BTA_HH_WRITE_DEV_ACT, BTA_HH_CONN_ST },
/* BTA_HH_API_GET_DSCP_EVT */ {BTA_HH_GET_DSCP_ACT, BTA_HH_CONN_ST },
/* BTA_HH_API_MAINT_DEV_EVT */ {BTA_HH_MAINT_DEV_ACT, BTA_HH_CONN_ST },
/* BTA_HH_OPEN_CMPL_EVT */ {BTA_HH_IGNORE, BTA_HH_CONN_ST }
/* Event Action Next state */
/* BTA_HH_API_OPEN_EVT */ {BTA_HH_IGNORE, BTA_HH_CONN_ST },
/* BTA_HH_API_CLOSE_EVT */ {BTA_HH_API_DISC_ACT, BTA_HH_CONN_ST },
/* BTA_HH_INT_OPEN_EVT */ {BTA_HH_OPEN_ACT, BTA_HH_CONN_ST },
/* BTA_HH_INT_CLOSE_EVT */ {BTA_HH_CLOSE_ACT, BTA_HH_IDLE_ST },
/* BTA_HH_INT_DATA_EVT */ {BTA_HH_DATA_ACT, BTA_HH_CONN_ST },
/* BTA_HH_INT_CTRL_DATA */ {BTA_HH_CTRL_DAT_ACT, BTA_HH_CONN_ST },
/* BTA_HH_INT_HANDSK_EVT */ {BTA_HH_HANDSK_ACT, BTA_HH_CONN_ST },
/* BTA_HH_SDP_CMPL_EVT */ {BTA_HH_IGNORE, BTA_HH_CONN_ST },
/* BTA_HH_API_WRITE_DEV_EVT */ {BTA_HH_WRITE_DEV_ACT, BTA_HH_CONN_ST },
/* BTA_HH_API_GET_DSCP_EVT */ {BTA_HH_GET_DSCP_ACT, BTA_HH_CONN_ST },
/* BTA_HH_API_MAINT_DEV_EVT */ {BTA_HH_MAINT_DEV_ACT, BTA_HH_CONN_ST },
/* BTA_HH_OPEN_CMPL_EVT */ {BTA_HH_IGNORE, BTA_HH_CONN_ST },
#if (defined BTA_HH_LE_INCLUDED && BTA_HH_LE_INCLUDED == TRUE)
/* BTA_HH_GATT_CLOSE_EVT */ , {BTA_HH_GATT_CLOSE, BTA_HH_IDLE_ST }
/* BTA_HH_GATT_OPEN_EVT */ , {BTA_HH_IGNORE, BTA_HH_CONN_ST }
/* BTA_HH_START_ENC_EVT */ , {BTA_HH_IGNORE, BTA_HH_CONN_ST }
/* BTA_HH_ENC_CMPL_EVT */ , {BTA_HH_IGNORE, BTA_HH_CONN_ST }
/* READ_CHAR_CMPL_EVT */ , {BTA_HH_LE_READ_CHAR, BTA_HH_CONN_ST }
/* WRITE_CHAR_CMPL_EVT*/ , {BTA_HH_LE_WRITE, BTA_HH_CONN_ST }
/* READ_DESCR_CMPL_EVT */ , {BTA_HH_LE_READ_DESCR, BTA_HH_CONN_ST } /* do not currently read any descr when connection up */
/* WRITE_DESCR_CMPL_EVT */ , {BTA_HH_WRITE_DESCR, BTA_HH_CONN_ST } /* do not currently write any descr when connection up */
/* SCPP_UPDATE_EVT */ , {BTA_HH_LE_UPDATE_SCPP, BTA_HH_CONN_ST }
/* BTA_HH_GATT_ENC_CMPL_EVT */ , {BTA_HH_IGNORE, BTA_HH_CONN_ST }
/* BTA_HH_GATT_CLOSE_EVT */ {BTA_HH_GATT_CLOSE, BTA_HH_IDLE_ST },
/* BTA_HH_GATT_OPEN_EVT */ {BTA_HH_IGNORE, BTA_HH_CONN_ST },
/* BTA_HH_START_ENC_EVT */ {BTA_HH_IGNORE, BTA_HH_CONN_ST },
/* BTA_HH_ENC_CMPL_EVT */ {BTA_HH_IGNORE, BTA_HH_CONN_ST },
/* READ_CHAR_CMPL_EVT */ {BTA_HH_LE_READ_CHAR, BTA_HH_CONN_ST },
/* WRITE_CHAR_CMPL_EVT */ {BTA_HH_LE_WRITE, BTA_HH_CONN_ST },
/* READ_DESCR_CMPL_EVT */ {BTA_HH_LE_READ_DESCR, BTA_HH_CONN_ST }, /* do not currently read any descr when connection up */
/* WRITE_DESCR_CMPL_EVT */ {BTA_HH_WRITE_DESCR, BTA_HH_CONN_ST }, /* do not currently write any descr when connection up */
/* SCPP_UPDATE_EVT */ {BTA_HH_LE_UPDATE_SCPP, BTA_HH_CONN_ST },
/* BTA_HH_GATT_ENC_CMPL_EVT */ {BTA_HH_IGNORE, BTA_HH_CONN_ST },
#endif
};
#if (defined BTA_HH_LE_INCLUDED && BTA_HH_LE_INCLUDED == TRUE)
const UINT8 bta_hh_st_w4_sec[][BTA_HH_NUM_COLS] = {
/* Event Action Next state */
/* BTA_HH_API_OPEN_EVT */ {BTA_HH_IGNORE, BTA_HH_W4_SEC },
/* BTA_HH_API_CLOSE_EVT */ {BTA_HH_API_DISC_ACT, BTA_HH_W4_SEC },
/* BTA_HH_INT_OPEN_EVT */ {BTA_HH_IGNORE, BTA_HH_W4_SEC },
/* BTA_HH_INT_CLOSE_EVT */ {BTA_HH_OPEN_FAILURE, BTA_HH_IDLE_ST },
/* BTA_HH_INT_DATA_EVT */ {BTA_HH_IGNORE, BTA_HH_W4_SEC },
/* BTA_HH_INT_CTRL_DATA */ {BTA_HH_IGNORE, BTA_HH_W4_SEC },
/* BTA_HH_INT_HANDSK_EVT */ {BTA_HH_IGNORE, BTA_HH_W4_SEC },
/* BTA_HH_SDP_CMPL_EVT */ {BTA_HH_IGNORE, BTA_HH_W4_SEC },
/* BTA_HH_API_WRITE_DEV_EVT */ {BTA_HH_IGNORE , BTA_HH_W4_SEC },
/* BTA_HH_API_GET_DSCP_EVT */ {BTA_HH_IGNORE, BTA_HH_W4_SEC },
/* BTA_HH_API_MAINT_DEV_EVT */ {BTA_HH_MAINT_DEV_ACT, BTA_HH_W4_SEC },
/* BTA_HH_OPEN_CMPL_EVT */ {BTA_HH_IGNORE, BTA_HH_W4_SEC },
/* BTA_HH_GATT_CLOSE_EVT */ {BTA_HH_LE_OPEN_FAIL, BTA_HH_IDLE_ST },
/* BTA_HH_GATT_OPEN_EVT */ {BTA_HH_IGNORE, BTA_HH_W4_SEC },
/* BTA_HH_START_ENC_EVT */ {BTA_HH_IGNORE, BTA_HH_W4_SEC },
/* BTA_HH_ENC_CMPL_EVT */ {BTA_HH_SEC_CMPL, BTA_HH_W4_CONN_ST },
/* READ_CHAR_CMPL_EVT */ {BTA_HH_IGNORE, BTA_HH_W4_SEC },
/* BTA_HH_GATT_WRITE_CMPL_EVT*/ {BTA_HH_IGNORE, BTA_HH_W4_SEC },
/* READ_DESCR_CMPL_EVT */ {BTA_HH_IGNORE, BTA_HH_W4_SEC },
/* WRITE_DESCR_CMPL_EVT */ {BTA_HH_IGNORE, BTA_HH_W4_SEC }
/* SCPP_UPDATE_EVT */ , {BTA_HH_IGNORE, BTA_HH_W4_SEC }
/* BTA_HH_GATT_ENC_CMPL_EVT */ , {BTA_HH_GATT_ENC_CMPL, BTA_HH_W4_SEC }
/* Event Action Next state */
/* BTA_HH_API_OPEN_EVT */ {BTA_HH_IGNORE, BTA_HH_W4_SEC },
/* BTA_HH_API_CLOSE_EVT */ {BTA_HH_API_DISC_ACT, BTA_HH_W4_SEC },
/* BTA_HH_INT_OPEN_EVT */ {BTA_HH_IGNORE, BTA_HH_W4_SEC },
/* BTA_HH_INT_CLOSE_EVT */ {BTA_HH_OPEN_FAILURE, BTA_HH_IDLE_ST },
/* BTA_HH_INT_DATA_EVT */ {BTA_HH_IGNORE, BTA_HH_W4_SEC },
/* BTA_HH_INT_CTRL_DATA */ {BTA_HH_IGNORE, BTA_HH_W4_SEC },
/* BTA_HH_INT_HANDSK_EVT */ {BTA_HH_IGNORE, BTA_HH_W4_SEC },
/* BTA_HH_SDP_CMPL_EVT */ {BTA_HH_IGNORE, BTA_HH_W4_SEC },
/* BTA_HH_API_WRITE_DEV_EVT */ {BTA_HH_IGNORE , BTA_HH_W4_SEC },
/* BTA_HH_API_GET_DSCP_EVT */ {BTA_HH_IGNORE, BTA_HH_W4_SEC },
/* BTA_HH_API_MAINT_DEV_EVT */ {BTA_HH_MAINT_DEV_ACT, BTA_HH_W4_SEC },
/* BTA_HH_OPEN_CMPL_EVT */ {BTA_HH_IGNORE, BTA_HH_W4_SEC },
/* BTA_HH_GATT_CLOSE_EVT */ {BTA_HH_LE_OPEN_FAIL, BTA_HH_IDLE_ST },
/* BTA_HH_GATT_OPEN_EVT */ {BTA_HH_IGNORE, BTA_HH_W4_SEC },
/* BTA_HH_START_ENC_EVT */ {BTA_HH_IGNORE, BTA_HH_W4_SEC },
/* BTA_HH_ENC_CMPL_EVT */ {BTA_HH_SEC_CMPL, BTA_HH_W4_CONN_ST },
/* READ_CHAR_CMPL_EVT */ {BTA_HH_IGNORE, BTA_HH_W4_SEC },
/* BTA_HH_GATT_WRITE_CMPL_EVT */ {BTA_HH_IGNORE, BTA_HH_W4_SEC },
/* READ_DESCR_CMPL_EVT */ {BTA_HH_IGNORE, BTA_HH_W4_SEC },
/* WRITE_DESCR_CMPL_EVT */ {BTA_HH_IGNORE, BTA_HH_W4_SEC },
/* SCPP_UPDATE_EVT */ {BTA_HH_IGNORE, BTA_HH_W4_SEC },
/* BTA_HH_GATT_ENC_CMPL_EVT */ {BTA_HH_GATT_ENC_CMPL, BTA_HH_W4_SEC },
};
#endif
@@ -337,7 +337,7 @@ void bta_hh_sm_execute(tBTA_HH_DEV_CB *p_cb, UINT16 event, tBTA_HH_DATA *p_data)
cback_event = BTA_HH_CLOSE_EVT;
cback_data.dev_status.status = BTA_HH_ERR_HDL;
cback_data.dev_status.handle = (UINT8)p_data->api_sndcmd.hdr.layer_specific;
cback_data.dev_status.handle = (UINT8)p_data->hdr.layer_specific;
break;
default:
components/bt/host/bluedroid/bta/hh/bta_hh_utils.c
+20 -15
View File
@@ -38,9 +38,6 @@
#define BTA_HH_KB_CAPS_LOCK 0x39 /* caps lock */
#define BTA_HH_KB_NUM_LOCK 0x53 /* num lock */
#define BTA_HH_MAX_RPT_CHARS 8
static const UINT8 bta_hh_mod_key_mask[BTA_HH_MOD_MAX_KEY] = {
BTA_HH_KB_CTRL_MASK,
BTA_HH_KB_SHIFT_MASK,
@@ -119,6 +116,10 @@ void bta_hh_clean_up_kdev(tBTA_HH_DEV_CB *p_cb)
{
UINT8 index;
if (!p_cb) {
return;
}
if (p_cb->hid_handle != BTA_HH_INVALID_HANDLE ) {
#if BTA_HH_LE_INCLUDED == TRUE
if (p_cb->is_le_device) {
@@ -287,10 +288,6 @@ void bta_hh_parse_keybd_rpt(tBTA_HH_BOOT_RPT *p_kb_data, UINT8 *p_report,
ctl_shift = *p_report++;
report_len--;
if (report_len > BTA_HH_MAX_RPT_CHARS) {
report_len = BTA_HH_MAX_RPT_CHARS;
}
memset (this_report, 0, BTA_HH_MAX_RPT_CHARS);
memset (p_data, 0, sizeof(tBTA_HH_KEYBD_RPT));
memcpy (this_report, p_report, report_len);
@@ -369,7 +366,7 @@ void bta_hh_parse_mice_rpt(tBTA_HH_BOOT_RPT *p_mice_data, UINT8 *p_report,
report_len=%d) called", p_report, report_len);
#endif
if (report_len < 3) {
if ((report_len < 3) || (p_report == NULL)) {
return;
}
@@ -417,6 +414,7 @@ tBTA_HH_STATUS bta_hh_read_ssr_param(BD_ADDR bd_addr, UINT16 *p_max_ssr_lat, UIN
tBTA_HH_CB *p_cb = &bta_hh_cb;
UINT8 i;
UINT16 ssr_max_latency;
for (i = 0; i < BTA_HH_MAX_KNOWN; i ++) {
if (memcmp(p_cb->kdev[i].addr, bd_addr, BD_ADDR_LEN) == 0) {
@@ -434,19 +432,26 @@ tBTA_HH_STATUS bta_hh_read_ssr_param(BD_ADDR bd_addr, UINT16 *p_max_ssr_lat, UIN
ssr_max_latency = BTA_HH_SSR_MAX_LATENCY_DEF;
}
* p_max_ssr_lat = ssr_max_latency;
if (p_max_ssr_lat) {
*p_max_ssr_lat = ssr_max_latency;
}
} else {
* p_max_ssr_lat = p_cb->kdev[i].dscp_info.ssr_max_latency;
if (p_max_ssr_lat) {
*p_max_ssr_lat = p_cb->kdev[i].dscp_info.ssr_max_latency;
}
}
if (p_cb->kdev[i].dscp_info.ssr_min_tout == HID_SSR_PARAM_INVALID) {
* p_min_ssr_tout = BTA_HH_SSR_MIN_TOUT_DEF;
if (p_min_ssr_tout) {
*p_min_ssr_tout = BTA_HH_SSR_MIN_TOUT_DEF;
}
} else {
* p_min_ssr_tout = p_cb->kdev[i].dscp_info.ssr_min_tout;
if (p_min_ssr_tout) {
*p_min_ssr_tout = p_cb->kdev[i].dscp_info.ssr_min_tout;
}
}
status = BTA_HH_OK;
status = BTA_HH_OK;
break;
}
}
@@ -540,4 +545,4 @@ void bta_hh_trace_dev_db(void)
APPL_TRACE_DEBUG("*********************************************************");
}
#endif
#endif /* HL_INCLUDED */
#endif /* BTA_HH_INCLUDED */
components/bt/host/bluedroid/bta/include/bta/bta_hh_api.h
+3 -3
View File
@@ -156,9 +156,9 @@ typedef struct {
/* configuration struct */
typedef struct {
UINT8 max_devt_spt; /* max number of types of devices spt */
tBTA_HH_SPT_TOD *p_devt_list; /* supported types of device list */
UINT16 sdp_db_size;
UINT8 max_devt_spt; /* max number of types of devices spt */
const tBTA_HH_SPT_TOD *p_devt_list; /* supported types of device list */
UINT16 sdp_db_size;
} tBTA_HH_CFG;
enum {
components/bt/host/bluedroid/btc/profile/std/hid/bta_hh_co.c
+9 -5
View File
@@ -1,6 +1,6 @@
#include <string.h>
#include "btc_hh.h"
#include "osi/allocator.h"
#include "string.h"
#if HID_HOST_INCLUDED == TRUE
/*******************************************************************************
@@ -12,9 +12,9 @@
*
* Returns void.
******************************************************************************/
void bta_hh_co_open(uint8_t dev_handle, uint8_t sub_class, tBTA_HH_ATTR_MASK attr_mask, uint8_t app_id)
void bta_hh_co_open(UINT8 dev_handle, UINT8 sub_class, tBTA_HH_ATTR_MASK attr_mask, UINT8 app_id)
{
uint32_t i;
UINT32 i;
btc_hh_device_t *p_dev = NULL;
if (dev_handle == BTA_HH_INVALID_HANDLE) {
@@ -73,9 +73,9 @@ void bta_hh_co_open(uint8_t dev_handle, uint8_t sub_class, tBTA_HH_ATTR_MASK att
*
* Returns void.
******************************************************************************/
void bta_hh_co_close(uint8_t dev_handle, uint8_t app_id)
void bta_hh_co_close(UINT8 dev_handle, UINT8 app_id)
{
uint32_t i;
UINT32 i;
btc_hh_device_t *p_dev = NULL;
APPL_TRACE_WARNING("%s: dev_handle = %d, app_id = %d", __func__, dev_handle, app_id);
@@ -129,6 +129,10 @@ void bta_hh_co_data(UINT8 dev_handle, UINT8 *p_rpt, UINT16 len, tBTA_HH_PROTO_MO
__func__, dev_handle, sub_class, mode, ctry_code, app_id);
do {
if ((p_rpt == NULL) || (len == 0)) {
ret = BTA_HH_ERR;
break;
}
if ((p_buf = osi_malloc(sizeof(BT_HDR) + len)) == NULL) {
APPL_TRACE_ERROR("%s malloc failed!", __func__);
ret = BTA_HH_ERR_NO_RES;
components/bt/host/bluedroid/btc/profile/std/hid/btc_hd.c
+126 -39
View File
@@ -28,6 +28,7 @@
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include "bta/bta_api.h"
@@ -46,13 +47,16 @@
#if HID_DEV_INCLUDED == TRUE
#include "bta_dm_int.h"
_Static_assert(sizeof(tBTA_HD_QOS_INFO) == sizeof(esp_hidd_qos_param_t),
"QoS layout must match between BTA and esp_hidd");
/* HD request events */
typedef enum { BTC_HD_DUMMY_REQ_EVT = 0 } btc_hd_req_evt_t;
/*******************************************************************************
* Static variables
******************************************************************************/
btc_hd_cb_t btc_hd_cb = {0};
static btc_hd_cb_t btc_hd_cb = {0};
// static tBTA_HD_APP_INFO app_info;
// static tBTA_HD_QOS_INFO in_qos;
@@ -64,7 +68,7 @@ btc_hd_cb_t btc_hd_cb = {0};
#define BTC_HD_APP_NAME_LEN 50
#define BTC_HD_APP_DESCRIPTION_LEN 50
#define BTC_HD_APP_PROVIDER_LEN 50
#define BTC_HD_APP_DESCRIPTOR_LEN 2048
#define BTC_HD_APP_DESCRIPTOR_LEN ESP_HIDD_APP_DESC_LIST_LEN_MAX
#define COD_HID_KEYBOARD 0x0540
#define COD_HID_POINTING 0x0580
#define COD_HID_COMBO 0x05C0
@@ -79,9 +83,9 @@ static void btc_hd_cb_arg_deep_free(btc_msg_t *msg);
static inline void btc_hd_cb_to_app(esp_hidd_cb_event_t event, esp_hidd_cb_param_t *param)
{
esp_hd_cb_t btc_hd_cb = (esp_hd_cb_t)btc_profile_cb_get(BTC_PID_HD);
if (btc_hd_cb) {
btc_hd_cb(event, param);
esp_hd_cb_t btc_hd_cbk = (esp_hd_cb_t)btc_profile_cb_get(BTC_PID_HD);
if (btc_hd_cbk) {
btc_hd_cbk(event, param);
}
}
@@ -174,13 +178,13 @@ static void bte_hd_evt(tBTA_HD_EVT event, tBTA_HD *p_data)
param_len = sizeof(tBTA_HD_CONN);
break;
case BTA_HD_GET_REPORT_EVT:
param_len += sizeof(tBTA_HD_GET_REPORT);
param_len = sizeof(tBTA_HD_GET_REPORT);
break;
case BTA_HD_SET_REPORT_EVT:
param_len = sizeof(tBTA_HD_SET_REPORT);
break;
case BTA_HD_SET_PROTOCOL_EVT:
param_len += sizeof(p_data->set_protocol);
param_len = sizeof(p_data->set_protocol);
break;
case BTA_HD_INTR_DATA_EVT:
param_len = sizeof(tBTA_HD_INTR_DATA);
@@ -262,7 +266,7 @@ static void btc_hd_deinit(void)
break;
}
btc_hd_cb.service_dereg_active = FALSE;
btc_hd_cb.service_dereg_active = false;
// unregister app will also release the connection
// and disable after receiving unregister event from lower layer
if (is_hidd_app_register()) {
@@ -296,6 +300,22 @@ static void btc_hd_register_app(esp_hidd_app_param_t *p_app_param, esp_hidd_qos_
BTC_TRACE_API("%s", __func__);
esp_hidd_status_t ret = ESP_HIDD_SUCCESS;
do {
if (!p_app_param || !p_in_qos || !p_out_qos) {
BTC_TRACE_ERROR("bad app_param(%p), in_qos(%p) or out_qos(%p)", p_app_param, p_in_qos, p_out_qos);
ret = ESP_HIDD_ERROR;
break;
}
if ((p_app_param->desc_list_len <= 0) || (p_app_param->desc_list_len > BTC_HD_APP_DESCRIPTOR_LEN) || !p_app_param->desc_list) {
BTC_TRACE_ERROR("bad desc_list_len (%d) or desc_list(%p)", p_app_param->desc_list_len, p_app_param->desc_list);
ret = ESP_HIDD_ERROR;
break;
}
if (!p_app_param->name || !p_app_param->description || !p_app_param->provider) {
BTC_TRACE_ERROR("bad name(%p), description(%p) or provider(%p)", p_app_param->name, p_app_param->description, p_app_param->provider);
ret = ESP_HIDD_ERROR;
break;
}
if (!is_hidd_init()) {
BTC_TRACE_ERROR("%s HD has not been initiated, shall init first!", __func__);
ret = ESP_HIDD_NEED_INIT;
@@ -312,20 +332,15 @@ static void btc_hd_register_app(esp_hidd_app_param_t *p_app_param, esp_hidd_qos_
break;
}
if (!p_app_param->name || !p_app_param->description || !p_app_param->provider ||
!p_app_param->desc_list || (p_app_param->desc_list_len <= 0)) {
ret = ESP_HIDD_ERROR;
break;
}
size_t name_len = strnlen(p_app_param->name, BTC_HD_APP_NAME_LEN);
size_t description_len = strnlen(p_app_param->description, BTC_HD_APP_DESCRIPTION_LEN);
size_t provider_len = strnlen(p_app_param->provider, BTC_HD_APP_PROVIDER_LEN);
size_t desc_list_len = (size_t)p_app_param->desc_list_len;
if ((btc_hd_cb.app_info.p_name = (char *)osi_malloc(name_len + 1)) == NULL ||
(btc_hd_cb.app_info.p_description = (char *)osi_malloc(description_len + 1)) == NULL ||
(btc_hd_cb.app_info.p_provider = (char *)osi_malloc(provider_len + 1)) == NULL ||
(btc_hd_cb.app_info.descriptor.dsc_list = (uint8_t *)osi_malloc(p_app_param->desc_list_len)) == NULL) {
(btc_hd_cb.app_info.descriptor.dsc_list = (uint8_t *)osi_malloc(desc_list_len)) == NULL) {
BTC_TRACE_ERROR(
"%s malloc app_info failed! p_name:%p, p_description:%p, p_provider:%p, descriptor.dsc_list:%p",
__func__, btc_hd_cb.app_info.p_name, btc_hd_cb.app_info.p_description, btc_hd_cb.app_info.p_provider,
@@ -339,22 +354,12 @@ static void btc_hd_register_app(esp_hidd_app_param_t *p_app_param, esp_hidd_qos_
btc_hd_cb.app_info.p_description[description_len] = '\0';
memcpy(btc_hd_cb.app_info.p_provider, p_app_param->provider, provider_len);
btc_hd_cb.app_info.p_provider[provider_len] = '\0';
memcpy(btc_hd_cb.app_info.descriptor.dsc_list, p_app_param->desc_list, p_app_param->desc_list_len);
memcpy(btc_hd_cb.app_info.descriptor.dsc_list, p_app_param->desc_list, desc_list_len);
btc_hd_cb.app_info.subclass = p_app_param->subclass;
btc_hd_cb.app_info.descriptor.dl_len = p_app_param->desc_list_len;
btc_hd_cb.in_qos.service_type = p_in_qos->service_type;
btc_hd_cb.in_qos.token_rate = p_in_qos->token_rate;
btc_hd_cb.in_qos.token_bucket_size = p_in_qos->token_bucket_size;
btc_hd_cb.in_qos.peak_bandwidth = p_in_qos->peak_bandwidth;
btc_hd_cb.in_qos.access_latency = p_in_qos->access_latency;
btc_hd_cb.in_qos.delay_variation = p_in_qos->delay_variation;
btc_hd_cb.out_qos.service_type = p_out_qos->service_type;
btc_hd_cb.out_qos.token_rate = p_out_qos->token_rate;
btc_hd_cb.out_qos.token_bucket_size = p_out_qos->token_bucket_size;
btc_hd_cb.out_qos.peak_bandwidth = p_out_qos->peak_bandwidth;
btc_hd_cb.out_qos.access_latency = p_out_qos->access_latency;
btc_hd_cb.out_qos.delay_variation = p_out_qos->delay_variation;
memcpy(&btc_hd_cb.in_qos, p_in_qos, sizeof(tBTA_HD_QOS_INFO));
memcpy(&btc_hd_cb.out_qos, p_out_qos, sizeof(tBTA_HD_QOS_INFO));
BTA_HdRegisterApp(&btc_hd_cb.app_info, &btc_hd_cb.in_qos, &btc_hd_cb.out_qos);
} while(0);
@@ -404,7 +409,7 @@ static void btc_hd_unregister_app(bool need_deinit)
ret = ESP_HIDD_BUSY;
break;
}
btc_hd_cb.service_dereg_active = TRUE;
btc_hd_cb.service_dereg_active = true;
if (need_deinit) {
btc_hd_cb.status = BTC_HD_DISABLING;
@@ -596,10 +601,10 @@ static void btc_hd_send_report(esp_hidd_report_type_t type, uint8_t id, uint16_t
if (type == ESP_HIDD_REPORT_TYPE_INTRDATA) {
report.type = ESP_HIDD_REPORT_TYPE_INPUT;
report.use_intr = TRUE;
report.use_intr = true;
} else {
report.type = (type & 0x03);
report.use_intr = FALSE;
report.use_intr = false;
}
report.id = id;
@@ -728,6 +733,19 @@ void btc_hd_call_arg_deep_free(btc_msg_t *msg)
case BTC_HD_SEND_REPORT_EVT:
utl_freebuf((void **)&arg->send_report.data);
break;
case BTC_HD_REGISTER_APP_EVT: {
esp_hidd_app_param_t *app_param = arg->register_app.app_param;
if (app_param) {
utl_freebuf((void **)&app_param->name);
utl_freebuf((void **)&app_param->description);
utl_freebuf((void **)&app_param->provider);
utl_freebuf((void **)&app_param->desc_list);
}
utl_freebuf((void **)&arg->register_app.app_param);
utl_freebuf((void **)&arg->register_app.in_qos);
utl_freebuf((void **)&arg->register_app.out_qos);
break;
}
default:
break;
}
@@ -817,7 +835,7 @@ void btc_hd_cb_handler(btc_msg_t *msg)
if (p_data->status == BTA_HD_OK){
btc_hd_cb.status = BTC_HD_DISABLED;
if (btc_hd_cb.service_dereg_active) {
btc_hd_cb.service_dereg_active = FALSE;
btc_hd_cb.service_dereg_active = false;
}
free_app_info_param();
memset(&btc_hd_cb, 0, sizeof(btc_hd_cb));
@@ -829,7 +847,7 @@ void btc_hd_cb_handler(btc_msg_t *msg)
break;
case BTA_HD_REGISTER_APP_EVT:
if (p_data->reg_status.status == BTA_HD_OK) {
btc_hd_cb.app_registered = TRUE;
btc_hd_cb.app_registered = true;
}
param.register_app.status = p_data->reg_status.status;
param.register_app.in_use = p_data->reg_status.in_use;
@@ -841,7 +859,7 @@ void btc_hd_cb_handler(btc_msg_t *msg)
btc_hd_cb_to_app(ESP_HIDD_REGISTER_APP_EVT, &param);
break;
case BTA_HD_UNREGISTER_APP_EVT:
btc_hd_cb.app_registered = FALSE;
btc_hd_cb.app_registered = false;
param.unregister_app.status = p_data->status;
btc_hd_cb_to_app(ESP_HIDD_UNREGISTER_APP_EVT, &param);
if (btc_hd_cb.status == BTC_HD_DISABLING) {
@@ -858,13 +876,13 @@ void btc_hd_cb_handler(btc_msg_t *msg)
// if (check_cod_hid(addr)) {
// /* Incoming connection from hid device, reject it */
// BTC_TRACE_WARNING("remote device is not hid host, disconnecting");
// btc_hd_cb.forced_disc = TRUE;
// btc_hd_cb.forced_disc = true;
// BTA_HdDisconnect();
// break;
// }
// btc_storage_set_hidd((bt_bdaddr_t *)&p_data->conn.bda);
btc_hd_cb.status = BTC_HD_CONNECTED;
btc_hd_cb.in_use = TRUE;
btc_hd_cb.in_use = true;
} else if (p_data->conn.conn_status == BTA_HD_CONN_STATE_DISCONNECTED) {
btc_hd_cb.status = BTC_HD_DISCONNECTED;
}
@@ -881,7 +899,7 @@ void btc_hd_cb_handler(btc_msg_t *msg)
bt_bdaddr_t *addr = (bt_bdaddr_t *)&p_data->conn.bda;
BTC_TRACE_WARNING("remote device was forcefully disconnected");
btc_hd_remove_device(*addr);
btc_hd_cb.forced_disc = FALSE;
btc_hd_cb.forced_disc = false;
break;
}
}
@@ -937,7 +955,7 @@ void btc_hd_cb_handler(btc_msg_t *msg)
btc_hd_cb_to_app(ESP_HIDD_CLOSE_EVT, &param);
}
btc_hd_cb.in_use = FALSE;
btc_hd_cb.in_use = false;
param.vc_unplug.status = p_data->conn.status;
param.vc_unplug.conn_status = p_data->conn.conn_status;
@@ -977,6 +995,75 @@ void btc_hd_arg_deep_copy(btc_msg_t *msg, void *p_dest, void *p_src)
BTC_TRACE_ERROR("%s %d osi_malloc failed\n", __func__, msg->act);
}
break;
case BTC_HD_REGISTER_APP_EVT: {
esp_hidd_app_param_t *src_app_param = src->register_app.app_param;
esp_hidd_qos_param_t *src_in_qos = src->register_app.in_qos;
esp_hidd_qos_param_t *src_out_qos = src->register_app.out_qos;
dst->register_app.app_param = NULL;
dst->register_app.in_qos = NULL;
dst->register_app.out_qos = NULL;
if (!src_app_param || !src_in_qos || !src_out_qos) {
BTC_TRACE_ERROR("bad app_param(%p), in_qos(%p) or out_qos(%p)", src_app_param, src_in_qos, src_out_qos);
break;
}
if ((src_app_param->desc_list_len <= 0) || (src_app_param->desc_list_len > BTC_HD_APP_DESCRIPTOR_LEN) || !src_app_param->desc_list) {
BTC_TRACE_ERROR("bad desc_list_len (%d) or desc_list(%p)", src_app_param->desc_list_len, src_app_param->desc_list);
break;
}
if (!src_app_param->name || !src_app_param->description || !src_app_param->provider) {
BTC_TRACE_ERROR("bad name(%p), description(%p) or provider(%p)", src_app_param->name, src_app_param->description, src_app_param->provider);
break;
}
esp_hidd_app_param_t *dst_app_param = (esp_hidd_app_param_t *)osi_malloc(sizeof(esp_hidd_app_param_t));
esp_hidd_qos_param_t *dst_in_qos = (esp_hidd_qos_param_t *)osi_malloc(sizeof(esp_hidd_qos_param_t));
esp_hidd_qos_param_t *dst_out_qos = (esp_hidd_qos_param_t *)osi_malloc(sizeof(esp_hidd_qos_param_t));
size_t name_len = strnlen(src_app_param->name, BTC_HD_APP_NAME_LEN);
size_t description_len = strnlen(src_app_param->description, BTC_HD_APP_DESCRIPTION_LEN);
size_t provider_len = strnlen(src_app_param->provider, BTC_HD_APP_PROVIDER_LEN);
size_t desc_list_len = (size_t)src_app_param->desc_list_len;
char *name = (char *)osi_malloc(name_len + 1);
char *description = (char *)osi_malloc(description_len + 1);
char *provider = (char *)osi_malloc(provider_len + 1);
uint8_t *desc_list = (uint8_t *)osi_malloc(desc_list_len);
if (!dst_app_param || !dst_in_qos || !dst_out_qos || !name || !description || !provider || !desc_list) {
BTC_TRACE_ERROR("%s %d osi_malloc failed\n", __func__, msg->act);
utl_freebuf((void **)&dst_app_param);
utl_freebuf((void **)&dst_in_qos);
utl_freebuf((void **)&dst_out_qos);
utl_freebuf((void **)&name);
utl_freebuf((void **)&description);
utl_freebuf((void **)&provider);
utl_freebuf((void **)&desc_list);
break;
}
memcpy(name, src_app_param->name, name_len);
name[name_len] = '\0';
memcpy(description, src_app_param->description, description_len);
description[description_len] = '\0';
memcpy(provider, src_app_param->provider, provider_len);
provider[provider_len] = '\0';
memcpy(desc_list, src_app_param->desc_list, desc_list_len);
dst_app_param->name = name;
dst_app_param->description = description;
dst_app_param->provider = provider;
dst_app_param->subclass = src_app_param->subclass;
dst_app_param->desc_list = desc_list;
dst_app_param->desc_list_len = src_app_param->desc_list_len;
memcpy(dst_in_qos, src_in_qos, sizeof(esp_hidd_qos_param_t));
memcpy(dst_out_qos, src_out_qos, sizeof(esp_hidd_qos_param_t));
dst->register_app.app_param = dst_app_param;
dst->register_app.in_qos = dst_in_qos;
dst->register_app.out_qos = dst_out_qos;
break;
}
default:
break;
}
@@ -1000,4 +1087,4 @@ void btc_hd_get_profile_status(esp_hidd_profile_status_t *param)
}
}
#endif // HID_DEV_INCLUDED==TRUE
#endif // HID_DEV_INCLUDED==true
components/bt/host/bluedroid/btc/profile/std/hid/btc_hh.c
+33 -7
View File
@@ -19,9 +19,9 @@
******************************************************************************/
/************************************************************************************
*
* Filename: btc_hd.c
* Filename: btc_hh.c
*
* Description: HID Device Profile Bluetooth Interface
* Description: HID Host Profile Bluetooth Interface
*
*
***********************************************************************************/
@@ -68,9 +68,9 @@ static void btc_hh_cb_arg_deep_free(btc_msg_t *msg);
static inline void btc_hh_cb_to_app(esp_hidh_cb_event_t event, esp_hidh_cb_param_t *param)
{
esp_hh_cb_t btc_hh_cb = (esp_hh_cb_t)btc_profile_cb_get(BTC_PID_HH);
if (btc_hh_cb) {
btc_hh_cb(event, param);
esp_hh_cb_t btc_hh_cbk = (esp_hh_cb_t)btc_profile_cb_get(BTC_PID_HH);
if (btc_hh_cbk) {
btc_hh_cbk(event, param);
}
}
@@ -367,6 +367,23 @@ static void bte_hh_arg_deep_copy(btc_msg_t *msg, void *p_dst, void *p_src)
}
break;
}
case BTA_HH_DATA_IND_EVT: {
BT_HDR *src_hdr = p_src_data->int_data.p_data;
p_dst_data->int_data.p_data = NULL;
if (src_hdr) {
p_dst_data->int_data.p_data = osi_malloc(sizeof(BT_HDR) + src_hdr->len);
if (p_dst_data->int_data.p_data == NULL) {
BTC_TRACE_ERROR("%s malloc int_data.p_data failed!", __func__);
p_dst_data->int_data.status = ESP_HIDH_ERR_NO_RES;
break;
}
BT_HDR *dst_hdr = p_dst_data->int_data.p_data;
memcpy(dst_hdr, src_hdr, sizeof(BT_HDR));
memcpy(dst_hdr->data, src_hdr->data + src_hdr->offset, src_hdr->len);
dst_hdr->offset = 0;
}
break;
}
default:
break;
}
@@ -425,6 +442,9 @@ static void bte_hh_evt(tBTA_HH_EVT event, tBTA_HH *p_data)
case BTA_HH_DATA_EVT:
param_len = sizeof(tBTA_HH_API_SENDDATA);
break;
case BTA_HH_DATA_IND_EVT:
param_len = sizeof(tBTA_HH_INTDATA);
break;
case BTA_HH_API_ERR_EVT:
param_len = 0;
break;
@@ -712,6 +732,11 @@ static void btc_hh_set_info(btc_hidh_args_t *arg)
esp_hidh_cb_param_t param;
tBTA_HH_DEV_DSCP_INFO dscp_info;
if (!arg->set_info.hid_info) {
ret = ESP_HIDH_ERR;
goto _error;
}
BTC_TRACE_DEBUG("%s: sub_class = 0x%02x, app_id = %d, vendor_id = 0x%04x, "
"product_id = 0x%04x, version= 0x%04x",
__func__, arg->set_info.hid_info->sub_class, arg->set_info.hid_info->app_id,
@@ -751,6 +776,7 @@ static void btc_hh_set_info(btc_hidh_args_t *arg)
} while(0);
utl_freebuf((void **)&dscp_info.descriptor.dsc_list);
_error:
if (ret != ESP_HIDH_OK) {
param.set_info.status = ret;
param.set_info.handle = BTA_HH_INVALID_HANDLE;
@@ -1255,7 +1281,7 @@ void btc_hh_cb_handler(btc_msg_t *msg)
}
if (p_data->status == BTA_HH_OK) {
// Clear the control block
for (uint8_t i = 0; i < BTC_HH_MAX_HID; i++) {
for (i = 0; i < BTC_HH_MAX_HID; i++) {
if (btc_hh_cb.devices[i].vup_timer) {
osi_alarm_free(btc_hh_cb.devices[i].vup_timer);
}
@@ -1495,7 +1521,7 @@ void btc_hh_cb_handler(btc_msg_t *msg)
break;
case BTA_HH_ADD_DEV_EVT:
BTC_TRACE_DEBUG("status = %d, handle = %d", p_data->dev_info.status, p_data->dev_info.handle);
for (uint8_t i = 0; i < BTC_HH_MAX_ADDED_DEV; i++) {
for (i = 0; i < BTC_HH_MAX_ADDED_DEV; i++) {
if (memcmp(btc_hh_cb.added_devices[i].bd_addr, p_data->dev_info.bda, BD_ADDR_LEN) == 0) {
if (p_data->dev_info.status == BTA_HH_OK) {
btc_hh_cb.added_devices[i].dev_handle = p_data->dev_info.handle;