/****************************************************************************** * * Copyright 2005-2012 Broadcom Corporation * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at: * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * ******************************************************************************/ /****************************************************************************** * * This file contains the HID host action functions. * ******************************************************************************/ #define LOG_TAG "bluetooth" // BTA_HH_INCLUDED #include "bt_target.h" // Must be first to define build configuration #if (BTA_HH_INCLUDED == TRUE) #include #include #include "bta/hh/bta_hh_int.h" #include "bta/include/bta_hh_api.h" #include "bta/include/bta_hh_co.h" #include "bta/sys/bta_sys.h" #include "main/shim/dumpsys.h" #include "osi/include/log.h" #include "osi/include/osi.h" // UNUSED_ATTR #include "stack/include/hiddefs.h" #include "stack/include/hidh_api.h" #include "types/raw_address.h" /***************************************************************************** * Constants ****************************************************************************/ namespace { constexpr char kBtmLogTag[] = "HIDH"; } /***************************************************************************** * Local Function prototypes ****************************************************************************/ static void bta_hh_cback(uint8_t dev_handle, const RawAddress& addr, uint8_t event, uint32_t data, BT_HDR* pdata); static tBTA_HH_STATUS bta_hh_get_trans_status(uint32_t result); static const char* bta_hh_get_w4_event(uint16_t event); static const char* bta_hh_hid_event_name(uint16_t event); /***************************************************************************** * Action Functions ****************************************************************************/ /******************************************************************************* * * Function bta_hh_api_enable * * Description Perform necessary operations to enable HID host. * * * Returns void * ******************************************************************************/ void bta_hh_api_enable(tBTA_HH_DATA* p_data) { tBTA_HH_STATUS status = BTA_HH_ERR; uint8_t xx; /* initialize BTE HID */ HID_HostInit(); memset(&bta_hh_cb, 0, sizeof(tBTA_HH_CB)); /* Register with L2CAP */ if (HID_HostRegister(bta_hh_cback) == HID_SUCCESS) { /* store parameters */ bta_hh_cb.p_cback = p_data->api_enable.p_cback; status = BTA_HH_OK; /* initialize device CB */ for (xx = 0; xx < BTA_HH_MAX_DEVICE; xx++) { bta_hh_cb.kdev[xx].state = BTA_HH_IDLE_ST; bta_hh_cb.kdev[xx].hid_handle = BTA_HH_INVALID_HANDLE; bta_hh_cb.kdev[xx].index = xx; } /* initialize control block map */ for (xx = 0; xx < BTA_HH_MAX_KNOWN; xx++) bta_hh_cb.cb_index[xx] = BTA_HH_IDX_INVALID; } if (status == BTA_HH_OK) { bta_hh_le_enable(); } else { /* signal BTA call back event */ tBTA_HH bta_hh; bta_hh.status = status; (*bta_hh_cb.p_cback)(BTA_HH_ENABLE_EVT, &bta_hh); } } /******************************************************************************* * * Function bta_hh_api_disable * * Description Perform necessary operations to disable HID host. * * * Returns void * ******************************************************************************/ void bta_hh_api_disable(void) { uint8_t xx; /* service is not enabled */ if (bta_hh_cb.p_cback == NULL) return; /* no live connection, signal DISC_CMPL_EVT directly */ if (!bta_hh_cb.cnt_num) { bta_hh_disc_cmpl(); } else /* otherwise, disconnect all live connections */ { bta_hh_cb.w4_disable = true; for (xx = 0; xx < BTA_HH_MAX_DEVICE; xx++) { /* send API_CLOSE event to every connected device */ if (bta_hh_cb.kdev[xx].state == BTA_HH_CONN_ST) { /* disconnect all connected devices */ bta_hh_sm_execute(&bta_hh_cb.kdev[xx], BTA_HH_API_CLOSE_EVT, NULL); } } } return; } /******************************************************************************* * * Function bta_hh_disc_cmpl * * Description All connections have been closed, disable service. * * * Returns void * ******************************************************************************/ void bta_hh_disc_cmpl(void) { LOG_DEBUG("Disconnect complete"); HID_HostDeregister(); bta_hh_le_deregister(); tBTA_HH_STATUS status = BTA_HH_OK; /* Deregister with lower layer */ if (HID_HostDeregister() != HID_SUCCESS) status = BTA_HH_ERR; bta_hh_cleanup_disable(status); #endif } /******************************************************************************* * * Function bta_hh_sdp_cback * * Description SDP callback function. * * Returns void * ******************************************************************************/ static void bta_hh_sdp_cback(uint16_t result, uint16_t attr_mask, tHID_DEV_SDP_INFO* sdp_rec) { tBTA_HH_DEV_CB* p_cb = bta_hh_cb.p_cur; uint8_t hdl = 0; tBTA_HH_STATUS status = BTA_HH_ERR_SDP; /* make sure sdp succeeded and hh has not been disabled */ if ((result == SDP_SUCCESS) && (p_cb != NULL)) { /* security is required for the connection, add attr_mask bit*/ attr_mask |= HID_SEC_REQUIRED; APPL_TRACE_EVENT("%s: p_cb: %d result 0x%02x, attr_mask 0x%02x, handle %x", __func__, p_cb, result, attr_mask, p_cb->hid_handle); /* check to see type of device is supported , and should not been added * before */ if (bta_hh_tod_spt(p_cb, sdp_rec->sub_class)) { /* if not added before */ if (p_cb->hid_handle == BTA_HH_INVALID_HANDLE) { /* add device/update attr_mask information */ if (HID_HostAddDev(p_cb->addr, attr_mask, &hdl) == HID_SUCCESS) { status = BTA_HH_OK; /* update cb_index[] map */ bta_hh_cb.cb_index[hdl] = p_cb->index; } else { p_cb->app_id = 0; } } else { hdl = p_cb->hid_handle; } /* else : incoming connection after SDP should update the SDP information * as well */ if (p_cb->app_id != 0) { /* update cb information with attr_mask, dscp_info etc. */ bta_hh_add_device_to_list(p_cb, hdl, attr_mask, &sdp_rec->dscp_info, sdp_rec->sub_class, sdp_rec->ssr_max_latency, sdp_rec->ssr_min_tout, p_cb->app_id); p_cb->dscp_info.ctry_code = sdp_rec->ctry_code; status = BTA_HH_OK; } } else /* type of device is not supported */ status = BTA_HH_ERR_TOD_UNSPT; } /* free disc_db when SDP is completed */ osi_free_and_reset((void**)&bta_hh_cb.p_disc_db); /* send SDP_CMPL_EVT into state machine */ tBTA_HH_DATA bta_hh_data; bta_hh_data.status = status; bta_hh_sm_execute(p_cb, BTA_HH_SDP_CMPL_EVT, &bta_hh_data); return; } /******************************************************************************* * * Function bta_hh_di_sdp_cback * * Description SDP DI callback function. * * Returns void * ******************************************************************************/ static void bta_hh_di_sdp_cback(tSDP_RESULT result) { tBTA_HH_DEV_CB* p_cb = bta_hh_cb.p_cur; tBTA_HH_STATUS status = BTA_HH_ERR_SDP; tSDP_DI_GET_RECORD di_rec; tHID_STATUS ret; APPL_TRACE_EVENT("%s: p_cb: %d result 0x%02x", __func__, p_cb, result); /* if DI record does not exist on remote device, vendor_id in * tBTA_HH_DEV_DSCP_INFO will be set to 0xffff and we will allow the * connection to go through. Spec mandates that DI record be set, but many * HID devices do not set this. So for IOP purposes, we allow the connection * to go through and update the DI record to invalid DI entry. */ if (((result == SDP_SUCCESS) || (result == SDP_NO_RECS_MATCH)) && (p_cb != NULL)) { if (result == SDP_SUCCESS && SDP_GetNumDiRecords(bta_hh_cb.p_disc_db) != 0) { /* always update information with primary DI record */ if (SDP_GetDiRecord(1, &di_rec, bta_hh_cb.p_disc_db) == SDP_SUCCESS) { bta_hh_update_di_info(p_cb, di_rec.rec.vendor, di_rec.rec.product, di_rec.rec.version, 0); } } else /* no DI recrod available */ { bta_hh_update_di_info(p_cb, BTA_HH_VENDOR_ID_INVALID, 0, 0, 0); } ret = HID_HostGetSDPRecord(p_cb->addr, bta_hh_cb.p_disc_db, p_bta_hh_cfg->sdp_db_size, bta_hh_sdp_cback); if (ret == HID_SUCCESS) { status = BTA_HH_OK; } else { APPL_TRACE_DEBUG("%s: HID_HostGetSDPRecord failed: Status 0x%2x", __func__, ret); } } if (status != BTA_HH_OK) { osi_free_and_reset((void**)&bta_hh_cb.p_disc_db); /* send SDP_CMPL_EVT into state machine */ tBTA_HH_DATA bta_hh_data; bta_hh_data.status = status; bta_hh_sm_execute(p_cb, BTA_HH_SDP_CMPL_EVT, &bta_hh_data); } return; } /******************************************************************************* * * Function bta_hh_start_sdp * * Description Start SDP service search, and obtain necessary SDP records. * Only one SDP service search request is allowed at the same * time. For every BTA_HhOpen API call, do SDP first unless SDP * has been done previously. * * Returns void * ******************************************************************************/ void bta_hh_start_sdp(tBTA_HH_DEV_CB* p_cb, const tBTA_HH_DATA* p_data) { tBTA_HH_STATUS status = BTA_HH_ERR_SDP; uint8_t hdl; p_cb->mode = p_data->api_conn.mode; bta_hh_cb.p_cur = p_cb; if (BTM_UseLeLink(p_data->api_conn.bd_addr)) { p_cb->is_le_device = true; bta_hh_le_open_conn(p_cb, p_data->api_conn.bd_addr); return; } /* if previously virtually cabled device, skip SDP */ if (p_cb->app_id) { status = BTA_HH_OK; APPL_TRACE_DEBUG("%s: skip SDP for known devices", __func__); if (p_cb->hid_handle == BTA_HH_INVALID_HANDLE) { if (HID_HostAddDev(p_cb->addr, p_cb->attr_mask, &hdl) == HID_SUCCESS) { /* update device CB with newly register device handle */ bta_hh_add_device_to_list(p_cb, hdl, p_cb->attr_mask, NULL, p_cb->sub_class, p_cb->dscp_info.ssr_max_latency, p_cb->dscp_info.ssr_min_tout, p_cb->app_id); /* update cb_index[] map */ bta_hh_cb.cb_index[hdl] = p_cb->index; } else status = BTA_HH_ERR_NO_RES; } tBTA_HH_DATA bta_hh_data; bta_hh_data.status = status; bta_hh_sm_execute(p_cb, BTA_HH_SDP_CMPL_EVT, &bta_hh_data); return; } /* GetSDPRecord. at one time only one SDP precedure can be active */ else if (!bta_hh_cb.p_disc_db) { bta_hh_cb.p_disc_db = (tSDP_DISCOVERY_DB*)osi_malloc(p_bta_hh_cfg->sdp_db_size); bta_hh_cb.p_cur = p_cb; /* do DI discovery first */ if (SDP_DiDiscover(p_data->api_conn.bd_addr, bta_hh_cb.p_disc_db, p_bta_hh_cfg->sdp_db_size, bta_hh_di_sdp_cback) != SDP_SUCCESS) { APPL_TRACE_DEBUG("%s: SDP_DiDiscover failed: Status 0x%2X", __func__, status); status = BTA_HH_ERR_SDP; osi_free_and_reset((void**)&bta_hh_cb.p_disc_db); } else { status = BTA_HH_OK; } } else if (bta_hh_cb.p_disc_db) { /* It is possible that there is incoming/outgoing collision case. DUT * initiated * HID connection at same time remote has connected L2CAP for HID control, * so SDP would be in progress, when this flow reaches here. Just do nothing * when the code reaches here, and ongoing SDP completion or failure will * handle this case. */ APPL_TRACE_DEBUG("%s: ignoring as SDP already in progress", __func__); return; } if (status != BTA_HH_OK) { tBTA_HH_DATA bta_hh_data; bta_hh_data.status = status; bta_hh_sm_execute(p_cb, BTA_HH_SDP_CMPL_EVT, &bta_hh_data); } return; } /******************************************************************************* * * Function bta_hh_sdp_cmpl * * Description When SDP completes, initiate a connection or report an error * depending on the SDP result. * * * Returns void * ******************************************************************************/ void bta_hh_sdp_cmpl(tBTA_HH_DEV_CB* p_cb, const tBTA_HH_DATA* p_data) { CHECK(p_data != nullptr); tBTA_HH_CONN conn_dat; tBTA_HH_STATUS status = p_data->status; APPL_TRACE_DEBUG("%s: status 0x%2X", __func__, p_data->status); /* initialize call back data */ memset((void*)&conn_dat, 0, sizeof(tBTA_HH_CONN)); conn_dat.handle = p_cb->hid_handle; conn_dat.bda = p_cb->addr; /* if SDP compl success */ if (status == BTA_HH_OK) { /* not incoming connection doing SDP, initiate a HID connection */ if (!p_cb->incoming_conn) { tHID_STATUS ret; /* open HID connection */ ret = HID_HostOpenDev(p_cb->hid_handle); APPL_TRACE_DEBUG("%s: HID_HostOpenDev returned=%d", __func__, ret); if (ret == HID_SUCCESS || ret == HID_ERR_ALREADY_CONN) { status = BTA_HH_OK; } else if (ret == HID_ERR_CONN_IN_PROCESS) { /* Connection already in progress, return from here, SDP * will be performed after connection is completed. */ APPL_TRACE_DEBUG("%s: connection already in progress", __func__); return; } else { APPL_TRACE_DEBUG("%s: HID_HostOpenDev failed: Status 0x%2X", __func__, ret); /* open fail, remove device from management device list */ HID_HostRemoveDev(p_cb->hid_handle); status = BTA_HH_ERR; } } else /* incoming connection SDP finish */ { bta_hh_sm_execute(p_cb, BTA_HH_OPEN_CMPL_EVT, NULL); } } if (status != BTA_HH_OK) { /* Check if this was incoming connection request from an unknown device * and connection failed due to missing HID Device SDP UUID * In above condition, disconnect the link as well as remove the * device from list of HID devices */ if ((status == BTA_HH_ERR_SDP) && (p_cb->incoming_conn) && (p_cb->app_id == 0)) { APPL_TRACE_ERROR("%s: SDP failed for incoming conn hndl: %d", __func__, p_cb->incoming_hid_handle); HID_HostRemoveDev(p_cb->incoming_hid_handle); } conn_dat.status = status; (*bta_hh_cb.p_cback)(BTA_HH_OPEN_EVT, (tBTA_HH*)&conn_dat); /* move state machine W4_CONN ->IDLE */ bta_hh_sm_execute(p_cb, BTA_HH_API_CLOSE_EVT, NULL); /* if this is an outgoing connection to an unknown device, clean up cb */ if (p_cb->app_id == 0 && !p_cb->incoming_conn) { /* clean up device control block */ bta_hh_clean_up_kdev(p_cb); } bta_hh_trace_dev_db(); } p_cb->incoming_conn = false; p_cb->incoming_hid_handle = BTA_HH_INVALID_HANDLE; return; } /******************************************************************************* * * Function bta_hh_api_disc_act * * Description HID Host initiate a disconnection. * * * Returns void * ******************************************************************************/ extern void btif_hh_remove_device(RawAddress bd_addr); void bta_hh_api_disc_act(tBTA_HH_DEV_CB* p_cb, const tBTA_HH_DATA* p_data) { CHECK(p_cb != nullptr); if (p_cb->is_le_device) { LOG_DEBUG("Host initiating close to le device:%s", PRIVATE_ADDRESS(p_cb->addr)); bta_hh_le_api_disc_act(p_cb); } else { const uint8_t hid_handle = (p_data != nullptr) ? static_cast(p_data->hdr.layer_specific) : p_cb->hid_handle; tHID_STATUS status = HID_HostCloseDev(hid_handle); if (status != HID_SUCCESS) { LOG_WARN("Failed closing classic device:%s status:%s", PRIVATE_ADDRESS(p_cb->addr), hid_status_text(status).c_str()); } else { LOG_DEBUG("Host initiated close to classic device:%s", PRIVATE_ADDRESS(p_cb->addr)); } tBTA_HH bta_hh = { .dev_status = {.status = (status == HID_SUCCESS) ? BTA_HH_OK : BTA_HH_ERR, .handle = hid_handle}, }; (*bta_hh_cb.p_cback)(BTA_HH_CLOSE_EVT, &bta_hh); } } /******************************************************************************* * * Function bta_hh_open_cmpl_act * * Description HID host connection completed * * * Returns void * ******************************************************************************/ void bta_hh_open_cmpl_act(tBTA_HH_DEV_CB* p_cb, const tBTA_HH_DATA* p_data) { tBTA_HH_CONN conn; uint8_t dev_handle = p_data ? (uint8_t)p_data->hid_cback.hdr.layer_specific : p_cb->hid_handle; memset((void*)&conn, 0, sizeof(tBTA_HH_CONN)); conn.handle = dev_handle; conn.bda = p_cb->addr; /* increase connection number */ bta_hh_cb.cnt_num++; /* initialize device driver */ bta_hh_co_open(p_cb->hid_handle, p_cb->sub_class, p_cb->attr_mask, p_cb->app_id); conn.status = p_cb->status; conn.le_hid = p_cb->is_le_device; conn.scps_supported = p_cb->scps_supported; BTM_LogHistory(kBtmLogTag, p_cb->addr, "Opened", base::StringPrintf( "%s initiator:%s", (p_cb->is_le_device) ? "le" : "classic", (p_cb->incoming_conn) ? "remote" : "local")); if (!p_cb->is_le_device) { /* inform role manager */ bta_sys_conn_open(BTA_ID_HH, p_cb->app_id, p_cb->addr); } /* set protocol mode when not default report mode */ if (p_cb->mode != BTA_HH_PROTO_RPT_MODE && !p_cb->is_le_device ) { if ((HID_HostWriteDev(dev_handle, HID_TRANS_SET_PROTOCOL, HID_PAR_PROTOCOL_BOOT_MODE, 0, 0, NULL)) != HID_SUCCESS) { /* HID connection is up, while SET_PROTO fail */ conn.status = BTA_HH_ERR_PROTO; (*bta_hh_cb.p_cback)(BTA_HH_OPEN_EVT, (tBTA_HH*)&conn); } else { conn.status = BTA_HH_OK; p_cb->w4_evt = BTA_HH_OPEN_EVT; } } else (*bta_hh_cb.p_cback)(BTA_HH_OPEN_EVT, (tBTA_HH*)&conn); p_cb->incoming_conn = false; p_cb->incoming_hid_handle = BTA_HH_INVALID_HANDLE; } /******************************************************************************* * * Function bta_hh_open_act * * Description HID host receive HID_OPEN_EVT . * * * Returns void * ******************************************************************************/ void bta_hh_open_act(tBTA_HH_DEV_CB* p_cb, const tBTA_HH_DATA* p_data) { tBTA_HH_API_CONN conn_data; uint8_t dev_handle = p_data ? (uint8_t)p_data->hid_cback.hdr.layer_specific : p_cb->hid_handle; APPL_TRACE_EVENT("%s: Device[%d] connected", __func__, dev_handle); /* SDP has been done */ if (p_cb->app_id != 0) { bta_hh_sm_execute(p_cb, BTA_HH_OPEN_CMPL_EVT, p_data); } else /* app_id == 0 indicates an incoming conenction request arrives without SDP * performed, do it first */ { p_cb->incoming_conn = true; /* store the handle here in case sdp fails - need to disconnect */ p_cb->incoming_hid_handle = dev_handle; memset(&conn_data, 0, sizeof(tBTA_HH_API_CONN)); conn_data.bd_addr = p_cb->addr; bta_hh_start_sdp(p_cb, (tBTA_HH_DATA*)&conn_data); } return; } /******************************************************************************* * * Function bta_hh_data_act * * Description HID Host process a data report * * * Returns void * ******************************************************************************/ void bta_hh_data_act(tBTA_HH_DEV_CB* p_cb, const tBTA_HH_DATA* p_data) { BT_HDR* pdata = p_data->hid_cback.p_data; uint8_t* p_rpt = (uint8_t*)(pdata + 1) + pdata->offset; bta_hh_co_data((uint8_t)p_data->hid_cback.hdr.layer_specific, p_rpt, pdata->len, p_cb->mode, p_cb->sub_class, p_cb->dscp_info.ctry_code, p_cb->addr, p_cb->app_id); osi_free_and_reset((void**)&pdata); } /******************************************************************************* * * Function bta_hh_handsk_act * * Description HID Host process a handshake acknowledgement. * * * Returns void * ******************************************************************************/ void bta_hh_handsk_act(tBTA_HH_DEV_CB* p_cb, const tBTA_HH_DATA* p_data) { APPL_TRACE_DEBUG("HANDSHAKE received for: event = %s data= %d", bta_hh_get_w4_event(p_cb->w4_evt), p_data->hid_cback.data); tBTA_HH bta_hh; memset(&bta_hh, 0, sizeof(tBTA_HH)); switch (p_cb->w4_evt) { /* GET_ transsaction, handshake indicate unsupported request */ case BTA_HH_GET_PROTO_EVT: bta_hh.hs_data.rsp_data.proto_mode = BTA_HH_PROTO_UNKNOWN; FALLTHROUGH_INTENDED; /* FALLTHROUGH */ case BTA_HH_GET_RPT_EVT: case BTA_HH_GET_IDLE_EVT: bta_hh.hs_data.handle = p_cb->hid_handle; /* if handshake gives an OK code for these transaction, fill in UNSUPT */ bta_hh.hs_data.status = bta_hh_get_trans_status(p_data->hid_cback.data); if (bta_hh.hs_data.status == BTA_HH_OK) bta_hh.hs_data.status = BTA_HH_HS_TRANS_NOT_SPT; if (p_cb->w4_evt == BTA_HH_GET_RPT_EVT) bta_hh_co_get_rpt_rsp(bta_hh.dev_status.handle, bta_hh.hs_data.status, NULL, 0); (*bta_hh_cb.p_cback)(p_cb->w4_evt, &bta_hh); p_cb->w4_evt = 0; break; /* acknoledgement from HID device for SET_ transaction */ case BTA_HH_SET_RPT_EVT: case BTA_HH_SET_PROTO_EVT: case BTA_HH_SET_IDLE_EVT: bta_hh.dev_status.handle = p_cb->hid_handle; bta_hh.dev_status.status = bta_hh_get_trans_status(p_data->hid_cback.data); if (p_cb->w4_evt == BTA_HH_SET_RPT_EVT) bta_hh_co_set_rpt_rsp(bta_hh.dev_status.handle, bta_hh.dev_status.status); (*bta_hh_cb.p_cback)(p_cb->w4_evt, &bta_hh); p_cb->w4_evt = 0; break; /* SET_PROTOCOL when open connection */ case BTA_HH_OPEN_EVT: bta_hh.conn.status = p_data->hid_cback.data ? BTA_HH_ERR_PROTO : BTA_HH_OK; bta_hh.conn.handle = p_cb->hid_handle; bta_hh.conn.bda = p_cb->addr; (*bta_hh_cb.p_cback)(p_cb->w4_evt, &bta_hh); bta_hh_trace_dev_db(); p_cb->w4_evt = 0; break; default: /* unknow transaction handshake response */ APPL_TRACE_DEBUG("unknown transaction type"); break; } /* transaction achknoledgement received, inform PM for mode change */ bta_sys_idle(BTA_ID_HH, p_cb->app_id, p_cb->addr); return; } /******************************************************************************* * * Function bta_hh_ctrl_dat_act * * Description HID Host process a data report from control channel. * * * Returns void * ******************************************************************************/ void bta_hh_ctrl_dat_act(tBTA_HH_DEV_CB* p_cb, const tBTA_HH_DATA* p_data) { BT_HDR* pdata = p_data->hid_cback.p_data; uint8_t* data = (uint8_t*)(pdata + 1) + pdata->offset; tBTA_HH_HSDATA hs_data; APPL_TRACE_DEBUG("Ctrl DATA received w4: event[%s]", bta_hh_get_w4_event(p_cb->w4_evt)); if (pdata->len == 0) { android_errorWriteLog(0x534e4554, "116108738"); p_cb->w4_evt = 0; osi_free_and_reset((void**)&pdata); return; } hs_data.status = BTA_HH_OK; hs_data.handle = p_cb->hid_handle; switch (p_cb->w4_evt) { case BTA_HH_GET_IDLE_EVT: hs_data.rsp_data.idle_rate = *data; break; case BTA_HH_GET_RPT_EVT: hs_data.rsp_data.p_rpt_data = pdata; bta_hh_co_get_rpt_rsp(hs_data.handle, hs_data.status, pdata->data, pdata->len); break; case BTA_HH_GET_PROTO_EVT: /* match up BTE/BTA report/boot mode def*/ hs_data.rsp_data.proto_mode = ((*data) == HID_PAR_PROTOCOL_REPORT) ? BTA_HH_PROTO_RPT_MODE : BTA_HH_PROTO_BOOT_MODE; APPL_TRACE_DEBUG("GET_PROTOCOL Mode = [%s]", (hs_data.rsp_data.proto_mode == BTA_HH_PROTO_RPT_MODE) ? "Report" : "Boot"); break; /* should not expect control DATA for SET_ transaction */ case BTA_HH_SET_PROTO_EVT: FALLTHROUGH_INTENDED; /* FALLTHROUGH */ case BTA_HH_SET_RPT_EVT: FALLTHROUGH_INTENDED; /* FALLTHROUGH */ case BTA_HH_SET_IDLE_EVT: FALLTHROUGH_INTENDED; /* FALLTHROUGH */ default: APPL_TRACE_DEBUG("invalid transaction type for DATA payload: 4_evt[%s]", bta_hh_get_w4_event(p_cb->w4_evt)); break; } /* inform PM for mode change */ bta_sys_busy(BTA_ID_HH, p_cb->app_id, p_cb->addr); bta_sys_idle(BTA_ID_HH, p_cb->app_id, p_cb->addr); (*bta_hh_cb.p_cback)(p_cb->w4_evt, (tBTA_HH*)&hs_data); p_cb->w4_evt = 0; osi_free_and_reset((void**)&pdata); } /******************************************************************************* * * Function bta_hh_open_failure * * Description report HID open failure when at wait for connection state * and receive device close event. * * * Returns void * ******************************************************************************/ void bta_hh_open_failure(tBTA_HH_DEV_CB* p_cb, const tBTA_HH_DATA* p_data) { tBTA_HH_CONN conn_dat; uint32_t reason = p_data->hid_cback.data; /* Reason for closing (32-bit) */ memset(&conn_dat, 0, sizeof(tBTA_HH_CONN)); conn_dat.handle = p_cb->hid_handle; conn_dat.status = (reason == HID_ERR_AUTH_FAILED) ? BTA_HH_ERR_AUTH_FAILED : BTA_HH_ERR; conn_dat.bda = p_cb->addr; HID_HostCloseDev(p_cb->hid_handle); /* Report OPEN fail event */ (*bta_hh_cb.p_cback)(BTA_HH_OPEN_EVT, (tBTA_HH*)&conn_dat); bta_hh_trace_dev_db(); /* clean up control block, but retain SDP info and device handle */ p_cb->vp = false; p_cb->w4_evt = 0; /* if no connection is active and HH disable is signaled, disable service */ if (bta_hh_cb.cnt_num == 0 && bta_hh_cb.w4_disable) { bta_hh_disc_cmpl(); } /* Error in opening hid connection, reset flags */ p_cb->incoming_conn = false; p_cb->incoming_hid_handle = BTA_HH_INVALID_HANDLE; } /******************************************************************************* * * Function bta_hh_close_act * * Description HID Host process a close event * * * Returns void * ******************************************************************************/ void bta_hh_close_act(tBTA_HH_DEV_CB* p_cb, const tBTA_HH_DATA* p_data) { tBTA_HH_CONN conn_dat; tBTA_HH_CBDATA disc_dat = {BTA_HH_OK, 0}; uint32_t reason = p_data->hid_cback.data; /* Reason for closing (32-bit) */ const bool l2cap_conn_fail = reason & HID_L2CAP_CONN_FAIL; const bool l2cap_req_fail = reason & HID_L2CAP_REQ_FAIL; const bool l2cap_cfg_fail = reason & HID_L2CAP_CFG_FAIL; const tHID_STATUS hid_status = static_cast(reason & 0xff); /* if HID_HDEV_EVT_VC_UNPLUG was received, report BTA_HH_VC_UNPLUG_EVT */ uint16_t event = p_cb->vp ? BTA_HH_VC_UNPLUG_EVT : BTA_HH_CLOSE_EVT; disc_dat.handle = p_cb->hid_handle; disc_dat.status = to_bta_hh_status(p_data->hid_cback.data); std::string overlay_fail = base::StringPrintf("%s %s %s", (l2cap_conn_fail) ? "l2cap_conn_fail" : "", (l2cap_req_fail) ? "l2cap_req_fail" : "", (l2cap_cfg_fail) ? "l2cap_cfg_fail" : ""); BTM_LogHistory(kBtmLogTag, p_cb->addr, "Closed", base::StringPrintf("%s reason %s %s", (p_cb->is_le_device) ? "le" : "classic", hid_status_text(hid_status).c_str(), overlay_fail.c_str())); /* Check reason for closing */ if ((reason & (HID_L2CAP_CONN_FAIL | HID_L2CAP_REQ_FAIL)) || /* Failure to initialize connection (page timeout or l2cap error) */ (reason == HID_ERR_AUTH_FAILED) || /* Authenication error (while initiating) */ (reason == HID_ERR_L2CAP_FAILED)) /* Failure creating l2cap connection */ { /* Failure in opening connection */ conn_dat.handle = p_cb->hid_handle; conn_dat.status = (reason == HID_ERR_AUTH_FAILED) ? BTA_HH_ERR_AUTH_FAILED : BTA_HH_ERR; conn_dat.bda = p_cb->addr; HID_HostCloseDev(p_cb->hid_handle); /* Report OPEN fail event */ (*bta_hh_cb.p_cback)(BTA_HH_OPEN_EVT, (tBTA_HH*)&conn_dat); bta_hh_trace_dev_db(); return; } /* otherwise report CLOSE/VC_UNPLUG event */ else { /* finaliza device driver */ bta_hh_co_close(p_cb->hid_handle, p_cb->app_id); /* inform role manager */ bta_sys_conn_close(BTA_ID_HH, p_cb->app_id, p_cb->addr); /* update total conn number */ bta_hh_cb.cnt_num--; if (disc_dat.status) disc_dat.status = BTA_HH_ERR; (*bta_hh_cb.p_cback)(event, (tBTA_HH*)&disc_dat); /* if virtually unplug, remove device */ if (p_cb->vp) { HID_HostRemoveDev(p_cb->hid_handle); bta_hh_clean_up_kdev(p_cb); } bta_hh_trace_dev_db(); } /* clean up control block, but retain SDP info and device handle */ p_cb->vp = false; p_cb->w4_evt = 0; /* if no connection is active and HH disable is signaled, disable service */ if (bta_hh_cb.cnt_num == 0 && bta_hh_cb.w4_disable) { bta_hh_disc_cmpl(); } return; } /******************************************************************************* * * Function bta_hh_get_dscp_act * * Description Get device report descriptor * * * Returns void * ******************************************************************************/ void bta_hh_get_dscp_act(tBTA_HH_DEV_CB* p_cb, UNUSED_ATTR const tBTA_HH_DATA* p_data) { if (p_cb->is_le_device) { bta_hh_le_get_dscp_act(p_cb); } else (*bta_hh_cb.p_cback)(BTA_HH_GET_DSCP_EVT, (tBTA_HH*)&p_cb->dscp_info); } /******************************************************************************* * * Function bta_hh_maint_dev_act * * Description HID Host maintain device list. * * * Returns void * ******************************************************************************/ void bta_hh_maint_dev_act(tBTA_HH_DEV_CB* p_cb, const tBTA_HH_DATA* p_data) { const tBTA_HH_MAINT_DEV* p_dev_info = &p_data->api_maintdev; tBTA_HH_DEV_INFO dev_info; uint8_t dev_handle; dev_info.status = BTA_HH_ERR; dev_info.handle = BTA_HH_INVALID_HANDLE; switch (p_dev_info->sub_event) { case BTA_HH_ADD_DEV_EVT: /* add a device */ dev_info.bda = p_dev_info->bda; /* initialize callback data */ if (p_cb->hid_handle == BTA_HH_INVALID_HANDLE) { if (BTM_UseLeLink(p_data->api_conn.bd_addr)) { p_cb->is_le_device = true; dev_info.handle = bta_hh_le_add_device(p_cb, p_dev_info); if (dev_info.handle != BTA_HH_INVALID_HANDLE) dev_info.status = BTA_HH_OK; } else if (HID_HostAddDev(p_dev_info->bda, p_dev_info->attr_mask, &dev_handle) == HID_SUCCESS) { dev_info.handle = dev_handle; dev_info.status = BTA_HH_OK; /* update DI information */ bta_hh_update_di_info(p_cb, p_dev_info->dscp_info.vendor_id, p_dev_info->dscp_info.product_id, p_dev_info->dscp_info.version, p_dev_info->dscp_info.flag); /* add to BTA device list */ bta_hh_add_device_to_list( p_cb, dev_handle, p_dev_info->attr_mask, &p_dev_info->dscp_info.descriptor, p_dev_info->sub_class, p_dev_info->dscp_info.ssr_max_latency, p_dev_info->dscp_info.ssr_min_tout, p_dev_info->app_id); /* update cb_index[] map */ bta_hh_cb.cb_index[dev_handle] = p_cb->index; } } else /* device already been added */ { dev_info.handle = p_cb->hid_handle; dev_info.status = BTA_HH_OK; } bta_hh_trace_dev_db(); break; case BTA_HH_RMV_DEV_EVT: /* remove device */ dev_info.handle = (uint8_t)p_dev_info->hdr.layer_specific; dev_info.bda = p_cb->addr; if (p_cb->is_le_device) { bta_hh_le_remove_dev_bg_conn(p_cb); bta_hh_sm_execute(p_cb, BTA_HH_API_CLOSE_EVT, NULL); bta_hh_clean_up_kdev(p_cb); } else { if (HID_HostRemoveDev(dev_info.handle) == HID_SUCCESS) { dev_info.status = BTA_HH_OK; /* remove from known device list in BTA */ bta_hh_clean_up_kdev(p_cb); } } break; default: APPL_TRACE_DEBUG("invalid command"); break; } (*bta_hh_cb.p_cback)(p_dev_info->sub_event, (tBTA_HH*)&dev_info); } /******************************************************************************* * * Function bta_hh_write_dev_act * * Description Write device action. can be SET/GET/DATA transaction. * * Returns void * ******************************************************************************/ static uint8_t convert_api_sndcmd_param(const tBTA_HH_CMD_DATA& api_sndcmd) { uint8_t api_sndcmd_param = api_sndcmd.param; if (api_sndcmd.t_type == HID_TRANS_SET_PROTOCOL) { api_sndcmd_param = (api_sndcmd.param == BTA_HH_PROTO_RPT_MODE) ? HID_PAR_PROTOCOL_REPORT : HID_PAR_PROTOCOL_BOOT_MODE; } return api_sndcmd_param; } void bta_hh_write_dev_act(tBTA_HH_DEV_CB* p_cb, const tBTA_HH_DATA* p_data) { tBTA_HH_CBDATA cbdata = {BTA_HH_OK, 0}; uint16_t event = (p_data->api_sndcmd.t_type - HID_TRANS_GET_REPORT) + BTA_HH_GET_RPT_EVT; if (p_cb->is_le_device) bta_hh_le_write_dev_act(p_cb, p_data); else { cbdata.handle = p_cb->hid_handle; /* match up BTE/BTA report/boot mode def */ const uint8_t api_sndcmd_param = convert_api_sndcmd_param(p_data->api_sndcmd); if (HID_HostWriteDev(p_cb->hid_handle, p_data->api_sndcmd.t_type, api_sndcmd_param, p_data->api_sndcmd.data, p_data->api_sndcmd.rpt_id, p_data->api_sndcmd.p_data) != HID_SUCCESS) { APPL_TRACE_ERROR("HID_HostWriteDev Error "); cbdata.status = BTA_HH_ERR; if (p_data->api_sndcmd.t_type != HID_TRANS_CONTROL && p_data->api_sndcmd.t_type != HID_TRANS_DATA) (*bta_hh_cb.p_cback)(event, (tBTA_HH*)&cbdata); else if (api_sndcmd_param == BTA_HH_CTRL_VIRTUAL_CABLE_UNPLUG) (*bta_hh_cb.p_cback)(BTA_HH_VC_UNPLUG_EVT, (tBTA_HH*)&cbdata); } else { switch (p_data->api_sndcmd.t_type) { case HID_TRANS_SET_PROTOCOL: FALLTHROUGH_INTENDED; /* FALLTHROUGH */ case HID_TRANS_GET_REPORT: FALLTHROUGH_INTENDED; /* FALLTHROUGH */ case HID_TRANS_SET_REPORT: FALLTHROUGH_INTENDED; /* FALLTHROUGH */ case HID_TRANS_GET_PROTOCOL: FALLTHROUGH_INTENDED; /* FALLTHROUGH */ case HID_TRANS_GET_IDLE: FALLTHROUGH_INTENDED; /* FALLTHROUGH */ case HID_TRANS_SET_IDLE: /* set w4_handsk event name for callback function use */ p_cb->w4_evt = event; break; case HID_TRANS_DATA: /* output report */ FALLTHROUGH_INTENDED; /* FALLTHROUGH */ case HID_TRANS_CONTROL: /* no handshake event will be generated */ /* if VC_UNPLUG is issued, set flag */ if (api_sndcmd_param == BTA_HH_CTRL_VIRTUAL_CABLE_UNPLUG) p_cb->vp = true; break; /* currently not expected */ case HID_TRANS_DATAC: default: APPL_TRACE_DEBUG("%s: cmd type = %d", __func__, p_data->api_sndcmd.t_type); break; } /* if not control type transaction, notify PM for energy control */ if (p_data->api_sndcmd.t_type != HID_TRANS_CONTROL) { /* inform PM for mode change */ bta_sys_busy(BTA_ID_HH, p_cb->app_id, p_cb->addr); bta_sys_idle(BTA_ID_HH, p_cb->app_id, p_cb->addr); } else if (api_sndcmd_param == BTA_HH_CTRL_SUSPEND) { bta_sys_sco_close(BTA_ID_HH, p_cb->app_id, p_cb->addr); } else if (api_sndcmd_param == BTA_HH_CTRL_EXIT_SUSPEND) { bta_sys_busy(BTA_ID_HH, p_cb->app_id, p_cb->addr); } } } return; } /***************************************************************************** * Static Function ****************************************************************************/ /******************************************************************************* * * Function bta_hh_cback * * Description BTA HH callback function. * * * Returns void * ******************************************************************************/ static void bta_hh_cback(uint8_t dev_handle, const RawAddress& addr, uint8_t event, uint32_t data, BT_HDR* pdata) { uint16_t sm_event = BTA_HH_INVALID_EVT; uint8_t xx = 0; APPL_TRACE_DEBUG("%s::HID_event [%s]", __func__, bta_hh_hid_event_name(event)); switch (event) { case HID_HDEV_EVT_OPEN: sm_event = BTA_HH_INT_OPEN_EVT; break; case HID_HDEV_EVT_CLOSE: sm_event = BTA_HH_INT_CLOSE_EVT; break; case HID_HDEV_EVT_INTR_DATA: sm_event = BTA_HH_INT_DATA_EVT; break; case HID_HDEV_EVT_HANDSHAKE: sm_event = BTA_HH_INT_HANDSK_EVT; break; case HID_HDEV_EVT_CTRL_DATA: sm_event = BTA_HH_INT_CTRL_DATA; break; case HID_HDEV_EVT_RETRYING: break; case HID_HDEV_EVT_INTR_DATC: case HID_HDEV_EVT_CTRL_DATC: /* Unhandled events: Free buffer for DATAC */ osi_free_and_reset((void**)&pdata); break; case HID_HDEV_EVT_VC_UNPLUG: for (xx = 0; xx < BTA_HH_MAX_DEVICE; xx++) { if (bta_hh_cb.kdev[xx].hid_handle == dev_handle) { bta_hh_cb.kdev[xx].vp = true; break; } } break; } if (sm_event != BTA_HH_INVALID_EVT) { tBTA_HH_CBACK_DATA* p_buf = (tBTA_HH_CBACK_DATA*)osi_malloc( sizeof(tBTA_HH_CBACK_DATA) + sizeof(BT_HDR)); p_buf->hdr.event = sm_event; p_buf->hdr.layer_specific = (uint16_t)dev_handle; p_buf->data = data; p_buf->addr = addr; p_buf->p_data = pdata; bta_sys_sendmsg(p_buf); } } /******************************************************************************* * * Function bta_hh_get_trans_status * * Description translate a handshake result code into BTA HH * status code * ******************************************************************************/ static tBTA_HH_STATUS bta_hh_get_trans_status(uint32_t result) { switch (result) { case HID_PAR_HANDSHAKE_RSP_SUCCESS: /* (0) */ return BTA_HH_OK; case HID_PAR_HANDSHAKE_RSP_NOT_READY: /* (1) */ case HID_PAR_HANDSHAKE_RSP_ERR_INVALID_REP_ID: /* (2) */ case HID_PAR_HANDSHAKE_RSP_ERR_UNSUPPORTED_REQ: /* (3) */ case HID_PAR_HANDSHAKE_RSP_ERR_INVALID_PARAM: /* (4) */ return (tBTA_HH_STATUS)result; case HID_PAR_HANDSHAKE_RSP_ERR_UNKNOWN: /* (14) */ case HID_PAR_HANDSHAKE_RSP_ERR_FATAL: /* (15) */ default: return BTA_HH_HS_ERROR; break; } } /***************************************************************************** * Debug Functions ****************************************************************************/ static const char* bta_hh_get_w4_event(uint16_t event) { switch (event) { case BTA_HH_GET_RPT_EVT: return "BTA_HH_GET_RPT_EVT"; case BTA_HH_SET_RPT_EVT: return "BTA_HH_SET_RPT_EVT"; case BTA_HH_GET_PROTO_EVT: return "BTA_HH_GET_PROTO_EVT"; case BTA_HH_SET_PROTO_EVT: return "BTA_HH_SET_PROTO_EVT"; case BTA_HH_GET_IDLE_EVT: return "BTA_HH_GET_IDLE_EVT"; case BTA_HH_SET_IDLE_EVT: return "BTA_HH_SET_IDLE_EVT"; case BTA_HH_OPEN_EVT: return "BTA_HH_OPEN_EVT"; default: return "Unknown event"; } } static const char* bta_hh_hid_event_name(uint16_t event) { switch (event) { case HID_HDEV_EVT_OPEN: return "HID_HDEV_EVT_OPEN"; case HID_HDEV_EVT_CLOSE: return "HID_HDEV_EVT_CLOSE"; case HID_HDEV_EVT_RETRYING: return "HID_HDEV_EVT_RETRYING"; case HID_HDEV_EVT_INTR_DATA: return "HID_HDEV_EVT_INTR_DATA"; case HID_HDEV_EVT_INTR_DATC: return "HID_HDEV_EVT_INTR_DATC"; case HID_HDEV_EVT_CTRL_DATA: return "HID_HDEV_EVT_CTRL_DATA"; case HID_HDEV_EVT_CTRL_DATC: return "HID_HDEV_EVT_CTRL_DATC"; case HID_HDEV_EVT_HANDSHAKE: return "HID_HDEV_EVT_HANDSHAKE"; case HID_HDEV_EVT_VC_UNPLUG: return "HID_HDEV_EVT_VC_UNPLUG"; default: return "Unknown HID event"; } }