diff options
| author | jacqueline <me@jacqueline.id.au> | 2025-07-25 13:33:07 +1000 |
|---|---|---|
| committer | jacqueline <me@jacqueline.id.au> | 2025-07-25 13:33:07 +1000 |
| commit | c8e79a926620e48830778714cfe4b2ea2453fcaf (patch) | |
| tree | 8c756e08e01b8e147cf72bec128026f46bd854c5 /lib/bt/host/bluedroid/stack/btm | |
| parent | 237136f3e93cb6b5be24670d7520adb17cc0fa36 (diff) | |
| download | tangara-fw-c8e79a926620e48830778714cfe4b2ea2453fcaf.tar.gz | |
Update forked idf components
Diffstat (limited to 'lib/bt/host/bluedroid/stack/btm')
22 files changed, 1853 insertions, 367 deletions
diff --git a/lib/bt/host/bluedroid/stack/btm/btm_acl.c b/lib/bt/host/bluedroid/stack/btm/btm_acl.c index 4b7e7eed..90506785 100644 --- a/lib/bt/host/bluedroid/stack/btm/btm_acl.c +++ b/lib/bt/host/bluedroid/stack/btm/btm_acl.c @@ -335,7 +335,7 @@ void btm_acl_created (BD_ADDR bda, DEV_CLASS dc, UINT8 bdn[BTM_MAX_REM_BD_NAME_L #if (CLASSIC_BT_INCLUDED == TRUE) const UINT8 req_pend = (p_dev_rec->sm4 & BTM_SM4_REQ_PEND); #endif ///CLASSIC_BT_INCLUDED == TRUE - /* Store the Peer Security Capabilites (in SM4 and rmt_sec_caps) */ + /* Store the Peer Security Capabilities (in SM4 and rmt_sec_caps) */ #if (SMP_INCLUDED == TRUE) btm_sec_set_peer_sec_caps(p, p_dev_rec); #endif ///SMP_INCLUDED == TRUE @@ -350,7 +350,7 @@ void btm_acl_created (BD_ADDR bda, DEV_CLASS dc, UINT8 bdn[BTM_MAX_REM_BD_NAME_L return; } } else { - /* If remote features indicated secure connection (SC) mode, check the remote feautres again*/ + /* If remote features indicated secure connection (SC) mode, check the remote features again*/ /* this is to prevent from BIAS attack where attacker can downgrade SC mode*/ btm_read_remote_features (p->hci_handle); } @@ -474,7 +474,7 @@ void btm_acl_removed (BD_ADDR bda, tBT_TRANSPORT transport) BTM_TRACE_DEBUG("Bonded\n"); } } else { - BTM_TRACE_DEBUG("Bletooth link down\n"); + BTM_TRACE_DEBUG("Bluetooth link down\n"); p_dev_rec->sec_flags &= ~(BTM_SEC_AUTHORIZED | BTM_SEC_AUTHENTICATED | BTM_SEC_ENCRYPTED | BTM_SEC_ROLE_SWITCHED); } @@ -531,10 +531,11 @@ void btm_acl_device_down (void) *******************************************************************************/ void btm_acl_update_busy_level (tBTM_BLI_EVENT event) { - tBTM_BL_UPDATE_DATA evt; - UINT8 busy_level; - BTM_TRACE_DEBUG ("btm_acl_update_busy_level\n"); + UINT8 busy_level_flags = 0; BOOLEAN old_inquiry_state = btm_cb.is_inquiry; + + BTM_TRACE_DEBUG ("btm_acl_update_busy_level\n"); + switch (event) { case BTM_BLI_ACL_UP_EVT: BTM_TRACE_DEBUG ("BTM_BLI_ACL_UP_EVT\n"); @@ -545,30 +546,31 @@ void btm_acl_update_busy_level (tBTM_BLI_EVENT event) case BTM_BLI_PAGE_EVT: BTM_TRACE_DEBUG ("BTM_BLI_PAGE_EVT\n"); btm_cb.is_paging = TRUE; - evt.busy_level_flags = BTM_BL_PAGING_STARTED; + busy_level_flags = BTM_BL_PAGING_STARTED; break; case BTM_BLI_PAGE_DONE_EVT: BTM_TRACE_DEBUG ("BTM_BLI_PAGE_DONE_EVT\n"); btm_cb.is_paging = FALSE; - evt.busy_level_flags = BTM_BL_PAGING_COMPLETE; + busy_level_flags = BTM_BL_PAGING_COMPLETE; break; case BTM_BLI_INQ_EVT: BTM_TRACE_DEBUG ("BTM_BLI_INQ_EVT\n"); btm_cb.is_inquiry = TRUE; - evt.busy_level_flags = BTM_BL_INQUIRY_STARTED; + busy_level_flags = BTM_BL_INQUIRY_STARTED; break; case BTM_BLI_INQ_CANCEL_EVT: BTM_TRACE_DEBUG ("BTM_BLI_INQ_CANCEL_EVT\n"); btm_cb.is_inquiry = FALSE; - evt.busy_level_flags = BTM_BL_INQUIRY_CANCELLED; + busy_level_flags = BTM_BL_INQUIRY_CANCELLED; break; case BTM_BLI_INQ_DONE_EVT: BTM_TRACE_DEBUG ("BTM_BLI_INQ_DONE_EVT\n"); btm_cb.is_inquiry = FALSE; - evt.busy_level_flags = BTM_BL_INQUIRY_COMPLETE; + busy_level_flags = BTM_BL_INQUIRY_COMPLETE; break; } + UINT8 busy_level; if (btm_cb.is_paging || btm_cb.is_inquiry) { busy_level = 10; } else { @@ -576,8 +578,11 @@ void btm_acl_update_busy_level (tBTM_BLI_EVENT event) } if ((busy_level != btm_cb.busy_level) || (old_inquiry_state != btm_cb.is_inquiry)) { - evt.event = BTM_BL_UPDATE_EVT; - evt.busy_level = busy_level; + tBTM_BL_UPDATE_DATA evt = { + .event = BTM_BL_UPDATE_EVT, + .busy_level = busy_level, + .busy_level_flags = busy_level_flags, + }; btm_cb.busy_level = busy_level; if (btm_cb.p_bl_changed_cb && (btm_cb.bl_evt_mask & BTM_BL_UPDATE_MASK)) { (*btm_cb.p_bl_changed_cb)((tBTM_BL_EVENT_DATA *)&evt); @@ -1016,7 +1021,7 @@ void btm_process_remote_ext_features (tACL_CONN *p_acl_cb, UINT8 num_read_pages) const UINT8 req_pend = (p_dev_rec->sm4 & BTM_SM4_REQ_PEND); #if (SMP_INCLUDED == TRUE) - /* Store the Peer Security Capabilites (in SM4 and rmt_sec_caps) */ + /* Store the Peer Security Capabilities (in SM4 and rmt_sec_caps) */ btm_sec_set_peer_sec_caps(p_acl_cb, p_dev_rec); #endif ///SMP_INCLUDED == TRUE BTM_TRACE_API("%s: pend:%d\n", __FUNCTION__, req_pend); @@ -1455,7 +1460,7 @@ void btm_process_clk_off_comp_evt (UINT16 hci_handle, UINT16 clock_offset) ** ** Function btm_acl_role_changed ** -** Description This function is called whan a link's master/slave role change +** Description This function is called when a link's master/slave role change ** event or command status event (with error) is received. ** It updates the link control block, and calls ** the registered callback with status and role (if registered). @@ -2060,6 +2065,7 @@ tBTM_STATUS BTM_ReadLinkQuality (BD_ADDR remote_bda, tBTM_CMPL_CB *p_cb) return (BTM_UNKNOWN_ADDR); } +#if (BLE_HOST_READ_TX_POWER_EN == TRUE) /******************************************************************************* ** ** Function BTM_ReadTxPower @@ -2116,6 +2122,7 @@ tBTM_STATUS BTM_ReadTxPower (BD_ADDR remote_bda, tBT_TRANSPORT transport, tBTM_C /* If here, no BD Addr found */ return (BTM_UNKNOWN_ADDR); } +#endif // #if (BLE_HOST_READ_TX_POWER_EN == TRUE) tBTM_STATUS BTM_SetAclPktTypes(BD_ADDR remote_bda, UINT16 pkt_types, tBTM_CMPL_CB *p_cb) { @@ -2182,6 +2189,55 @@ void btm_acl_pkt_types_changed(UINT8 status, UINT16 handle, UINT16 pkt_types) } #if (BLE_INCLUDED == TRUE) + +/******************************************************************************* +** +** Function BTM_ReadChannelMap +** +** Description This function is called to read the current channel map +** for the given connection. The results are returned via +** the callback (tBTM_BLE_CH_MAP_RESULTS). +** +** Returns BTM_CMD_STARTED if successfully initiated or error code +** +*******************************************************************************/ +tBTM_STATUS BTM_ReadChannelMap(BD_ADDR remote_bda, tBTM_CMPL_CB *p_cb) +{ + tACL_CONN *p; + tBTM_BLE_CH_MAP_RESULTS result; + + BTM_TRACE_DEBUG("BTM_ReadChannelMap: RemBdAddr: %02x%02x%02x%02x%02x%02x\n", + remote_bda[0], remote_bda[1], remote_bda[2], + remote_bda[3], remote_bda[4], remote_bda[5]); + + memset(result.channel_map, 0, sizeof(result.channel_map)); // Clear channel map data + /* If someone already waiting for the channel map, do not allow another */ + if (btm_cb.devcb.p_ble_ch_map_cmpl_cb) { + result.status = BTM_BUSY; + (*p_cb)(&result); + return BTM_BUSY; + } + p = btm_bda_to_acl(remote_bda, BT_TRANSPORT_LE); + if (p != NULL) { + btm_cb.devcb.p_ble_ch_map_cmpl_cb = p_cb; + + if (!btsnd_hcic_ble_read_chnl_map(p->hci_handle)) { + btm_cb.devcb.p_ble_ch_map_cmpl_cb = NULL; + result.status = BTM_NO_RESOURCES; + (*p_cb)(&result); + return BTM_NO_RESOURCES; + } else { + return BTM_CMD_STARTED; + } + } + + /* If here, no BD Addr found */ + result.status = BTM_UNKNOWN_ADDR; + (*p_cb)(&result); + return BTM_UNKNOWN_ADDR; +} + +#if (BLE_HOST_READ_TX_POWER_EN == TRUE) tBTM_STATUS BTM_BleReadAdvTxPower(tBTM_CMPL_CB *p_cb) { BOOLEAN ret; @@ -2208,6 +2264,7 @@ tBTM_STATUS BTM_BleReadAdvTxPower(tBTM_CMPL_CB *p_cb) return BTM_CMD_STARTED; } } +#endif // #if (BLE_HOST_READ_TX_POWER_EN == TRUE) void BTM_BleGetWhiteListSize(uint16_t *length) { @@ -2218,8 +2275,21 @@ void BTM_BleGetWhiteListSize(uint16_t *length) *length = p_cb->white_list_avail_size; return; } + +#if (BLE_50_EXTEND_SYNC_EN == TRUE) +void BTM_BleGetPeriodicAdvListSize(uint8_t *size) +{ + tBTM_BLE_CB *p_cb = &btm_cb.ble_ctr_cb; + if (p_cb->periodic_adv_list_size == 0) { + BTM_TRACE_WARNING("%s Periodic Adv list is full.", __func__); + } + *size = p_cb->periodic_adv_list_size; +} +#endif //#if (BLE_50_EXTEND_SYNC_EN == TRUE) + #endif ///BLE_INCLUDED == TRUE +#if (BLE_HOST_READ_TX_POWER_EN == TRUE) /******************************************************************************* ** ** Function btm_read_tx_power_complete @@ -2273,6 +2343,63 @@ void btm_read_tx_power_complete (UINT8 *p, BOOLEAN is_ble) (*p_cb)(&results); } } +#endif // #if (BLE_HOST_READ_TX_POWER_EN == TRUE) + +/******************************************************************************* +** +** Function btm_read_channel_map_complete +** +** Description This function is called when the command complete message +** is received from the HCI for the read channel map request. +** It processes the received channel map data and invokes the +** registered callback function with the results. +** +** Returns void +** +*******************************************************************************/ +void btm_read_channel_map_complete(UINT8 *p) +{ + tBTM_CMPL_CB *p_cb = btm_cb.devcb.p_ble_ch_map_cmpl_cb; + tBTM_BLE_CH_MAP_RESULTS results; + UINT16 handle; + tACL_CONN *p_acl_cb = NULL; + + BTM_TRACE_DEBUG("btm_read_channel_map_complete\n"); + + /* Reset the callback pointer to prevent duplicate calls */ + btm_cb.devcb.p_ble_ch_map_cmpl_cb = NULL; + + if (p_cb) { + /* Extract HCI status from the response */ + STREAM_TO_UINT8(results.hci_status, p); + + if (results.hci_status == HCI_SUCCESS) { + results.status = BTM_SUCCESS; + + /* Extract the connection handle and channel map */ + STREAM_TO_UINT16(handle, p); + STREAM_TO_ARRAY(results.channel_map, p, 5); + + BTM_TRACE_DEBUG("BTM Channel Map Complete: handle 0x%04x, hci status 0x%02x", handle, results.hci_status); + BTM_TRACE_DEBUG("Channel Map: %02x %02x %02x %02x %02x", + results.channel_map[0], results.channel_map[1], results.channel_map[2], + results.channel_map[3], results.channel_map[4]); + + /* Retrieve the remote BD address using the connection handle */ + p_acl_cb = btm_handle_to_acl(handle); + if (p_acl_cb) { + memcpy(results.rem_bda, p_acl_cb->remote_addr, BD_ADDR_LEN); + } + } else { + results.status = BTM_ERR_PROCESSING; + BTM_TRACE_ERROR("BTM Channel Map Read Failed: hci status 0x%02x", results.hci_status); + } + + /* Invoke the registered callback with the results */ + (*p_cb)(&results); + } +} + /******************************************************************************* ** @@ -2705,7 +2832,7 @@ void btm_acl_connected(BD_ADDR bda, UINT16 handle, UINT8 link_type, UINT8 enc_mo l2c_link_hci_conn_comp(status, handle, bda); } #if BTM_SCO_INCLUDED == TRUE - else { + else if (link_type == HCI_LINK_TYPE_SCO) { memset(&esco_data, 0, sizeof(tBTM_ESCO_DATA)); esco_data.link_type = HCI_LINK_TYPE_SCO; memcpy (esco_data.bd_addr, bda, BD_ADDR_LEN); @@ -2721,9 +2848,10 @@ void btm_acl_connected(BD_ADDR bda, UINT16 handle, UINT8 link_type, UINT8 enc_mo ** Description Handle ACL disconnection complete event ** *******************************************************************************/ -void btm_acl_disconnected(UINT16 handle, UINT8 reason) +BOOLEAN btm_acl_disconnected(UINT16 handle, UINT8 reason) { - + BOOLEAN status = FALSE; + BOOLEAN dis_status; /* Report BR/EDR ACL disconnection result to upper layer */ tACL_CONN *conn = btm_handle_to_acl(handle); if (conn) { @@ -2731,6 +2859,7 @@ void btm_acl_disconnected(UINT16 handle, UINT8 reason) if (conn->transport == BT_TRANSPORT_BR_EDR) #endif { + status = TRUE; tBTM_ACL_LINK_STAT_EVENT_DATA evt_data = { .event = BTM_ACL_DISCONN_CMPL_EVT, .link_act.disconn_cmpl.reason = reason, @@ -2742,16 +2871,29 @@ void btm_acl_disconnected(UINT16 handle, UINT8 reason) } #if BTM_SCO_INCLUDED == TRUE + dis_status = l2c_link_hci_disc_comp (handle, reason); /* If L2CAP doesn't know about it, send it to SCO */ - if (!l2c_link_hci_disc_comp (handle, reason)) { - btm_sco_removed (handle, reason); + if (!dis_status) { + dis_status = btm_sco_removed (handle, reason); + } else { + status = TRUE; } #else - l2c_link_hci_disc_comp(handle, reason); + dis_status = l2c_link_hci_disc_comp(handle, reason); #endif /* BTM_SCO_INCLUDED */ + if (dis_status) { + // find tL2C_LCB + status = TRUE; + } #if (SMP_INCLUDED == TRUE) /* Notify security manager */ - btm_sec_disconnected(handle, reason); + if (btm_sec_disconnected(handle, reason)) { + // find tBTM_SEC_DEV_REC + status = TRUE; + } + #endif /* SMP_INCLUDED == TRUE */ + + return status; } diff --git a/lib/bt/host/bluedroid/stack/btm/btm_ble.c b/lib/bt/host/bluedroid/stack/btm/btm_ble.c index 334001fe..8f676a65 100644 --- a/lib/bt/host/bluedroid/stack/btm/btm_ble.c +++ b/lib/bt/host/bluedroid/stack/btm/btm_ble.c @@ -217,7 +217,7 @@ void BTM_BleLoadLocalKeys(UINT8 key_type, tBTM_BLE_LOCAL_KEYS *p_key) break; default: - BTM_TRACE_ERROR("unknow local key type: %d", key_type); + BTM_TRACE_ERROR("unknown local key type: %d", key_type); break; } } @@ -553,6 +553,7 @@ void BTM_BleSecureConnectionCreateOobData(void) #endif } +#if (BLE_HOST_CONN_SCAN_PARAM_EN == TRUE) /****************************************************************************** ** ** Function BTM_BleSetConnScanParams @@ -582,15 +583,17 @@ void BTM_BleSetConnScanParams (UINT32 scan_interval, UINT32 scan_window) p_ble_cb->scan_win = scan_window; new_param = TRUE; } - +#if (tGATT_BG_CONN_DEV == TRUE) if (new_param && p_ble_cb->conn_state == BLE_BG_CONN) { btm_ble_suspend_bg_conn(); } +#endif // #if (tGATT_BG_CONN_DEV == TRUE) } else { BTM_TRACE_ERROR("Illegal Connection Scan Parameters"); } #endif } +#endif // #if (BLE_HOST_CONN_SCAN_PARAM_EN == TRUE) /******************************************************** ** @@ -694,7 +697,7 @@ void BTM_ReadDevInfo (BD_ADDR remote_bda, tBT_DEVICE_TYPE *p_dev_type, tBLE_ADDR BTM_TRACE_DEBUG ("btm_find_dev_type - unknown device, BR/EDR assumed"); } } - } else { /* there is a security device record exisitng */ + } else { /* there is a security device record existing */ /* new inquiry result, overwrite device type in security device record */ if (p_inq_info) { p_dev_rec->device_type = p_inq_info->results.device_type; @@ -707,7 +710,7 @@ void BTM_ReadDevInfo (BD_ADDR remote_bda, tBT_DEVICE_TYPE *p_dev_type, tBLE_ADDR } else if (memcmp(p_dev_rec->ble.pseudo_addr, remote_bda, BD_ADDR_LEN) == 0) { *p_dev_type = BT_DEVICE_TYPE_BLE; *p_addr_type = p_dev_rec->ble.ble_addr_type; - } else { /* matching static adddress only */ + } else { /* matching static address only */ *p_dev_type = BT_DEVICE_TYPE_BREDR; *p_addr_type = BLE_ADDR_PUBLIC; } @@ -766,6 +769,7 @@ BOOLEAN BTM_ReadConnectedTransportAddress(BD_ADDR remote_bda, tBT_TRANSPORT tran } #if (BLE_INCLUDED == TRUE) +#if (BLE_42_DTM_TEST_EN == TRUE) /******************************************************************************* ** ** Function BTM_BleReceiverTest @@ -805,7 +809,8 @@ void BTM_BleTransmitterTest(UINT8 tx_freq, UINT8 test_data_len, BTM_TRACE_ERROR("%s: Unable to Trigger LE transmitter test", __FUNCTION__); } } - +#endif // #if (BLE_42_DTM_TEST_EN == TRUE) +#if ((BLE_42_DTM_TEST_EN == TRUE) || (BLE_50_DTM_TEST_EN == TRUE)) /******************************************************************************* ** ** Function BTM_BleTestEnd @@ -837,9 +842,9 @@ void btm_ble_test_command_complete(UINT8 *p) (*p_cb)(p); } } +#endif // #if ((BLE_42_DTM_TEST_EN == TRUE) || (BLE_50_DTM_TEST_EN == TRUE)) - -#if (BLE_50_FEATURE_SUPPORT == TRUE) +#if (BLE_50_DTM_TEST_EN == TRUE) /******************************************************************************* ** ** Function BTM_BleEnhancedReceiverTest @@ -882,7 +887,7 @@ void BTM_BleEnhancedTransmitterTest(UINT8 tx_freq, UINT8 test_data_len, BTM_TRACE_ERROR("%s: Unable to Trigger LE enhanced transmitter test", __FUNCTION__); } } -#endif // BLE_50_FEATURE_SUPPORT +#endif // #if (BLE_50_DTM_TEST_EN == TRUE) /******************************************************************************* ** @@ -1061,7 +1066,7 @@ tBTM_SEC_ACTION btm_ble_determine_security_act(BOOLEAN is_originator, BD_ADDR bd ** LE link for LE COC. ** ** Parameter bdaddr: remote device address. -** psm : PSM of the LE COC sevice. +** psm : PSM of the LE COC service. ** is_originator: TRUE if outgoing connection. ** p_callback : Pointer to the callback function. ** p_ref_data : Pointer to be returned along with the callback. @@ -1078,7 +1083,7 @@ BOOLEAN btm_ble_start_sec_check(BD_ADDR bd_addr, UINT16 psm, BOOLEAN is_originat /* If there is no application registered with this PSM do not allow connection */ if (!p_serv_rec) { - BTM_TRACE_WARNING ("%s PSM: %d no application registerd", __func__, psm); + BTM_TRACE_WARNING ("%s PSM: %d no application registered", __func__, psm); (*p_callback) (bd_addr, BT_TRANSPORT_LE, p_ref_data, BTM_MODE_UNSUPPORTED); return FALSE; } @@ -1151,7 +1156,7 @@ void btm_ble_rand_enc_complete (UINT8 *p, UINT16 op_code, tBTM_RAND_ENC_CB *p_en /* If there was a callback address for vcs complete, call it */ if (p_enc_cplt_cback && p) { - /* Pass paramters to the callback function */ + /* Pass parameters to the callback function */ STREAM_TO_UINT8(params.status, p); /* command status */ if (params.status == HCI_SUCCESS) { @@ -1208,7 +1213,7 @@ void btm_ble_increment_sign_ctr(BD_ADDR bd_addr, BOOLEAN is_local ) ** Function btm_ble_get_enc_key_type ** ** Description This function is to get the BLE key type that has been exchanged -** in betweem local device and peer device. +** in between local device and peer device. ** ** Returns p_key_type: output parameter to carry the key type value. ** @@ -1235,7 +1240,7 @@ BOOLEAN btm_ble_get_enc_key_type(BD_ADDR bd_addr, UINT8 *p_key_types) ** ** Description This function is called to read the local DIV ** -** Returns TRUE - if a valid DIV is availavle +** Returns TRUE - if a valid DIV is available *******************************************************************************/ BOOLEAN btm_get_local_div (BD_ADDR bd_addr, UINT16 *p_div) { @@ -1487,7 +1492,7 @@ void btm_ble_link_sec_check(BD_ADDR bd_addr, tBTM_LE_AUTH_REQ auth_req, tBTM_BLE BTM_TRACE_DEBUG ("dev_rec sec_flags=0x%x", p_dev_rec->sec_flags); - /* currently encrpted */ + /* currently encrypted */ if (p_dev_rec->sec_flags & BTM_SEC_LE_ENCRYPTED) { if (p_dev_rec->sec_flags & BTM_SEC_LE_AUTHENTICATED) { cur_sec_level = BTM_LE_SEC_AUTHENTICATED; @@ -1691,7 +1696,7 @@ tBTM_STATUS btm_ble_start_encrypt(BD_ADDR bda, BOOLEAN use_stk, BT_OCTET16 stk) ** ** Function btm_ble_link_encrypted ** -** Description This function is called when LE link encrption status is changed. +** Description This function is called when LE link encryption status is changed. ** ** Returns void ** @@ -1949,7 +1954,7 @@ static void btm_ble_resolve_random_addr_on_conn_cmpl(void *p_rec, void *p_data) ** Function btm_ble_connected ** ** Description This function is when a LE connection to the peer device is -** establsihed +** established ** ** Returns void ** @@ -2060,7 +2065,7 @@ void btm_ble_conn_complete(UINT8 *p, UINT16 evt_len, BOOLEAN enhanced) peer_addr_type = bda_type; match = btm_identity_addr_to_random_pseudo (bda, &bda_type, FALSE); - /* possiblly receive connection complete with resolvable random on + /* possibly receive connection complete with resolvable random on slave role while the device has been paired */ /* It will cause that scanner doesn't send scan request to advertiser @@ -2143,6 +2148,16 @@ void btm_ble_create_ll_conn_complete (UINT8 status) if (status != HCI_SUCCESS) { btm_ble_set_conn_st(BLE_CONN_IDLE); btm_ble_update_mode_operation(HCI_ROLE_UNKNOWN, NULL, status); + if(l2cb.is_ble_connecting) { + /* see L2CA_CancelBleConnectReq() */ + tL2C_LCB *p_lcb = l2cu_find_lcb_by_bd_addr(l2cb.ble_connecting_bda, BT_TRANSPORT_LE); + /* Do not remove lcb if an LE link is already up as a peripheral */ + if (p_lcb != NULL && + !(p_lcb->link_role == HCI_ROLE_SLAVE && BTM_LE_ACL_IS_CONNECTED(l2cb.ble_connecting_bda))) { + p_lcb->disc_reason = L2CAP_CONN_CANCEL; + l2cu_release_lcb (p_lcb); + } + } } } @@ -2279,17 +2294,16 @@ UINT8 btm_proc_smp_cback(tSMP_EVT event, BD_ADDR bd_addr, tSMP_EVT_DATA *p_data) } - } else { - if (event == SMP_SC_LOC_OOB_DATA_UP_EVT) { - tBTM_LE_EVT_DATA evt_data; - memcpy(&evt_data.local_oob_data, &p_data->loc_oob_data, sizeof(tSMP_LOC_OOB_DATA)); - if (btm_cb.api.p_le_callback) { - (*btm_cb.api.p_le_callback)(event, bd_addr, &evt_data); - } - } else { - BTM_TRACE_ERROR("btm_proc_smp_cback received for unknown device"); + } + + if (event == SMP_SC_LOC_OOB_DATA_UP_EVT) { + tBTM_LE_EVT_DATA evt_data; + memcpy(&evt_data.local_oob_data, &p_data->loc_oob_data, sizeof(tSMP_LOC_OOB_DATA)); + if (btm_cb.api.p_le_callback) { + (*btm_cb.api.p_le_callback)(event, bd_addr, &evt_data); } } + return 0; } #endif ///SMP_INCLUDED == TRUE @@ -2300,7 +2314,7 @@ UINT8 btm_proc_smp_cback(tSMP_EVT event, BD_ADDR bd_addr, tSMP_EVT_DATA *p_data) ** Function BTM_BleDataSignature ** ** Description This function is called to sign the data using AES128 CMAC -** algorith. +** algorithm. ** ** Parameter bd_addr: target device the data to be signed for. ** p_text: singing data @@ -2308,7 +2322,7 @@ UINT8 btm_proc_smp_cback(tSMP_EVT event, BD_ADDR bd_addr, tSMP_EVT_DATA *p_data) ** signature: output parameter where data signature is going to ** be stored. ** -** Returns TRUE if signing sucessul, otherwise FALSE. +** Returns TRUE if signing successful, otherwise FALSE. ** *******************************************************************************/ #if (SMP_INCLUDED == TRUE) @@ -2491,7 +2505,7 @@ BOOLEAN BTM_BleSecurityProcedureIsRunning(BD_ADDR bd_addr) ** Function BTM_BleGetSupportedKeySize ** ** Description This function gets the maximum encryption key size in bytes -** the local device can suport. +** the local device can support. ** record. ** ** Returns the key size or 0 if the size can't be retrieved. @@ -2932,7 +2946,7 @@ uint8_t btm_ble_scan_active_count(void) } #if (SMP_INCLUDED == TRUE) -uint8_t btm_ble_sec_dev_active_count(void) +uint8_t btm_ble_sec_dev_record_count(void) { tBTM_SEC_DEV_REC *p_dev_rec = NULL; list_node_t *p_node = NULL; @@ -2948,6 +2962,12 @@ uint8_t btm_ble_sec_dev_active_count(void) return count; } + +void btm_ble_clear_sec_dev_record(void) +{ + /* only used when connection is closed */ + if(btm_cb.p_sec_dev_rec_list) list_clear(btm_cb.p_sec_dev_rec_list); +} #endif #if (BLE_PRIVACY_SPT == TRUE) diff --git a/lib/bt/host/bluedroid/stack/btm/btm_ble_5_gap.c b/lib/bt/host/bluedroid/stack/btm/btm_ble_5_gap.c index 04ad4804..76fe63c0 100644 --- a/lib/bt/host/bluedroid/stack/btm/btm_ble_5_gap.c +++ b/lib/bt/host/bluedroid/stack/btm/btm_ble_5_gap.c @@ -21,6 +21,7 @@ extern BOOLEAN BTM_GetLocalResolvablePrivateAddr(BD_ADDR bda); extern void BTM_UpdateAddrInfor(uint8_t addr_type, BD_ADDR bda); extern void BTM_BleSetStaticAddr(BD_ADDR rand_addr); extern uint32_t BTM_BleUpdateOwnType(uint8_t *own_bda_type, tBTM_START_ADV_CMPL_CBACK *cb); +#if (BLE_50_EXTEND_ADV_EN == TRUE) static tBTM_STATUS btm_ble_ext_adv_params_validate(tBTM_BLE_GAP_EXT_ADV_PARAMS *params); static tBTM_STATUS btm_ble_ext_adv_set_data_validate(UINT8 instance, UINT16 len, UINT8 *data); @@ -35,6 +36,8 @@ typedef struct { } tBTM_EXT_ADV_RECORD; tBTM_EXT_ADV_RECORD adv_record[MAX_BLE_ADV_INSTANCE] = {0}; +#endif // #if (BLE_50_EXTEND_ADV_EN == TRUE) + extern void btm_ble_inter_set(bool extble_inter); #if !UC_BT_STACK_NO_LOG @@ -193,11 +196,12 @@ void btm_ble_extendadvcb_init(void) { memset(&extend_adv_cb, 0, sizeof(tBTM_BLE_EXTENDED_CB)); } - +#if (BLE_50_EXTEND_ADV_EN == TRUE) void btm_ble_advrecod_init(void) { memset(&adv_record[0], 0, sizeof(tBTM_EXT_ADV_RECORD)*MAX_BLE_ADV_INSTANCE); } +#endif // #if (BLE_50_EXTEND_ADV_EN == TRUE) void BTM_BleGapRegisterCallback(tBTM_BLE_5_HCI_CBACK cb) { @@ -249,10 +253,10 @@ tBTM_STATUS BTM_BleSetPreferDefaultPhy(UINT8 tx_phy_mask, UINT8 rx_phy_mask) if ((err = btsnd_hcic_ble_set_prefered_default_phy(all_phys, tx_phy_mask, rx_phy_mask)) != HCI_SUCCESS) { BTM_TRACE_ERROR("%s, fail to send the hci command, the error code = %s(0x%x)", __func__, btm_ble_hci_status_to_str(err), err); - status = BTM_ILLEGAL_VALUE; + status = BTM_HCI_ERROR | err; } - cb_params.set_perf_def_phy.status = err; + cb_params.set_perf_def_phy.status = status; BTM_ExtBleCallbackTrigger(BTM_BLE_5_GAP_SET_PREFERED_DEFAULT_PHY_COMPLETE_EVT, &cb_params); @@ -286,6 +290,7 @@ tBTM_STATUS BTM_BleSetPreferPhy(BD_ADDR bd_addr, UINT8 all_phys, UINT8 tx_phy_ma return BTM_SUCCESS; } +#if (BLE_50_EXTEND_ADV_EN == TRUE) tBTM_STATUS BTM_BleSetExtendedAdvRandaddr(UINT8 instance, BD_ADDR rand_addr) { tBTM_STATUS status = BTM_SUCCESS; @@ -330,7 +335,7 @@ tBTM_STATUS BTM_BleSetExtendedAdvRandaddr(UINT8 instance, BD_ADDR rand_addr) if((err = btsnd_hcic_ble_set_extend_rand_address(instance, rand_addr)) != HCI_SUCCESS) { BTM_TRACE_ERROR("%s, fail to send the hci command, the error code = %s(0x%x)", __func__, btm_ble_hci_status_to_str(err), err); - status = BTM_ILLEGAL_VALUE; + status = BTM_HCI_ERROR | err; } else { // set random address success, update address info if(extend_adv_cb.inst[instance].configured && extend_adv_cb.inst[instance].connetable) { @@ -340,8 +345,8 @@ tBTM_STATUS BTM_BleSetExtendedAdvRandaddr(UINT8 instance, BD_ADDR rand_addr) } end: - cb_params.status = status; - + cb_params.set_ext_rand_addr.status = status; + cb_params.set_ext_rand_addr.instance = instance; BTM_ExtBleCallbackTrigger(BTM_BLE_5_GAP_EXT_ADV_SET_RAND_ADDR_COMPLETE_EVT, &cb_params); return status; @@ -403,7 +408,7 @@ tBTM_STATUS BTM_BleSetExtendedAdvParams(UINT8 instance, tBTM_BLE_GAP_EXT_ADV_PAR params->primary_phy, params->max_skip, params->secondary_phy, params->sid, params->scan_req_notif)) != HCI_SUCCESS) { BTM_TRACE_ERROR("LE EA SetParams: cmd err=0x%x", err); - status = BTM_ILLEGAL_VALUE; + status = BTM_HCI_ERROR | err; goto end; } @@ -414,13 +419,14 @@ end: // update RPA address if((err = btsnd_hcic_ble_set_extend_rand_address(instance, rand_addr)) != HCI_SUCCESS) { BTM_TRACE_ERROR("LE EA SetParams: cmd err=0x%x", err); - status = BTM_ILLEGAL_VALUE; + status = BTM_HCI_ERROR | err; } else { // set addr success, update address info BTM_UpdateAddrInfor(BLE_ADDR_RANDOM, rand_addr); } } - cb_params.status = status; + cb_params.set_params.status = status; + cb_params.set_params.instance = instance; BTM_ExtBleCallbackTrigger(BTM_BLE_5_GAP_EXT_ADV_SET_PARAMS_COMPLETE_EVT, &cb_params); return status; @@ -451,27 +457,36 @@ tBTM_STATUS BTM_BleConfigExtendedAdvDataRaw(BOOLEAN is_scan_rsp, UINT8 instance, } else if (rem_len <= BTM_BLE_EXT_ADV_DATA_LEN_MAX) { operation = BTM_BLE_ADV_DATA_OP_LAST_FRAG; } else { - operation = BTM_BLE_ADV_DATA_OP_INTERMEDIATE_FRAG; - } + operation = BTM_BLE_ADV_DATA_OP_INTERMEDIATE_FRAG; + } } if (!is_scan_rsp) { if ((err = btsnd_hcic_ble_set_ext_adv_data(instance, operation, 0, send_data_len, &data[data_offset])) != HCI_SUCCESS) { BTM_TRACE_ERROR("LE EA SetAdvData: cmd err=0x%x", err); - status = BTM_ILLEGAL_VALUE; + status = BTM_HCI_ERROR | err; + break; } } else { if ((err = btsnd_hcic_ble_set_ext_adv_scan_rsp_data(instance, operation, 0, send_data_len, &data[data_offset])) != HCI_SUCCESS) { BTM_TRACE_ERROR("LE EA SetScanRspData: cmd err=0x%x", err); - status = BTM_ILLEGAL_VALUE; + status = BTM_HCI_ERROR | err; + break; } } rem_len -= send_data_len; - data_offset += send_data_len; + data_offset += send_data_len; } while (rem_len); end: - cb_params.status = status; + if (is_scan_rsp) { + cb_params.scan_rsp_data_set.status = status; + cb_params.scan_rsp_data_set.instance = instance; + } else { + cb_params.adv_data_set.status = status; + cb_params.adv_data_set.instance = instance; + } + BTM_ExtBleCallbackTrigger(is_scan_rsp ? BTM_BLE_5_GAP_EXT_SCAN_RSP_DATA_SET_COMPLETE_EVT : BTM_BLE_5_GAP_EXT_ADV_DATA_SET_COMPLETE_EVT, &cb_params); return status; @@ -514,7 +529,7 @@ tBTM_STATUS BTM_BleStartExtAdv(BOOLEAN enable, UINT8 num, tBTM_BLE_EXT_ADV *ext_ if ((err = btsnd_hcic_ble_ext_adv_enable(enable, num, instance, duration, max_events)) != HCI_SUCCESS) { BTM_TRACE_ERROR("LE EA En=%d: cmd err=0x%x", enable, err); - status = BTM_ILLEGAL_VALUE; + status = BTM_HCI_ERROR | err; } osi_free(instance); @@ -525,7 +540,7 @@ tBTM_STATUS BTM_BleStartExtAdv(BOOLEAN enable, UINT8 num, tBTM_BLE_EXT_ADV *ext_ if ((err = btsnd_hcic_ble_ext_adv_enable(enable, num, NULL, NULL, NULL)) != HCI_SUCCESS) { BTM_TRACE_ERROR("LE EA En=%d: cmd err=0x%x", enable, err); - status = BTM_ILLEGAL_VALUE; + status = BTM_HCI_ERROR | err; } goto end; } @@ -574,7 +589,12 @@ end: } } - cb_params.status = status; + cb_params.adv_start.status = status; + cb_params.adv_start.instance_num = num; + for (uint8_t i = 0; i < num; i++) { + cb_params.adv_start.instance[i] = ext_adv[i].instance; + } + BTM_ExtBleCallbackTrigger(enable ? BTM_BLE_5_GAP_EXT_ADV_START_COMPLETE_EVT : BTM_BLE_5_GAP_EXT_ADV_STOP_COMPLETE_EVT, &cb_params); return status; @@ -593,6 +613,7 @@ tBTM_STATUS BTM_BleStartExtAdvRestart(uint8_t con_handle) } if((index >= MAX_BLE_ADV_INSTANCE) || (!adv_record[index].invalid)) { + BTM_TRACE_WARNING("%s failed to find extend adv, adv_handle %u con_handle %u", __func__, index, con_handle); return BTM_WRONG_MODE; } @@ -618,7 +639,7 @@ tBTM_STATUS BTM_BleExtAdvSetRemove(UINT8 instance) if ((err = btsnd_hcic_ble_remove_adv_set(instance)) != HCI_SUCCESS) { BTM_TRACE_ERROR("LE EAS Rm: cmd err=0x%x", err); - status = BTM_ILLEGAL_VALUE; + status = BTM_HCI_ERROR | err; } else { extend_adv_cb.inst[instance].configured = false; extend_adv_cb.inst[instance].legacy_pdu = false; @@ -629,7 +650,9 @@ tBTM_STATUS BTM_BleExtAdvSetRemove(UINT8 instance) end: - cb_params.status = status; + cb_params.adv_start.status = status; + cb_params.adv_start.instance_num = 1; + cb_params.adv_start.instance[0] = instance; BTM_ExtBleCallbackTrigger(BTM_BLE_5_GAP_EXT_ADV_SET_REMOVE_COMPLETE_EVT, &cb_params); @@ -644,7 +667,7 @@ tBTM_STATUS BTM_BleExtAdvSetClear(void) if ((err = btsnd_hcic_ble_clear_adv_set()) != HCI_SUCCESS) { BTM_TRACE_ERROR("LE EAS Clr: cmd err=0x%x", err); - status = BTM_ILLEGAL_VALUE; + status = BTM_HCI_ERROR | err; } else { for (uint8_t i = 0; i < MAX_BLE_ADV_INSTANCE; i++) { extend_adv_cb.inst[i].configured = false; @@ -655,13 +678,15 @@ tBTM_STATUS BTM_BleExtAdvSetClear(void) } } - cb_params.status = status; + cb_params.adv_start.status = status; BTM_ExtBleCallbackTrigger(BTM_BLE_5_GAP_EXT_ADV_SET_CLEAR_COMPLETE_EVT, &cb_params); return status; } +#endif // #if (BLE_50_EXTEND_ADV_EN == TRUE) +#if (BLE_50_PERIODIC_ADV_EN == TRUE) tBTM_STATUS BTM_BlePeriodicAdvSetParams(UINT8 instance, tBTM_BLE_Periodic_Adv_Params *params) { tBTM_STATUS status = BTM_SUCCESS; @@ -688,12 +713,13 @@ tBTM_STATUS BTM_BlePeriodicAdvSetParams(UINT8 instance, tBTM_BLE_Periodic_Adv_Pa if ((err= btsnd_hcic_ble_set_periodic_adv_params(instance, params->interval_min, params->interval_max, params->properties)) != HCI_SUCCESS) { BTM_TRACE_ERROR("LE PA SetParams: cmd err=0x%x", err); - status = BTM_ILLEGAL_VALUE; + status = BTM_HCI_ERROR | err; } end: - cb_params.status = status; + cb_params.per_adv_set_params.status = status; + cb_params.per_adv_set_params.instance = instance; BTM_ExtBleCallbackTrigger(BTM_BLE_5_GAP_PERIODIC_ADV_SET_PARAMS_COMPLETE_EVT, &cb_params); @@ -740,14 +766,18 @@ tBTM_STATUS BTM_BlePeriodicAdvCfgDataRaw(UINT8 instance, UINT16 len, UINT8 *data if ((err = btsnd_hcic_ble_set_periodic_adv_data(instance, operation, send_data_len, &data[data_offset])) != HCI_SUCCESS) { BTM_TRACE_ERROR("LE PA SetData: cmd err=0x%x", err); - status = BTM_ILLEGAL_VALUE; + status = BTM_HCI_ERROR | err; + break; } + rem_len -= send_data_len; - data_offset += send_data_len; + data_offset += send_data_len; } while(rem_len); end: - cb_params.status = status; + cb_params.per_adv_data_set.status = status; + cb_params.per_adv_data_set.instance = instance; + BTM_ExtBleCallbackTrigger(BTM_BLE_5_GAP_PERIODIC_ADV_DATA_SET_COMPLETE_EVT, &cb_params); return status; @@ -767,19 +797,26 @@ tBTM_STATUS BTM_BlePeriodicAdvEnable(UINT8 instance, UINT8 enable) if ((err = btsnd_hcic_ble_periodic_adv_enable(enable, instance)) != HCI_SUCCESS) { BTM_TRACE_ERROR("LE PA En=%d: cmd err=0x%x", enable, err); - status = BTM_ILLEGAL_VALUE; + status = BTM_HCI_ERROR | err; } end: - - cb_params.status = status; + if (enable) { + cb_params.per_adv_start.status = status; + cb_params.per_adv_start.instance = instance; + } else { + cb_params.per_adv_stop.status = status; + cb_params.per_adv_stop.instance = instance; + } BTM_ExtBleCallbackTrigger(enable ? BTM_BLE_5_GAP_PERIODIC_ADV_START_COMPLETE_EVT : BTM_BLE_5_GAP_PERIODIC_ADV_STOP_COMPLETE_EVT, &cb_params); return status; } +#endif // #if (BLE_50_PERIODIC_ADV_EN == TRUE) +#if (BLE_50_EXTEND_SYNC_EN == TRUE) tBTM_STATUS BTM_BlePeriodicAdvCreateSync(tBTM_BLE_Periodic_Sync_Params *params) { //tHCI_STATUS err = HCI_SUCCESS; @@ -794,10 +831,10 @@ tBTM_STATUS BTM_BlePeriodicAdvCreateSync(tBTM_BLE_Periodic_Sync_Params *params) if ((params->sync_timeout < 0x0a || params->sync_timeout > 0x4000) || (params->filter_policy > 0x01) - #if (CONFIG_BT_BLE_FEAT_CREATE_SYNC_ENH) +#if (BLE_FEAT_CREATE_SYNC_ENH == TRUE) || (params->reports_disabled > 0x01) || (params->filter_duplicates > 0x01) - #endif +#endif // (BLE_FEAT_CREATE_SYNC_ENH == TRUE) /*If the Periodic Advertiser List is not used, the Advertising_SID, Advertiser Address_Type, and Advertiser Address parameters specify the periodic advertising device to listen to; otherwise they @@ -814,17 +851,17 @@ tBTM_STATUS BTM_BlePeriodicAdvCreateSync(tBTM_BLE_Periodic_Sync_Params *params) SET_BIT(option, 0); } - #if (CONFIG_BT_BLE_FEAT_CREATE_SYNC_ENH) +#if (BLE_FEAT_CREATE_SYNC_ENH == TRUE) if (params->reports_disabled) { SET_BIT(option, 1); } if (params->filter_duplicates) { SET_BIT(option, 2); } - #endif +#endif // (BLE_FEAT_CREATE_SYNC_ENH == TRUE) if (!btsnd_hcic_ble_periodic_adv_create_sync(option, params->sid, params->addr_type, - params->addr, params->sync_timeout, 0)) { + params->addr, params->sync_timeout, params->sync_cte_type)) { BTM_TRACE_ERROR("LE PA CreateSync cmd failed"); status = BTM_ILLEGAL_VALUE; } @@ -837,6 +874,8 @@ end: return status; } +#endif // #if (BLE_50_EXTEND_SYNC_EN == TRUE) + void btm_set_phy_callback(UINT8 status) { tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0}; @@ -845,6 +884,8 @@ void btm_set_phy_callback(UINT8 status) BTM_ExtBleCallbackTrigger(BTM_BLE_5_GAP_SET_PREFERED_PHY_COMPLETE_EVT, &cb_params); } + +#if (BLE_50_EXTEND_SYNC_EN == TRUE) void btm_create_sync_callback(UINT8 status) { tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0}; @@ -852,6 +893,7 @@ void btm_create_sync_callback(UINT8 status) BTM_ExtBleCallbackTrigger(BTM_BLE_5_GAP_PERIODIC_ADV_CREATE_SYNC_COMPLETE_EVT, &cb_params); } +#endif // #if (BLE_50_EXTEND_SYNC_EN == TRUE) void btm_read_phy_callback(uint8_t hci_status, uint16_t conn_handle, uint8_t tx_phy, uint8_t rx_phy) { @@ -872,6 +914,7 @@ void btm_read_phy_callback(uint8_t hci_status, uint16_t conn_handle, uint8_t tx_ BTM_ExtBleCallbackTrigger(BTM_BLE_5_GAP_READ_PHY_COMPLETE_EVT, &cb_params); } +#if (BLE_50_EXTEND_SYNC_EN == TRUE) tBTM_STATUS BTM_BlePeriodicAdvSyncCancel(void) { tHCI_STATUS err = HCI_SUCCESS; @@ -880,7 +923,7 @@ tBTM_STATUS BTM_BlePeriodicAdvSyncCancel(void) if ((err = btsnd_hcic_ble_periodic_adv_create_sync_cancel()) != HCI_SUCCESS) { BTM_TRACE_ERROR("LE PA SyncCancel, cmd err=0x%x", err); - status = BTM_ILLEGAL_VALUE; + status = BTM_HCI_ERROR | err; } cb_params.status = status; @@ -898,7 +941,7 @@ tBTM_STATUS BTM_BlePeriodicAdvSyncTerm(UINT16 sync_handle) if (( err = btsnd_hcic_ble_periodic_adv_term_sync(sync_handle)) != HCI_SUCCESS) { BTM_TRACE_ERROR("LE PA SyncTerm: cmd err=0x%x", err); - status = BTM_ILLEGAL_VALUE; + status = BTM_HCI_ERROR | err; } cb_params.status = status; @@ -922,7 +965,7 @@ tBTM_STATUS BTM_BlePeriodicAdvAddDevToList(tBLE_ADDR_TYPE addr_type, BD_ADDR add if ((err = btsnd_hcic_ble_add_dev_to_periodic_adv_list(addr_type, addr, sid)) != HCI_SUCCESS) { BTM_TRACE_ERROR("LE PA AddDevToList: cmd err=0x%x", err); - status = BTM_ILLEGAL_VALUE; + status = BTM_HCI_ERROR | err; } end: @@ -946,7 +989,7 @@ tBTM_STATUS BTM_BlePeriodicAdvRemoveDevFromList(tBLE_ADDR_TYPE addr_type, BD_ADD if ((err = btsnd_hcic_ble_rm_dev_from_periodic_adv_list(addr_type, addr, sid)) != HCI_SUCCESS) { BTM_TRACE_ERROR("LE PA RmDevFromList: cmd err=0x%x", err); - status = BTM_ILLEGAL_VALUE; + status = BTM_HCI_ERROR | err; } end: @@ -964,7 +1007,7 @@ tBTM_STATUS BTM_BlePeriodicAdvClearDev(void) if ((err = btsnd_hcic_ble_clear_periodic_adv_list()) != HCI_SUCCESS) { BTM_TRACE_ERROR("LE PA ClrDev: cmd err=0x%x", err); - status = BTM_ILLEGAL_VALUE; + status = BTM_HCI_ERROR | err; } cb_params.status = status; @@ -972,7 +1015,9 @@ tBTM_STATUS BTM_BlePeriodicAdvClearDev(void) return status; } +#endif // #if (BLE_50_EXTEND_SYNC_EN == TRUE) +#if (BLE_50_EXTEND_SCAN_EN == TRUE) tBTM_STATUS BTM_BleSetExtendedScanParams(tBTM_BLE_EXT_SCAN_PARAMS *params) { UINT8 phy_mask = 0; @@ -1016,7 +1061,7 @@ tBTM_STATUS BTM_BleSetExtendedScanParams(tBTM_BLE_EXT_SCAN_PARAMS *params) if ((err = btsnd_hcic_ble_set_ext_scan_params(params->own_addr_type, params->filter_policy, phy_mask, phy_count, hci_params)) != HCI_SUCCESS) { BTM_TRACE_ERROR("LE ES SetParams: cmd err=0x%x", err); - status = BTM_ILLEGAL_VALUE; + status = BTM_HCI_ERROR | err; } end: @@ -1042,7 +1087,7 @@ tBTM_STATUS BTM_BleExtendedScan(BOOLEAN enable, UINT16 duration, UINT16 period) if ((err = btsnd_hcic_ble_ext_scan_enable(enable, extend_adv_cb.scan_duplicate, duration, period)) != HCI_SUCCESS) { BTM_TRACE_ERROR("LE ES En=%d: cmd err=0x%x", enable, err); - status = BTM_ILLEGAL_VALUE; + status = BTM_HCI_ERROR | err; } end: @@ -1053,22 +1098,28 @@ end: return status; } +#endif // #if (BLE_50_EXTEND_SCAN_EN == TRUE) void BTM_BleSetPreferExtenedConnParams (BD_ADDR bd_addr, tBTM_EXT_CONN_PARAMS *params) { tBTM_SEC_DEV_REC *p_dev_rec = btm_find_or_alloc_dev (bd_addr); + tBTM_STATUS status = BTM_SUCCESS; + tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0}; if (p_dev_rec) { if (params) { memcpy(&p_dev_rec->ext_conn_params, params, sizeof(tBTM_EXT_CONN_PARAMS)); } else { - BTM_TRACE_ERROR("Invalid Extand connection parameters"); + BTM_TRACE_ERROR("Invalid Extended connection parameters"); + status = BTM_ILLEGAL_VALUE; } } else { - BTM_TRACE_ERROR("Unknown Device, setting rejected"); + BTM_TRACE_ERROR("Unknown Device, setting rejected"); + status = BTM_UNKNOWN_ADDR; } - return; + cb_params.status = status; + BTM_ExtBleCallbackTrigger(BTM_BLE_5_GAP_PREFER_EXT_CONN_PARAMS_SET_COMPLETE_EVT, &cb_params); } void btm_ble_extended_init(void) @@ -1081,6 +1132,7 @@ void btm_ble_extended_cleanup(void) } +#if (BLE_50_EXTEND_ADV_EN == TRUE) static tBTM_STATUS btm_ble_ext_adv_params_validate(tBTM_BLE_GAP_EXT_ADV_PARAMS *params) { if (!params) { @@ -1157,6 +1209,7 @@ static tBTM_STATUS btm_ble_ext_adv_set_data_validate(UINT8 instance, UINT16 len, return BTM_SUCCESS; } +#endif // #if (BLE_50_EXTEND_ADV_EN == TRUE) void btm_ble_update_phy_evt(tBTM_BLE_UPDATE_PHY *params) { @@ -1184,11 +1237,14 @@ void btm_ble_update_phy_evt(tBTM_BLE_UPDATE_PHY *params) return; } +#if (BLE_50_EXTEND_SCAN_EN == TRUE) void btm_ble_scan_timeout_evt(void) { BTM_ExtBleCallbackTrigger(BTM_BLE_5_GAP_SCAN_TIMEOUT_EVT, NULL); } +#endif // #if (BLE_50_EXTEND_SCAN_EN == TRUE) +#if (BLE_50_EXTEND_ADV_EN == TRUE) void btm_ble_adv_set_terminated_evt(tBTM_BLE_ADV_TERMINAT *params) { tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0}; @@ -1199,7 +1255,7 @@ void btm_ble_adv_set_terminated_evt(tBTM_BLE_ADV_TERMINAT *params) } // adv terminated due to connection, save the adv handle and connection handle - if(params->completed_event == 0x00) { + if(params->status == 0x00) { adv_record[params->adv_handle].ter_con_handle = params->conn_handle; } else { adv_record[params->adv_handle].ter_con_handle = INVALID_VALUE; @@ -1214,7 +1270,9 @@ void btm_ble_adv_set_terminated_evt(tBTM_BLE_ADV_TERMINAT *params) return; } +#endif // #if (BLE_50_EXTEND_ADV_EN == TRUE) +#if (BLE_50_EXTEND_SCAN_EN == TRUE) void btm_ble_ext_adv_report_evt(tBTM_BLE_EXT_ADV_REPORT *params) { tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0}; @@ -1232,7 +1290,9 @@ void btm_ble_ext_adv_report_evt(tBTM_BLE_EXT_ADV_REPORT *params) return; } +#endif // #if (BLE_50_EXTEND_SCAN_EN == TRUE) +#if (BLE_50_EXTEND_ADV_EN == TRUE) void btm_ble_scan_req_received_evt(tBTM_BLE_SCAN_REQ_RECEIVED *params) { tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0}; @@ -1249,7 +1309,7 @@ void btm_ble_scan_req_received_evt(tBTM_BLE_SCAN_REQ_RECEIVED *params) return; } - +#endif // #if (BLE_50_EXTEND_ADV_EN == TRUE) void btm_ble_channel_select_algorithm_evt(tBTM_BLE_CHANNEL_SEL_ALG *params) { tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0}; @@ -1267,6 +1327,7 @@ void btm_ble_channel_select_algorithm_evt(tBTM_BLE_CHANNEL_SEL_ALG *params) return; } +#if (BLE_50_EXTEND_SYNC_EN == TRUE) void btm_ble_periodic_adv_report_evt(tBTM_PERIOD_ADV_REPORT *params) { tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0}; @@ -1320,7 +1381,9 @@ void btm_ble_periodic_adv_sync_establish_evt(tBTM_BLE_PERIOD_ADV_SYNC_ESTAB *par return; } +#endif // #if (BLE_50_EXTEND_SYNC_EN == TRUE) +#if (BLE_50_EXTEND_ADV_EN == TRUE) uint8_t btm_ble_ext_adv_active_count(void) { uint8_t count = 0; @@ -1333,6 +1396,7 @@ uint8_t btm_ble_ext_adv_active_count(void) return count; } +#endif // #if (BLE_50_EXTEND_ADV_EN == TRUE) #endif // #if (BLE_50_FEATURE_SUPPORT == TRUE) @@ -1378,7 +1442,7 @@ void BTM_BlePeriodicAdvRecvEnable(UINT16 sync_handle, UINT8 enable) if ((err = btsnd_hcic_ble_set_periodic_adv_recv_enable(sync_handle, enable)) != HCI_SUCCESS) { BTM_TRACE_ERROR("%s cmd err=0x%x", __func__, err); - status = BTM_ILLEGAL_VALUE; + status = BTM_HCI_ERROR | err; } cb_params.status = status; @@ -1437,7 +1501,7 @@ void BTM_BleSetPeriodicAdvSyncTransParams(BD_ADDR bd_addr, UINT8 mode, UINT16 sk tHCI_STATUS err = HCI_SUCCESS; if ((err = btsnd_hcic_ble_set_default_periodic_adv_sync_trans_params(mode, skip, sync_timeout, cte_type)) != HCI_SUCCESS) { BTM_TRACE_ERROR("%s cmd err=0x%x", __func__, err); - status = BTM_ILLEGAL_VALUE; + status = BTM_HCI_ERROR | err; } cb_params.set_past_params.status = status; @@ -1476,3 +1540,192 @@ void btm_ble_periodic_adv_sync_trans_recv_evt(tBTM_BLE_PERIOD_ADV_SYNC_TRANS_REC BTM_ExtBleCallbackTrigger(BTM_BLE_GAP_PERIODIC_ADV_SYNC_TRANS_RECV_EVT, &cb_params); } #endif // #if (BLE_FEAT_PERIODIC_ADV_SYNC_TRANSFER == TRUE) + +#if (BLE_FEAT_POWER_CONTROL_EN == TRUE) +void BTM_BleEnhReadTransPowerLevel(uint16_t conn_handle, uint8_t phy) +{ + btsnd_hcic_ble_enh_read_trans_power_level(conn_handle, phy); +} + +void BTM_BleReadRemoteTransPwrLevel(uint16_t conn_handle, uint8_t phy) +{ + btsnd_hcic_ble_read_remote_trans_power_level(conn_handle, phy); +} + +void BTM_BleSetPathLossRptParams(uint16_t conn_handle, uint8_t high_threshold, uint8_t high_hysteresis, + uint8_t low_threshold, uint8_t low_hysteresis, uint16_t min_time_spent) +{ + tBTM_STATUS status = BTM_SUCCESS; + tHCI_STATUS err = HCI_SUCCESS; + tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0}; + + if ((err = btsnd_hcic_ble_set_path_loss_rpt_params(conn_handle, high_threshold, high_hysteresis, low_threshold, low_hysteresis, min_time_spent)) != HCI_SUCCESS) { + BTM_TRACE_ERROR("%s cmd err=0x%x", __func__, err); + status = BTM_HCI_ERROR | err; + } + + cb_params.path_loss_rpting_params.status = status; + cb_params.path_loss_rpting_params.conn_handle = conn_handle; + + BTM_ExtBleCallbackTrigger(BTM_BLE_GAP_SET_PATH_LOSS_REPORTING_PARAMS_EVT, &cb_params); +} + +void BTM_BleSetPathLossRptEnable(uint16_t conn_handle, uint8_t enable) +{ + tBTM_STATUS status = BTM_SUCCESS; + tHCI_STATUS err = HCI_SUCCESS; + tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0}; + + if ((err = btsnd_hcic_ble_set_path_loss_rpt_enable(conn_handle, enable)) != HCI_SUCCESS) { + BTM_TRACE_ERROR("%s cmd err=0x%x", __func__, err); + status = BTM_HCI_ERROR | err; + } + + cb_params.path_loss_rpting_enable.status = status; + cb_params.path_loss_rpting_enable.conn_handle = conn_handle; + + BTM_ExtBleCallbackTrigger(BTM_BLE_GAP_SET_PATH_LOSS_REPORTING_ENABLE_EVT, &cb_params); +} + +void BTM_BleSetTransPwrRptEnable(uint16_t conn_handle, uint8_t local_enable, uint8_t remote_enable) +{ + tBTM_STATUS status = BTM_SUCCESS; + tHCI_STATUS err = HCI_SUCCESS; + tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0}; + + if ((err = btsnd_hcic_ble_set_trans_pwr_rpt_enable(conn_handle, local_enable, remote_enable)) != HCI_SUCCESS) { + BTM_TRACE_ERROR("%s cmd err=0x%x", __func__, err); + status = BTM_HCI_ERROR | err; + } + + cb_params.trans_pwr_rpting_enable.status = status; + cb_params.trans_pwr_rpting_enable.conn_handle = conn_handle; + + BTM_ExtBleCallbackTrigger(BTM_BLE_GAP_SET_TRANS_POWER_REPORTING_ENABLE_EVT, &cb_params); +} + +void btm_enh_read_trans_pwr_level_cmpl_evt(uint8_t *p) +{ + uint8_t hci_status; + tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0}; + + STREAM_TO_UINT8(hci_status, p); + STREAM_TO_UINT16(cb_params.enh_trans_pwr_level_cmpl.conn_handle, p); + STREAM_TO_UINT8(cb_params.enh_trans_pwr_level_cmpl.phy, p); + STREAM_TO_UINT8(cb_params.enh_trans_pwr_level_cmpl.cur_tx_pwr_level, p); + STREAM_TO_UINT8(cb_params.enh_trans_pwr_level_cmpl.max_tx_pwr_level, p); + + if(hci_status != HCI_SUCCESS) { + hci_status = BTM_HCI_ERROR | hci_status; + BTM_TRACE_ERROR("%s error status %d", __func__, hci_status); + } + cb_params.enh_trans_pwr_level_cmpl.status = hci_status; + + BTM_ExtBleCallbackTrigger(BTM_BLE_GAP_ENH_READ_TRANS_POWER_LEVEL_EVT, &cb_params); +} + +void btm_read_remote_trans_pwr_level_cmpl(UINT8 status) +{ + tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0}; + + if (status != HCI_SUCCESS) { + status = (status | BTM_HCI_ERROR); + } + + cb_params.remote_pwr_level_cmpl.status = status; + + BTM_ExtBleCallbackTrigger(BTM_BLE_GAP_READ_REMOTE_TRANS_POWER_LEVEL_EVT, &cb_params); +} + +void btm_ble_path_loss_threshold_evt(tBTM_BLE_PATH_LOSS_THRESHOLD_EVT *params) +{ + if (!params) { + BTM_TRACE_ERROR("%s, Invalid params.", __func__); + return; + } + + // If the user has register the callback function, should callback it to the application. + BTM_ExtBleCallbackTrigger(BTM_BLE_GAP_PATH_LOSS_THRESHOLD_EVT, (tBTM_BLE_5_GAP_CB_PARAMS *)params); +} + +void btm_ble_transmit_power_report_evt(tBTM_BLE_TRANS_POWER_REPORT_EVT *params) +{ + if (!params) { + BTM_TRACE_ERROR("%s, Invalid params.", __func__); + return; + } + + if (params->status != HCI_SUCCESS) { + params->status = (params->status | BTM_HCI_ERROR); + } + + // If the user has register the callback function, should callback it to the application. + BTM_ExtBleCallbackTrigger(BTM_BLE_GAP_TRANMIT_POWER_REPORTING_EVT, (tBTM_BLE_5_GAP_CB_PARAMS *)params); +} + +#endif // #if (BLE_FEAT_POWER_CONTROL_EN == TRUE) + +#if (BLE_FEAT_CONN_SUBRATING == TRUE) +void BTM_BleSetDefaultSubrate(UINT16 subrate_min, UINT16 subrate_max, UINT16 max_latency, UINT16 continuation_number, UINT16 supervision_timeout) +{ + tBTM_STATUS status = BTM_SUCCESS; + tHCI_STATUS err = HCI_SUCCESS; + tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0}; + + if ((err = btsnd_hcic_ble_set_default_subrate(subrate_min, subrate_max, max_latency, continuation_number, supervision_timeout)) != HCI_SUCCESS) { + BTM_TRACE_ERROR("%s cmd err=0x%x", __func__, err); + status = BTM_HCI_ERROR | err; + } + + cb_params.status = status; + + BTM_ExtBleCallbackTrigger(BTM_BLE_GAP_SET_DEFAULT_SUBRATE_EVT, &cb_params); +} + +void BTM_BleSubrateRequest(UINT16 conn_handle, UINT16 subrate_min, UINT16 subrate_max, UINT16 max_latency, UINT16 continuation_number, UINT16 supervision_timeout) +{ + btsnd_hcic_ble_subrate_request(conn_handle, subrate_min, subrate_max, max_latency, continuation_number, supervision_timeout); +} + +void btm_subrate_req_cmd_status(UINT8 status) +{ + tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0}; + + if (status != HCI_SUCCESS) { + status = (status | BTM_HCI_ERROR); + } + cb_params.status = status; + + BTM_ExtBleCallbackTrigger(BTM_BLE_GAP_SUBRATE_REQUEST_EVT, &cb_params); +} + +void btm_ble_subrate_change_evt(tBTM_BLE_SUBRATE_CHANGE_EVT *params) +{ + if (params->status != HCI_SUCCESS) { + params->status = (params->status | BTM_HCI_ERROR); + } + + BTM_ExtBleCallbackTrigger(BTM_BLE_GAP_SUBRATE_CHANGE_EVT, (tBTM_BLE_5_GAP_CB_PARAMS *)params); +} +#endif // #if (BLE_FEAT_CONN_SUBRATING == TRUE) + +#if (BLE_50_FEATURE_SUPPORT == TRUE) +tBTM_STATUS BTM_BleSetHostFeature(uint16_t bit_num, uint8_t bit_val) +{ + tHCI_STATUS err = HCI_SUCCESS; + tBTM_STATUS status = BTM_SUCCESS; + tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0}; + + BTM_TRACE_DEBUG("BTM_BleSetHostFeature bit_num %d bit_value %d\n", bit_num, bit_val); + + if ((err = btsnd_hcic_ble_set_host_feature(bit_num, bit_val)) != HCI_SUCCESS) { + BTM_TRACE_ERROR("set host feature, cmd err=0x%x", err); + status = BTM_HCI_ERROR | err; + } + + cb_params.status = status; + BTM_ExtBleCallbackTrigger(BTM_BLE_GAP_SET_HOST_FEATURE_EVT, &cb_params); + + return status; +} +#endif // #if (BLE_50_FEATURE_SUPPORT == TRUE) diff --git a/lib/bt/host/bluedroid/stack/btm/btm_ble_addr.c b/lib/bt/host/bluedroid/stack/btm/btm_ble_addr.c index d7ed2095..60548a76 100644 --- a/lib/bt/host/bluedroid/stack/btm/btm_ble_addr.c +++ b/lib/bt/host/bluedroid/stack/btm/btm_ble_addr.c @@ -384,6 +384,10 @@ static BOOLEAN btm_ble_match_random_bda(tBTM_SEC_DEV_REC *p_dev_rec) void btm_ble_resolve_random_addr(BD_ADDR random_bda, tBTM_BLE_RESOLVE_CBACK *p_cback, void *p) { #if (SMP_INCLUDED == TRUE) + if (btm_cb.addr_res_en == FALSE) { + return; + } + tBTM_LE_RANDOM_CB *p_mgnt_cb = &btm_cb.ble_ctr_cb.addr_mgnt_cb; list_node_t *p_node = NULL; tBTM_SEC_DEV_REC *p_dev_rec = NULL; @@ -458,6 +462,10 @@ tBTM_SEC_DEV_REC *btm_find_dev_by_identity_addr(BD_ADDR bd_addr, UINT8 addr_type BOOLEAN btm_identity_addr_to_random_pseudo(BD_ADDR bd_addr, UINT8 *p_addr_type, BOOLEAN refresh) { #if BLE_PRIVACY_SPT == TRUE + if (btm_cb.addr_res_en == FALSE) { + return TRUE; + } + tBTM_SEC_DEV_REC *p_dev_rec = btm_find_dev_by_identity_addr(bd_addr, *p_addr_type); BTM_TRACE_EVENT ("%s", __func__); @@ -491,6 +499,10 @@ BOOLEAN btm_identity_addr_to_random_pseudo(BD_ADDR bd_addr, UINT8 *p_addr_type, BOOLEAN btm_random_pseudo_to_identity_addr(BD_ADDR random_pseudo, UINT8 *p_static_addr_type) { #if BLE_PRIVACY_SPT == TRUE + if (btm_cb.addr_res_en == FALSE) { + return TRUE; + } + tBTM_SEC_DEV_REC *p_dev_rec = btm_find_dev (random_pseudo); if (p_dev_rec != NULL) { diff --git a/lib/bt/host/bluedroid/stack/btm/btm_ble_adv_filter.c b/lib/bt/host/bluedroid/stack/btm/btm_ble_adv_filter.c index c0ae0aaa..9da09143 100644 --- a/lib/bt/host/bluedroid/stack/btm/btm_ble_adv_filter.c +++ b/lib/bt/host/bluedroid/stack/btm/btm_ble_adv_filter.c @@ -22,6 +22,7 @@ #include "common/bt_target.h" #if (BLE_INCLUDED == TRUE) +#if BLE_ANDROID_CONTROLLER_SCAN_FILTER == TRUE #include "stack/bt_types.h" #include "stack/hcimsgs.h" #include "stack/btu.h" @@ -445,11 +446,11 @@ BOOLEAN btm_ble_dealloc_addr_filter_counter(tBLE_BD_ADDR *p_bd_addr, UINT8 filte ** ** Function btm_ble_update_pf_local_name ** -** Description this function update(add,delete or clear) the adv lcoal name filtering condition. +** Description this function update(add,delete or clear) the adv local name filtering condition. ** ** -** Returns BTM_SUCCESS if sucessful, -** BTM_ILLEGAL_VALUE if paramter is not valid. +** Returns BTM_SUCCESS if successful, +** BTM_ILLEGAL_VALUE if parameter is not valid. ** *******************************************************************************/ tBTM_STATUS btm_ble_update_pf_local_name(tBTM_BLE_SCAN_COND_OP action, @@ -506,8 +507,8 @@ tBTM_STATUS btm_ble_update_pf_local_name(tBTM_BLE_SCAN_COND_OP action, ** Description this function update(add/remove) service data change filter. ** ** -** Returns BTM_SUCCESS if sucessful, -** BTM_ILLEGAL_VALUE if paramter is not valid. +** Returns BTM_SUCCESS if successful, +** BTM_ILLEGAL_VALUE if parameter is not valid. ** *******************************************************************************/ tBTM_STATUS btm_ble_update_srvc_data_change(tBTM_BLE_SCAN_COND_OP action, @@ -534,8 +535,8 @@ tBTM_STATUS btm_ble_update_srvc_data_change(tBTM_BLE_SCAN_COND_OP action, ** data filtering condition. ** ** -** Returns BTM_SUCCESS if sucessful, -** BTM_ILLEGAL_VALUE if paramter is not valid. +** Returns BTM_SUCCESS if successful, +** BTM_ILLEGAL_VALUE if parameter is not valid. ** *******************************************************************************/ tBTM_STATUS btm_ble_update_pf_manu_data(tBTM_BLE_SCAN_COND_OP action, @@ -708,8 +709,8 @@ UINT8 btm_ble_cs_update_pf_counter(tBTM_BLE_SCAN_COND_OP action, ** Description this function update(add,delete or clear) the address filter of adv. ** ** -** Returns BTM_SUCCESS if sucessful, -** BTM_ILLEGAL_VALUE if paramter is not valid. +** Returns BTM_SUCCESS if successful, +** BTM_ILLEGAL_VALUE if parameter is not valid. ** *******************************************************************************/ tBTM_STATUS btm_ble_update_addr_filter(tBTM_BLE_SCAN_COND_OP action, @@ -757,8 +758,8 @@ tBTM_STATUS btm_ble_update_addr_filter(tBTM_BLE_SCAN_COND_OP action, ** Description this function update(add,delete or clear) service UUID filter. ** ** -** Returns BTM_SUCCESS if sucessful, -** BTM_ILLEGAL_VALUE if paramter is not valid. +** Returns BTM_SUCCESS if successful, +** BTM_ILLEGAL_VALUE if parameter is not valid. ** *******************************************************************************/ tBTM_STATUS btm_ble_update_uuid_filter(tBTM_BLE_SCAN_COND_OP action, @@ -872,7 +873,7 @@ tBTM_STATUS btm_ble_update_uuid_filter(tBTM_BLE_SCAN_COND_OP action, memset(&btm_ble_adv_filt_cb.cur_filter_target, 0, sizeof(tBLE_BD_ADDR)); } } else { - BTM_TRACE_ERROR("UUID filter udpating failed"); + BTM_TRACE_ERROR("UUID filter updating failed"); } return st; @@ -886,8 +887,8 @@ tBTM_STATUS btm_ble_update_uuid_filter(tBTM_BLE_SCAN_COND_OP action, ** Description clear all adv payload filter by de-select all the adv pf feature bits ** ** -** Returns BTM_SUCCESS if sucessful, -** BTM_ILLEGAL_VALUE if paramter is not valid. +** Returns BTM_SUCCESS if successful, +** BTM_ILLEGAL_VALUE if parameter is not valid. ** *******************************************************************************/ tBTM_STATUS btm_ble_clear_scan_pf_filter(tBTM_BLE_SCAN_COND_OP action, @@ -1303,4 +1304,5 @@ void btm_ble_adv_filter_cleanup(void) #endif } +#endif // #if BLE_ANDROID_CONTROLLER_SCAN_FILTER == TRUE #endif diff --git a/lib/bt/host/bluedroid/stack/btm/btm_ble_batchscan.c b/lib/bt/host/bluedroid/stack/btm/btm_ble_batchscan.c index 5b0fcd8f..b4b58643 100644 --- a/lib/bt/host/bluedroid/stack/btm/btm_ble_batchscan.c +++ b/lib/bt/host/bluedroid/stack/btm/btm_ble_batchscan.c @@ -29,15 +29,22 @@ #include "stack/hcimsgs.h" #if (BLE_INCLUDED == TRUE) +#if (BLE_HOST_BATCH_SCAN_EN == TRUE) #if BTM_DYNAMIC_MEMORY == FALSE tBTM_BLE_BATCH_SCAN_CB ble_batchscan_cb; +#if (BLE_HOST_TRACK_ADVERTISER_EN == TRUE) tBTM_BLE_ADV_TRACK_CB ble_advtrack_cb; +#endif // #if (BLE_HOST_TRACK_ADVERTISER_EN == TRUE) #else tBTM_BLE_BATCH_SCAN_CB *ble_batchscan_cb_ptr; +#if (BLE_HOST_TRACK_ADVERTISER_EN == TRUE) tBTM_BLE_ADV_TRACK_CB *ble_advtrack_cb_ptr; +#endif // #if (BLE_HOST_TRACK_ADVERTISER_EN == TRUE) #define ble_batchscan_cb (*ble_batchscan_cb_ptr) +#if (BLE_HOST_TRACK_ADVERTISER_EN == TRUE) #define ble_advtrack_cb (*ble_advtrack_cb_ptr) +#endif // #if (BLE_HOST_TRACK_ADVERTISER_EN == TRUE) #endif /* length of each batch scan command */ @@ -66,10 +73,11 @@ void btm_ble_batchscan_cleanup(void); *******************************************************************************/ void btm_ble_batchscan_filter_track_adv_vse_cback(UINT8 len, UINT8 *p) { +#if (BLE_HOST_TRACK_ADVERTISER_EN == TRUE) tBTM_BLE_TRACK_ADV_DATA adv_data; - - UINT8 sub_event = 0; tBTM_BLE_VSC_CB cmn_ble_vsc_cb; +#endif // #if (BLE_HOST_TRACK_ADVERTISER_EN == TRUE) + UINT8 sub_event = 0; STREAM_TO_UINT8(sub_event, p); BTM_TRACE_EVENT("btm_ble_batchscan_filter_track_adv_vse_cback called with event:%x", sub_event); @@ -78,7 +86,7 @@ void btm_ble_batchscan_filter_track_adv_vse_cback(UINT8 len, UINT8 *p) ble_batchscan_cb.p_thres_cback(ble_batchscan_cb.ref_value); return; } - +#if (BLE_HOST_TRACK_ADVERTISER_EN == TRUE) if (HCI_VSE_SUBCODE_BLE_TRACKING_SUB_EVT == sub_event && NULL != ble_advtrack_cb.p_track_cback) { if (len < 10) { return; @@ -125,6 +133,7 @@ void btm_ble_batchscan_filter_track_adv_vse_cback(UINT8 len, UINT8 *p) ble_advtrack_cb.p_track_cback(&adv_data); return; } +#endif // #if (BLE_HOST_TRACK_ADVERTISER_EN == TRUE) } /******************************************************************************* @@ -598,6 +607,7 @@ tBTM_STATUS btm_ble_enable_disable_batchscan(BOOLEAN should_enable) return status; } +#if (BLE_HOST_SETUP_STORAGE_EN == TRUE) /******************************************************************************* ** ** Function BTM_BleSetStorageConfig @@ -676,7 +686,7 @@ tBTM_STATUS BTM_BleSetStorageConfig(UINT8 batch_scan_full_max, UINT8 batch_scan_ return status; } - +#endif // #if (BLE_HOST_SETUP_STORAGE_EN == TRUE) /******************************************************************************* ** @@ -796,6 +806,7 @@ tBTM_STATUS BTM_BleDisableBatchScan(tBTM_BLE_REF_VALUE ref_value) return status; } +#if (BLE_HOST_READ_SCAN_REPORTS_EN == TRUE) /******************************************************************************* ** ** Function BTM_BleReadScanReports @@ -854,8 +865,9 @@ tBTM_STATUS BTM_BleReadScanReports(tBTM_BLE_BATCH_SCAN_MODE scan_mode, } return status; } +#endif // #if (BLE_HOST_READ_SCAN_REPORTS_EN == TRUE) - +#if (BLE_HOST_TRACK_ADVERTISER_EN == TRUE) /******************************************************************************* ** ** Function BTM_BleTrackAdvertiser @@ -888,6 +900,7 @@ tBTM_STATUS BTM_BleTrackAdvertiser(tBTM_BLE_TRACK_ADV_CBACK *p_track_cback, ble_advtrack_cb.ref_value = ref_value; return BTM_CMD_STARTED; } +#endif // #if (BLE_HOST_TRACK_ADVERTISER_EN == TRUE) /******************************************************************************* ** @@ -904,7 +917,9 @@ void btm_ble_batchscan_init(void) { #if BTM_DYNAMIC_MEMORY == TRUE ble_batchscan_cb_ptr = (tBTM_BLE_BATCH_SCAN_CB *)osi_malloc(sizeof(tBTM_BLE_BATCH_SCAN_CB)); +#if (BLE_HOST_TRACK_ADVERTISER_EN == TRUE) ble_advtrack_cb_ptr = (tBTM_BLE_ADV_TRACK_CB *)osi_malloc(sizeof(tBTM_BLE_ADV_TRACK_CB)); +#endif // #if (BLE_HOST_TRACK_ADVERTISER_EN == TRUE) if (ble_batchscan_cb_ptr == NULL || ble_advtrack_cb_ptr == NULL) { BTM_TRACE_ERROR("%s malloc failed", __func__); return; @@ -912,7 +927,9 @@ void btm_ble_batchscan_init(void) #endif BTM_TRACE_EVENT (" btm_ble_batchscan_init"); memset(&ble_batchscan_cb, 0, sizeof(tBTM_BLE_BATCH_SCAN_CB)); +#if (BLE_HOST_TRACK_ADVERTISER_EN == TRUE) memset(&ble_advtrack_cb, 0, sizeof(tBTM_BLE_ADV_TRACK_CB)); +#endif // #if (BLE_HOST_TRACK_ADVERTISER_EN == TRUE) BTM_RegisterForVSEvents(btm_ble_batchscan_filter_track_adv_vse_cback, TRUE); } @@ -940,14 +957,21 @@ void btm_ble_batchscan_cleanup(void) } memset(&ble_batchscan_cb, 0, sizeof(tBTM_BLE_BATCH_SCAN_CB)); +#if (BLE_HOST_TRACK_ADVERTISER_EN == TRUE) memset(&ble_advtrack_cb, 0, sizeof(tBTM_BLE_ADV_TRACK_CB)); +#endif // #if (BLE_HOST_TRACK_ADVERTISER_EN == TRUE) #if BTM_DYNAMIC_MEMORY == TRUE osi_free(ble_batchscan_cb_ptr); - osi_free(ble_advtrack_cb_ptr); ble_batchscan_cb_ptr = NULL; +#if (BLE_HOST_TRACK_ADVERTISER_EN == TRUE) + osi_free(ble_advtrack_cb_ptr); ble_advtrack_cb_ptr = NULL; +#endif // #if (BLE_HOST_TRACK_ADVERTISER_EN == TRUE) + #endif } +#endif // #if (BLE_HOST_BATCH_SCAN_EN == TRUE) + #endif diff --git a/lib/bt/host/bluedroid/stack/btm/btm_ble_bgconn.c b/lib/bt/host/bluedroid/stack/btm/btm_ble_bgconn.c index 4cb282b7..bf9b1adb 100644 --- a/lib/bt/host/bluedroid/stack/btm/btm_ble_bgconn.c +++ b/lib/bt/host/bluedroid/stack/btm/btm_ble_bgconn.c @@ -201,7 +201,12 @@ BOOLEAN btm_add_dev_to_controller (BOOLEAN to_add, BD_ADDR bd_addr, tBLE_ADDR_TY /* Controller do not support resolvable address now, only support public address and static random address */ BOOLEAN started = FALSE; - if(wl_addr_type > BLE_ADDR_RANDOM) { +#if (BLE_50_FEATURE_SUPPORT == TRUE) + if (wl_addr_type > BLE_ADDR_RANDOM && wl_addr_type != BLE_ADDR_ANONYMOUS) +#else + if (wl_addr_type > BLE_ADDR_RANDOM) +#endif // #if (BLE_50_FEATURE_SUPPORT == TRUE) + { BTM_TRACE_ERROR("wl_addr_type is error\n"); return started; } @@ -278,7 +283,12 @@ void btm_enq_wl_dev_operation(BOOLEAN to_add, BD_ADDR bd_addr, tBLE_ADDR_TYPE ad *******************************************************************************/ BOOLEAN btm_update_dev_to_white_list(BOOLEAN to_add, BD_ADDR bd_addr, tBLE_ADDR_TYPE addr_type, tBTM_UPDATE_WHITELIST_CBACK *update_wl_cb) { - if(addr_type > BLE_ADDR_RANDOM) { +#if (BLE_50_FEATURE_SUPPORT == TRUE) + if (addr_type > BLE_ADDR_RANDOM && addr_type != BLE_ADDR_ANONYMOUS) +#else + if (addr_type > BLE_ADDR_RANDOM) +#endif // #if (BLE_50_FEATURE_SUPPORT == TRUE) + { BTM_TRACE_ERROR("%s address type is error, unable to add device", __func__); if (update_wl_cb){ update_wl_cb(HCI_ERR_ILLEGAL_PARAMETER_FMT,to_add); @@ -423,6 +433,23 @@ void btm_ble_white_list_init(UINT8 white_list_size) btm_cb.ble_ctr_cb.white_list_avail_size = white_list_size; } +#if (BLE_50_EXTEND_SYNC_EN == TRUE) +/******************************************************************************* +** +** Function btm_ble_periodic_adv_list_init +** +** Description Initialize the periodic advertiser list size. +** +** Parameters periodic_adv_size: The size of the periodic advertiser list to be initialized. +** +*******************************************************************************/ +void btm_ble_periodic_adv_list_init(UINT8 periodic_adv_size) +{ + BTM_TRACE_DEBUG("%s white_list_size = %d", __func__, periodic_adv_size); + btm_cb.ble_ctr_cb.periodic_adv_list_size = periodic_adv_size; +} +#endif //#if (BLE_50_EXTEND_SYNC_EN == TRUE) + /******************************************************************************* ** ** Function btm_ble_add_2_white_list_complete @@ -648,6 +675,7 @@ void btm_ble_initiate_select_conn(BD_ADDR bda) BTM_TRACE_ERROR("btm_ble_initiate_select_conn failed"); } } +#if (tGATT_BG_CONN_DEV == TRUE) /******************************************************************************* ** ** Function btm_ble_suspend_bg_conn @@ -672,6 +700,8 @@ BOOLEAN btm_ble_suspend_bg_conn(void) return FALSE; } +#endif // #if (tGATT_BG_CONN_DEV == TRUE) + /******************************************************************************* ** ** Function btm_suspend_wl_activity @@ -689,10 +719,11 @@ static void btm_suspend_wl_activity(tBTM_BLE_WL_STATE wl_state) if (wl_state & BTM_BLE_WL_SCAN) { btm_ble_start_select_conn(FALSE, NULL); } +#if (BLE_42_ADV_EN == TRUE) if (wl_state & BTM_BLE_WL_ADV) { btm_ble_stop_adv(); } - +#endif // #if (BLE_42_ADV_EN == TRUE) } /******************************************************************************* ** @@ -705,9 +736,13 @@ static void btm_suspend_wl_activity(tBTM_BLE_WL_STATE wl_state) *******************************************************************************/ void btm_resume_wl_activity(tBTM_BLE_WL_STATE wl_state) { +#if (tGATT_BG_CONN_DEV == TRUE) btm_ble_resume_bg_conn(); +#endif // #if (tGATT_BG_CONN_DEV == TRUE) if (wl_state & BTM_BLE_WL_ADV) { +#if (BLE_42_ADV_EN == TRUE) btm_ble_start_adv(); +#endif // #if (BLE_42_ADV_EN == TRUE) } } @@ -724,12 +759,13 @@ void btm_resume_wl_activity(tBTM_BLE_WL_STATE wl_state) static void btm_wl_update_to_controller(void) { /* whitelist will be added in the btm_ble_resume_bg_conn(), we do not - support background connection now, so we nedd to use btm_execute_wl_dev_operation + support background connection now, so we need to use btm_execute_wl_dev_operation to add whitelist directly ,if we support background connection in the future, please delete btm_execute_wl_dev_operation(). */ btm_execute_wl_dev_operation(); } +#if (tGATT_BG_CONN_DEV == TRUE) /******************************************************************************* ** ** Function btm_ble_resume_bg_conn @@ -759,6 +795,8 @@ BOOLEAN btm_ble_resume_bg_conn(void) return ret; } +#endif // #if (tGATT_BG_CONN_DEV == TRUE) + /******************************************************************************* ** ** Function btm_ble_get_conn_st diff --git a/lib/bt/host/bluedroid/stack/btm/btm_ble_cont_energy.c b/lib/bt/host/bluedroid/stack/btm/btm_ble_cont_energy.c index dd23d3e9..4b68fe80 100644 --- a/lib/bt/host/bluedroid/stack/btm/btm_ble_cont_energy.c +++ b/lib/bt/host/bluedroid/stack/btm/btm_ble_cont_energy.c @@ -20,6 +20,7 @@ #include "common/bt_target.h" #if (BLE_INCLUDED == TRUE) +#if (BLE_HOST_ENERGY_INFO_EN == TRUE) #include "stack/bt_types.h" #include "stack/hcimsgs.h" #include "stack/btu.h" @@ -104,5 +105,6 @@ tBTM_STATUS BTM_BleGetEnergyInfo(tBTM_BLE_ENERGY_INFO_CBACK *p_ener_cback) return status; } +#endif // #if (BLE_HOST_ENERGY_INFO_EN == TRUE) #endif diff --git a/lib/bt/host/bluedroid/stack/btm/btm_ble_cte.c b/lib/bt/host/bluedroid/stack/btm/btm_ble_cte.c new file mode 100644 index 00000000..a79932de --- /dev/null +++ b/lib/bt/host/bluedroid/stack/btm/btm_ble_cte.c @@ -0,0 +1,237 @@ +/* + * SPDX-FileCopyrightText: 2015-2021 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#include "btm_int.h" +#include "stack/hcimsgs.h" +#include "osi/allocator.h" +#include "device/controller.h" +#include <string.h> +#include "l2c_int.h" + +tBTM_BLE_CTE_CBACK ble_cte_cb; + +extern void btm_ble_inter_set(bool extble_inter); + +void BTM_BleCteRegisterCallback(tBTM_BLE_CTE_CBACK cb) +{ + if (cb) { + ble_cte_cb = cb; + } else { + BTM_TRACE_ERROR("%s, register fail, the cb function is NULL.", __func__); + } +} + +void BTM_CteBleCallbackTrigger(tBTM_BLE_5_GAP_EVENT event, tBTM_BLE_CTE_CB_PARAMS *params) +{ + BTM_TRACE_DEBUG("%s event %x", __func__, event); + + if(params && params->status == BTM_SUCCESS) { + btm_ble_inter_set(true); + } + if (ble_cte_cb) { + ble_cte_cb(event, params); + } +} +#if (BLE_FEAT_CTE_CONNECTIONLESS_EN == TRUE) +tBTM_STATUS BTM_BleSetCteTransParams(uint8_t adv_handle, uint8_t cte_len, uint8_t cte_type, uint8_t cte_count, uint8_t switching_pattern_len, uint8_t *antenna_ids) +{ + + + tHCI_STATUS err = HCI_SUCCESS; + tBTM_STATUS status = BTM_SUCCESS; + tBTM_BLE_CTE_CB_PARAMS cb_params = {0}; + + if ((err = btsnd_hcic_ble_set_connless_cte_trans_params(adv_handle, cte_len, cte_type, cte_count, switching_pattern_len, antenna_ids)) != HCI_SUCCESS) { + BTM_TRACE_ERROR("cte set trans params, cmd err=0x%x", err); + status = BTM_HCI_ERROR | err; + } + + cb_params.cte_trans_params_cmpl.status = status; + BTM_CteBleCallbackTrigger(BTM_BLE_CTE_SET_TRANS_PARAMS_EVT, &cb_params); + + return status; +} + +tBTM_STATUS BTM_BleCteSetConnectionlessTransEnable(uint8_t adv_handle, uint8_t cte_en) +{ + tHCI_STATUS err = HCI_SUCCESS; + tBTM_STATUS status = BTM_SUCCESS; + tBTM_BLE_CTE_CB_PARAMS cb_params = {0}; + + if ((err = btsnd_hcic_ble_set_connless_cte_enable(adv_handle, cte_en)) != HCI_SUCCESS) { + BTM_TRACE_ERROR("cte set trans enable, cmd err=0x%x", err); + status = BTM_HCI_ERROR | err; + } + + cb_params.cte_trans_en_cmpl.status = status; + BTM_CteBleCallbackTrigger(BTM_BLE_CTE_SET_TRANS_ENABLE_EVT, &cb_params); + + return status; +} + +tBTM_STATUS BTM_BleCteSetConnectionlessIqSamplingEnable(uint16_t sync_handle, uint8_t sampling_en, uint8_t slot_dur, + uint8_t max_sampled_ctes, uint8_t switching_pattern_len, uint8_t *ant_ids) +{ + tHCI_STATUS err = HCI_SUCCESS; + tBTM_STATUS status = BTM_SUCCESS; + tBTM_BLE_CTE_CB_PARAMS cb_params = {0}; + + if ((err = btsnd_hcic_ble_set_connless_iq_sampling_enable(sync_handle, sampling_en, slot_dur, max_sampled_ctes, switching_pattern_len, ant_ids)) != HCI_SUCCESS) { + BTM_TRACE_ERROR("cte set trans enable, cmd err=0x%x", err); + status = BTM_HCI_ERROR | err; + } + + cb_params.cte_iq_samp_en_cmpl.status = status; + cb_params.cte_iq_samp_en_cmpl.sync_handle = sync_handle; + BTM_CteBleCallbackTrigger(BTM_BLE_CTE_SET_IQ_SAMP_ENABLE_EVT, &cb_params); + + return status; +} +#endif // #if (BLE_FEAT_CTE_CONNECTIONLESS_EN == TRUE) + +#if (BLE_FEAT_CTE_CONNECTION_EN == TRUE) +tBTM_STATUS BTM_BleCteSetConnectionReceiveParams(uint16_t conn_handle, uint8_t sampling_en, uint8_t slot_dur, + uint8_t switching_pattern_len, uint8_t *ant_ids) +{ + tHCI_STATUS err = HCI_SUCCESS; + tBTM_STATUS status = BTM_SUCCESS; + tBTM_BLE_CTE_CB_PARAMS cb_params = {0}; + + if ((err = btsnd_hcic_ble_set_conn_cte_receive_params(conn_handle, sampling_en, slot_dur, switching_pattern_len, ant_ids)) != HCI_SUCCESS) { + BTM_TRACE_ERROR("cte set conn recv params, cmd err=0x%x", err); + status = BTM_HCI_ERROR | err; + } + + cb_params.cte_recv_params_cmpl.status = status; + cb_params.cte_recv_params_cmpl.conn_handle = conn_handle; + BTM_CteBleCallbackTrigger(BTM_BLE_CTE_SET_CONN_RECV_PARAMS_EVT, &cb_params); + + return status; +} + +tBTM_STATUS BTM_BleCteSetConnectionTransParams(uint16_t conn_handle, uint8_t cte_types, uint8_t switching_pattern_len, uint8_t *ant_ids) +{ + tHCI_STATUS err = HCI_SUCCESS; + tBTM_STATUS status = BTM_SUCCESS; + tBTM_BLE_CTE_CB_PARAMS cb_params = {0}; + + if ((err = btsnd_hcic_ble_set_conn_cte_trans_params(conn_handle, cte_types, switching_pattern_len, ant_ids)) != HCI_SUCCESS) { + BTM_TRACE_ERROR("cte set conn trans params, cmd err=0x%x", err); + status = BTM_HCI_ERROR | err; + } + + cb_params.cte_conn_trans_params_cmpl.status = status; + cb_params.cte_conn_trans_params_cmpl.conn_handle = conn_handle; + BTM_CteBleCallbackTrigger(BTM_BLE_CTE_SET_CONN_TRANS_PARAMS_EVT, &cb_params); + + return status; +} + +tBTM_STATUS BTM_BleCteSetConnectionRequestEnable(uint16_t conn_handle, uint8_t enable, uint16_t cte_req_int, + uint8_t req_cte_len, uint8_t req_cte_type) +{ + tHCI_STATUS err = HCI_SUCCESS; + tBTM_STATUS status = BTM_SUCCESS; + tBTM_BLE_CTE_CB_PARAMS cb_params = {0}; + + if ((err = btsnd_hcic_ble_conn_cte_req_enable(conn_handle, enable, cte_req_int, req_cte_len, req_cte_type)) != HCI_SUCCESS) { + BTM_TRACE_ERROR("cte set conn req en, cmd err=0x%x", err); + status = BTM_HCI_ERROR | err; + } + + cb_params.cte_conn_req_en_cmpl.status = status; + cb_params.cte_conn_req_en_cmpl.conn_handle = conn_handle; + BTM_CteBleCallbackTrigger(BTM_BLE_CTE_SET_CONN_REQ_ENABLE_EVT, &cb_params); + + return status; +} + +tBTM_STATUS BTM_BleCteSetConnectionRspEnable(uint16_t conn_handle, uint8_t enable) +{ + tHCI_STATUS err = HCI_SUCCESS; + tBTM_STATUS status = BTM_SUCCESS; + tBTM_BLE_CTE_CB_PARAMS cb_params = {0}; + + if ((err = btsnd_hcic_ble_conn_cte_rsp_enable(conn_handle, enable)) != HCI_SUCCESS) { + BTM_TRACE_ERROR("cte set conn rsp en, cmd err=0x%x", err); + status = BTM_HCI_ERROR | err; + } + + cb_params.cte_conn_rsp_en_cmpl.status = status; + cb_params.cte_conn_rsp_en_cmpl.conn_handle = conn_handle; + BTM_CteBleCallbackTrigger(BTM_BLE_CTE_SET_CONN_RSP_ENABLE_EVT, &cb_params); + + return status; +} +#endif // #if (BLE_FEAT_CTE_CONNECTION_EN == TRUE) + +tBTM_STATUS BTM_BleCteReadAntInfor(void) +{ + tHCI_STATUS err = HCI_SUCCESS; + tBTM_STATUS status = BTM_SUCCESS; + + if ((err = btsnd_hcic_ble_read_antenna_info()) != HCI_SUCCESS) { + BTM_TRACE_ERROR("cte read ant information, cmd err=0x%x", err); + status = BTM_HCI_ERROR | err; + } + + return status; +} + +void btm_ble_cte_read_ant_infor_complete(UINT8 *p) +{ + tBTM_BLE_CTE_CB_PARAMS cb_params = {0}; + + STREAM_TO_UINT8(cb_params.cte_read_ant_infor_cmpl.status, p); + STREAM_TO_UINT8(cb_params.cte_read_ant_infor_cmpl.supported_switching_sampling_rates, p); + STREAM_TO_UINT8(cb_params.cte_read_ant_infor_cmpl.num_ant, p); + STREAM_TO_UINT8(cb_params.cte_read_ant_infor_cmpl.max_switching_pattern_len, p); + STREAM_TO_UINT8(cb_params.cte_read_ant_infor_cmpl.max_cte_len, p); + + if (cb_params.cte_read_ant_infor_cmpl.status != HCI_SUCCESS) { + cb_params.cte_read_ant_infor_cmpl.status = (BTM_HCI_ERROR | cb_params.cte_read_ant_infor_cmpl.status); + } + + BTM_CteBleCallbackTrigger(BTM_BLE_CTE_READ_ANT_INFOR_EVT, &cb_params); +} + +#if (BLE_FEAT_CTE_CONNECTIONLESS_EN == TRUE) +void btm_ble_connless_iq_report_evt(tBTM_BLE_CTE_CONNLESS_IQ_REPORT_EVT *params) +{ + if (!params) { + BTM_TRACE_ERROR("%s, Invalid params.", __func__); + return; + } + + BTM_CteBleCallbackTrigger(BTM_BLE_CTE_CONNLESS_IQ_REPORT_EVT, (tBTM_BLE_CTE_CB_PARAMS *)params); +} +#endif // #if (BLE_FEAT_CTE_CONNECTIONLESS_EN == TRUE) + +#if (BLE_FEAT_CTE_CONNECTION_EN == TRUE) +void btm_ble_conn_iq_report_evt(tBTM_BLE_CTE_CONN_IQ_REPORT_EVT *params) +{ + if (!params) { + BTM_TRACE_ERROR("%s, Invalid params.", __func__); + return; + } + + BTM_CteBleCallbackTrigger(BTM_BLE_CTE_CONN_IQ_REPORT_EVT, (tBTM_BLE_CTE_CB_PARAMS *)params); +} + +void btm_ble_cte_req_failed_evt(tBTM_BLE_CTE_REQ_FAILED_EVT *params) +{ + if (!params) { + BTM_TRACE_ERROR("%s, Invalid params.", __func__); + return; + } + + if (params->status != HCI_SUCCESS) { + params->status = (params->status | BTM_HCI_ERROR); + } + + BTM_CteBleCallbackTrigger(BTM_BLE_CTE_REQUEST_FAILED_EVT, (tBTM_BLE_CTE_CB_PARAMS *)params); +} +#endif // #if (BLE_FEAT_CTE_CONNECTION_EN == TRUE) diff --git a/lib/bt/host/bluedroid/stack/btm/btm_ble_gap.c b/lib/bt/host/bluedroid/stack/btm/btm_ble_gap.c index df24fa08..f3886643 100644 --- a/lib/bt/host/bluedroid/stack/btm/btm_ble_gap.c +++ b/lib/bt/host/bluedroid/stack/btm/btm_ble_gap.c @@ -71,20 +71,28 @@ static tBTM_BLE_CTRL_FEATURES_CBACK *p_ctrl_le_feature_rd_cmpl_cback = NULL; #endif tBTM_CallbackFunc conn_callback_func; +// BLE vendor HCI event callback +#if (BLE_VENDOR_HCI_EN == TRUE) +static tBTM_BLE_VENDOR_HCI_EVT_CBACK *ble_vs_evt_callback = NULL; +#endif // #if (BLE_VENDOR_HCI_EN == TRUE) /******************************************************************************* ** Local functions *******************************************************************************/ static void btm_ble_update_adv_flag(UINT8 flag); static void btm_ble_process_adv_pkt_cont(BD_ADDR bda, UINT8 addr_type, UINT8 evt_type, UINT8 *p); + UINT8 *btm_ble_build_adv_data(tBTM_BLE_AD_MASK *p_data_mask, UINT8 **p_dst, tBTM_BLE_ADV_DATA *p_data); + static UINT8 btm_set_conn_mode_adv_init_addr(tBTM_BLE_INQ_CB *p_cb, BD_ADDR_PTR p_peer_addr_ptr, tBLE_ADDR_TYPE *p_peer_addr_type, tBLE_ADDR_TYPE *p_own_addr_type); static void btm_ble_stop_observe(void); static void btm_ble_stop_discover(void); +#if (BLE_42_SCAN_EN == TRUE) static void btm_adv_pkt_handler(void *arg); +#endif // #if (BLE_42_SCAN_EN == TRUE) uint32_t BTM_BleUpdateOwnType(uint8_t *own_bda_type, tBTM_START_ADV_CMPL_CBACK *cb); #define BTM_BLE_INQ_RESULT 0x01 @@ -246,56 +254,77 @@ const UINT8 btm_le_state_combo_tbl[BTM_BLE_STATE_MAX][BTM_BLE_STATE_MAX][2] = { /* check LE combo state supported */ #define BTM_LE_STATES_SUPPORTED(x, y, z) ((x)[(z)] & (y)) +#if (BLE_42_ADV_EN == TRUE) static osi_mutex_t adv_enable_lock; static osi_mutex_t adv_data_lock; static osi_mutex_t adv_param_lock; -static osi_mutex_t scan_enable_lock; -static osi_mutex_t scan_param_lock; osi_sem_t adv_enable_sem; osi_sem_t adv_data_sem; osi_sem_t adv_param_sem; -osi_sem_t scan_enable_sem; -osi_sem_t scan_param_sem; uint8_t adv_enable_status = 0; uint8_t adv_data_status = 0; uint8_t adv_param_status = 0; +#endif // #if (BLE_42_ADV_EN == TRUE) + +#if (BLE_42_SCAN_EN == TRUE) +static osi_mutex_t scan_enable_lock; +static osi_mutex_t scan_param_lock; +osi_sem_t scan_enable_sem; +osi_sem_t scan_param_sem; uint8_t scan_enable_status = 0; uint8_t scan_param_status = 0; +#endif // #if (BLE_42_SCAN_EN == TRUE) void btm_ble_lock_init(void) { +#if (BLE_42_ADV_EN == TRUE) osi_mutex_new(&adv_enable_lock); osi_mutex_new(&adv_data_lock); osi_mutex_new(&adv_param_lock); +#endif // #if (BLE_42_ADV_EN == TRUE) +#if (BLE_42_SCAN_EN == TRUE) osi_mutex_new(&scan_enable_lock); osi_mutex_new(&scan_param_lock); +#endif // #if (BLE_42_SCAN_EN == TRUE) } void btm_ble_lock_free(void) { +#if (BLE_42_ADV_EN == TRUE) osi_mutex_free(&adv_enable_lock); osi_mutex_free(&adv_data_lock); osi_mutex_free(&adv_param_lock); +#endif // #if (BLE_42_ADV_EN == TRUE) +#if (BLE_42_SCAN_EN == TRUE) osi_mutex_free(&scan_enable_lock); osi_mutex_free(&scan_param_lock); +#endif // #if (BLE_42_SCAN_EN == TRUE) } void btm_ble_sem_init(void) { +#if (BLE_42_ADV_EN == TRUE) osi_sem_new(&adv_enable_sem, 1, 0); osi_sem_new(&adv_data_sem, 1, 0); osi_sem_new(&adv_param_sem, 1, 0); +#endif // #if (BLE_42_ADV_EN == TRUE) +#if (BLE_42_SCAN_EN == TRUE) osi_sem_new(&scan_enable_sem, 1, 0); osi_sem_new(&scan_param_sem, 1, 0); +#endif // #if (BLE_42_SCAN_EN == TRUE) } void btm_ble_sem_free(void) { +#if (BLE_42_ADV_EN == TRUE) osi_sem_free(&adv_enable_sem); osi_sem_free(&adv_data_sem); osi_sem_free(&adv_param_sem); +#endif // #if (BLE_42_ADV_EN == TRUE) +#if (BLE_42_SCAN_EN == TRUE) osi_sem_free(&scan_enable_sem); osi_sem_free(&scan_param_sem); +#endif // #if (BLE_42_SCAN_EN == TRUE) } /******************************************************************************* @@ -326,6 +355,13 @@ void BTM_BleRegiseterPktLengthChangeCallback(tBTM_SET_PKT_DATA_LENGTH_CBACK *ptk conn_callback_func.set_pkt_data_length_cb = ptk_len_chane_cb; } +#if (BLE_VENDOR_HCI_EN == TRUE) +void BTM_BleRegisterVendorHciEventCallback(tBTM_BLE_VENDOR_HCI_EVT_CBACK *vendor_hci_evt_cb) +{ + ble_vs_evt_callback = vendor_hci_evt_cb; +} +#endif // #if (BLE_VENDOR_HCI_EN == TRUE) + /******************************************************************************* ** ** Function BTM_BleUpdateAdvWhitelist @@ -380,14 +416,22 @@ void BTM_BleUpdateAdvFilterPolicy(tBTM_BLE_AFP adv_policy) if (p_cb->afp != adv_policy) { p_cb->afp = adv_policy; +#if (BLE_42_ADV_EN == TRUE) /* if adv active, stop and restart */ btm_ble_stop_adv (); +#endif // #if (BLE_42_ADV_EN == TRUE) if (p_cb->connectable_mode & BTM_BLE_CONNECTABLE) { p_cb->evt_type = btm_set_conn_mode_adv_init_addr(p_cb, p_addr_ptr, &init_addr_type, &p_cb->adv_addr_type); } + uint8_t null_addr[BD_ADDR_LEN] = {0}; + if ((p_cb->evt_type == 0x01 || p_cb->evt_type == 0x04) && memcmp(p_addr_ptr, null_addr, BD_ADDR_LEN) == 0) { + /* directed advertising */ + return; + } + btsnd_hcic_ble_write_adv_params ((UINT16)(p_cb->adv_interval_min ? p_cb->adv_interval_min : BTM_BLE_GAP_ADV_SLOW_INT), (UINT16)(p_cb->adv_interval_max ? p_cb->adv_interval_max : @@ -400,7 +444,9 @@ void BTM_BleUpdateAdvFilterPolicy(tBTM_BLE_AFP adv_policy) p_cb->afp); if (adv_mode == BTM_BLE_ADV_ENABLE) { +#if (BLE_42_ADV_EN == TRUE) btm_ble_start_adv (); +#endif // #if (BLE_42_ADV_EN == TRUE) } } @@ -506,8 +552,9 @@ tBTM_STATUS BTM_BleObserve(BOOLEAN start, UINT32 duration, btm_cb.ble_ctr_cb.addr_mgnt_cb.own_addr_type, BTM_BLE_DEFAULT_SFP); } - +#if (BLE_42_SCAN_EN == TRUE) status = btm_ble_start_scan(); +#endif // #if (BLE_42_SCAN_EN == TRUE) } if (status == BTM_CMD_STARTED) { @@ -529,6 +576,7 @@ tBTM_STATUS BTM_BleObserve(BOOLEAN start, UINT32 duration, } +#if (BLE_42_SCAN_EN == TRUE) /******************************************************************************* ** ** Function BTM_BleScan @@ -606,7 +654,9 @@ tBTM_STATUS BTM_BleScan(BOOLEAN start, UINT32 duration, return status; } +#endif // #if (BLE_42_SCAN_EN == TRUE) +#if (BLE_42_ADV_EN == TRUE) /******************************************************************************* ** ** Function BTM_BleBroadcast @@ -665,7 +715,7 @@ tBTM_STATUS BTM_BleBroadcast(BOOLEAN start, tBTM_START_STOP_ADV_CMPL_CBACK *p_s } return status; } - +#endif // #if (BLE_42_ADV_EN == TRUE) #if BLE_VND_INCLUDED == TRUE /******************************************************************************* ** @@ -717,11 +767,11 @@ static void btm_ble_vendor_capability_vsc_cmpl_cback (tBTM_VSC_CMPL *p_vcs_cplt_ __func__, status, btm_cb.cmn_ble_vsc_cb.max_irk_list_sz, btm_cb.cmn_ble_vsc_cb.adv_inst_max, btm_cb.cmn_ble_vsc_cb.rpa_offloading, btm_cb.cmn_ble_vsc_cb.energy_support, btm_cb.cmn_ble_vsc_cb.extended_scan_support); - +#if (BLE_HOST_BLE_MULTI_ADV_EN == TRUE) if (BTM_BleMaxMultiAdvInstanceCount() > 0) { btm_ble_multi_adv_init(); } - +#endif // #if (BLE_HOST_BLE_MULTI_ADV_EN == TRUE) if (btm_cb.cmn_ble_vsc_cb.max_filter > 0) { btm_ble_adv_filter_init(); } @@ -899,9 +949,11 @@ BOOLEAN BTM_BleConfigPrivacy(BOOLEAN privacy_mode, tBTM_SET_LOCAL_PRIVACY_CBACK btm_gen_resolvable_private_addr((void *)btm_gen_resolve_paddr_low); #endif +#if (BLE_HOST_BLE_MULTI_ADV_EN == TRUE) if (BTM_BleMaxMultiAdvInstanceCount() > 0) { btm_ble_multi_adv_enb_privacy(privacy_mode); } +#endif // #if (BLE_HOST_BLE_MULTI_ADV_EN == TRUE) /* 4.2 controller only allow privacy 1.2 or mixed mode, resolvable private address in controller */ if (controller_get_interface()->supports_ble_privacy()) { @@ -1139,6 +1191,7 @@ void BTM_BleConfigConnParams(uint16_t int_min, uint16_t int_max, uint16_t latenc #endif } +#if (BLE_HOST_BLE_MULTI_ADV_EN == TRUE) /******************************************************************************* ** ** Function BTM_BleMaxMultiAdvInstanceCount @@ -1153,6 +1206,7 @@ extern UINT8 BTM_BleMaxMultiAdvInstanceCount(void) return btm_cb.cmn_ble_vsc_cb.adv_inst_max < BTM_BLE_MULTI_ADV_MAX ? btm_cb.cmn_ble_vsc_cb.adv_inst_max : BTM_BLE_MULTI_ADV_MAX; } +#endif // #if (BLE_HOST_BLE_MULTI_ADV_EN == TRUE) #if BLE_PRIVACY_SPT == TRUE /******************************************************************************* @@ -1291,7 +1345,9 @@ void BTM_BleClearBgConnDev(void) { btm_ble_start_auto_conn(FALSE); btm_ble_clear_white_list(NULL); +#if (tGATT_BG_CONN_DEV == TRUE) gatt_reset_bgdev_list(); +#endif // #if (tGATT_BG_CONN_DEV == TRUE) } /******************************************************************************* @@ -1314,7 +1370,7 @@ BOOLEAN BTM_BleUpdateBgConnDev(BOOLEAN add_remove, BD_ADDR remote_bda) BTM_TRACE_EVENT("%s() add=%d", __func__, add_remove); return btm_update_dev_to_white_list(add_remove, remote_bda, 0, NULL); } - +#if 0 /******************************************************************************* ** ** Function BTM_BleSetConnectableMode @@ -1342,7 +1398,7 @@ tBTM_STATUS BTM_BleSetConnectableMode(tBTM_BLE_CONN_MODE connectable_mode) p_cb->directed_conn = connectable_mode; return btm_ble_set_connectability( p_cb->connectable_mode); } - +#endif /******************************************************************************* ** ** Function btm_set_conn_mode_adv_init_addr @@ -1435,76 +1491,7 @@ static UINT8 btm_set_conn_mode_adv_init_addr(tBTM_BLE_INQ_CB *p_cb, return evt_type; } -/******************************************************************************* -** -** Function BTM_BleSetAdvParams -** -** Description This function is called to set advertising parameters. -** -** Parameters adv_int_min: minimum advertising interval -** adv_int_max: maximum advertising interval -** p_dir_bda: connectable direct initiator's LE device address -** chnl_map: advertising channel map. -** -** Returns void -** -*******************************************************************************/ -tBTM_STATUS BTM_BleSetAdvParams(UINT16 adv_int_min, UINT16 adv_int_max, - tBLE_BD_ADDR *p_dir_bda, - tBTM_BLE_ADV_CHNL_MAP chnl_map) -{ - tBTM_LE_RANDOM_CB *p_addr_cb = &btm_cb.ble_ctr_cb.addr_mgnt_cb; - tBTM_BLE_INQ_CB *p_cb = &btm_cb.ble_ctr_cb.inq_var; - tBTM_STATUS status = BTM_SUCCESS; - BD_ADDR p_addr_ptr = {0}; - tBLE_ADDR_TYPE init_addr_type = BLE_ADDR_PUBLIC; - tBLE_ADDR_TYPE own_addr_type = p_addr_cb->own_addr_type; - UINT8 adv_mode = p_cb->adv_mode; - - BTM_TRACE_EVENT ("BTM_BleSetAdvParams"); - - if (!controller_get_interface()->supports_ble()) { - return BTM_ILLEGAL_VALUE; - } - - if (!BTM_BLE_ISVALID_PARAM(adv_int_min, BTM_BLE_ADV_INT_MIN, BTM_BLE_ADV_INT_MAX) || - !BTM_BLE_ISVALID_PARAM(adv_int_max, BTM_BLE_ADV_INT_MIN, BTM_BLE_ADV_INT_MAX)) { - return BTM_ILLEGAL_VALUE; - } - - p_cb->adv_interval_min = adv_int_min; - p_cb->adv_interval_max = adv_int_max; - p_cb->adv_chnl_map = chnl_map; - - if (p_dir_bda) { - memcpy(&p_cb->direct_bda, p_dir_bda, sizeof(tBLE_BD_ADDR)); - } - - BTM_TRACE_EVENT ("update params for an active adv\n"); - - btm_ble_stop_adv(); - - p_cb->evt_type = btm_set_conn_mode_adv_init_addr(p_cb, p_addr_ptr, &init_addr_type, - &own_addr_type); - - /* update adv params */ - btsnd_hcic_ble_write_adv_params (p_cb->adv_interval_min, - p_cb->adv_interval_max, - p_cb->evt_type, - own_addr_type, - init_addr_type, - p_addr_ptr, - p_cb->adv_chnl_map, - p_cb->afp); - - if (adv_mode == BTM_BLE_ADV_ENABLE) { - btm_ble_start_adv(); - } - - return status; -} - - +#if (BLE_42_ADV_EN == TRUE) /******************************************************************************* ** ** Function BTM_BleSetAdvParamsAll @@ -1599,6 +1586,7 @@ tBTM_STATUS BTM_BleStartAdv(void) return status; } +#endif // #if (BLE_42_ADV_EN == TRUE) /******************************************************************************* ** ** Function BTM_BleReadAdvParams @@ -1632,6 +1620,7 @@ void BTM_BleReadAdvParams (UINT16 *adv_int_min, UINT16 *adv_int_max, } } +#if (BLE_HOST_BLE_SCAN_PARAM_UNUSED == TRUE) /******************************************************************************* ** ** Function BTM_BleSetScanParams @@ -1690,7 +1679,9 @@ void BTM_BleSetScanParams(tGATT_IF client_if, UINT32 scan_interval, UINT32 scan_ } } +#endif // #if (BLE_HOST_BLE_SCAN_PARAM_UNUSED == TRUE) +#if (BLE_42_SCAN_EN == TRUE) tBTM_STATUS BTM_BleSetScanFilterParams(tGATT_IF client_if, UINT32 scan_interval, UINT32 scan_window, tBLE_SCAN_MODE scan_mode, UINT8 addr_type_own, UINT8 scan_duplicate_filter, tBTM_BLE_SFP scan_filter_policy, tBLE_SCAN_PARAM_SETUP_CBACK scan_setup_status_cback) @@ -1746,8 +1737,9 @@ tBTM_STATUS BTM_BleSetScanFilterParams(tGATT_IF client_if, UINT32 scan_interval, osi_mutex_unlock(&scan_param_lock); return ret; } +#endif // #if (BLE_42_SCAN_EN == TRUE) - +#if (BLE_42_ADV_EN == TRUE) /******************************************************************************* ** ** Function BTM_BleWriteScanRsp @@ -1822,6 +1814,7 @@ tBTM_STATUS BTM_BleWriteScanRspRaw(UINT8 *p_raw_scan_rsp, UINT32 raw_scan_rsp_le return ret; } +#endif // #if (BLE_42_ADV_EN == TRUE) /******************************************************************************* ** @@ -1888,6 +1881,7 @@ tBTM_STATUS BTM_UpdateBleDuplicateExceptionalList(uint8_t subcode, uint32_t type return status; } +#if (BLE_42_ADV_EN == TRUE) /******************************************************************************* ** ** Function BTM_BleWriteAdvData @@ -1940,38 +1934,6 @@ tBTM_STATUS BTM_BleWriteAdvData(tBTM_BLE_AD_MASK data_mask, tBTM_BLE_ADV_DATA *p /******************************************************************************* ** -** Function BTM_BleWriteLongAdvData -** -** Description This function is called to write long advertising data. -** -** Parameters: adv_data: long advertising data -** adv_data_len: the length of long advertising data -** -** Returns void -** -*******************************************************************************/ -tBTM_STATUS BTM_BleWriteLongAdvData(uint8_t *adv_data, uint8_t adv_data_len) -{ - tBTM_STATUS status = BTM_NO_RESOURCES; - if (!controller_get_interface()->supports_ble()) { - return BTM_ILLEGAL_VALUE; - } - if(!adv_data || adv_data_len <= 0 || adv_data_len > BTM_BLE_LONG_ADV_MAX_LEN) { - return BTM_ILLEGAL_VALUE; - } - uint8_t long_adv[BTM_BLE_LONG_ADV_MAX_LEN + 1] = {0}; - long_adv[0] = adv_data_len; - memcpy(&long_adv[1], adv_data, adv_data_len); - status = BTM_VendorSpecificCommand(HCI_VENDOR_BLE_LONG_ADV_DATA, BTM_BLE_LONG_ADV_MAX_LEN + 1, long_adv, NULL); - if(status == BTM_CMD_STARTED) { - status = BTM_SUCCESS; - } - - return status; -} - -/******************************************************************************* -** ** Function BTM_BleWriteAdvDataRaw ** ** Description This function is called to write raw advertising data. @@ -1995,7 +1957,7 @@ tBTM_STATUS BTM_BleWriteAdvDataRaw(UINT8 *p_raw_adv, UINT32 raw_adv_len) return ret; } - +#endif // #if (BLE_42_ADV_EN == TRUE) /******************************************************************************* ** @@ -2082,6 +2044,7 @@ BOOLEAN BTM_BleGetCurrentAddress(BD_ADDR addr, uint8_t *addr_type) return TRUE; } +#if ((BLE_42_SCAN_EN == TRUE) || (BLE_50_EXTEND_SCAN_EN == TRUE)) /******************************************************************************* ** ** Function BTM_CheckAdvData @@ -2095,7 +2058,7 @@ BOOLEAN BTM_BleGetCurrentAddress(BD_ADDR addr, uint8_t *addr_type) ** Returns pointer of ADV data ** *******************************************************************************/ -UINT8 *BTM_CheckAdvData( UINT8 *p_adv, UINT8 type, UINT8 *p_length) +UINT8 *BTM_CheckAdvData( UINT8 *p_adv, UINT16 adv_data_len, UINT8 type, UINT8 *p_length) { UINT8 *p = p_adv; UINT8 length; @@ -2104,7 +2067,7 @@ UINT8 *BTM_CheckAdvData( UINT8 *p_adv, UINT8 type, UINT8 *p_length) STREAM_TO_UINT8(length, p); - while ( length && (p - p_adv < BTM_BLE_CACHE_ADV_DATA_MAX)) { + while ( length && (p - p_adv < adv_data_len)) { STREAM_TO_UINT8(adv_type, p); if ( adv_type == type ) { @@ -2117,7 +2080,7 @@ UINT8 *BTM_CheckAdvData( UINT8 *p_adv, UINT8 type, UINT8 *p_length) /* Break loop if advertising data is in an incorrect format, as it may lead to memory overflow */ - if (p >= p_adv + BTM_BLE_CACHE_ADV_DATA_MAX) { + if (p >= p_adv + adv_data_len) { break; } @@ -2127,7 +2090,7 @@ UINT8 *BTM_CheckAdvData( UINT8 *p_adv, UINT8 type, UINT8 *p_length) *p_length = 0; return NULL; } - +#endif // #if ((BLE_42_SCAN_EN == TRUE) || (BLE_50_EXTEND_SCAN_EN == TRUE)) /******************************************************************************* ** ** Function BTM__BLEReadDiscoverability @@ -2165,16 +2128,20 @@ UINT16 BTM_BleReadConnectability(void) void BTM_Recovery_Pre_State(void) { +#if ((BLE_42_ADV_EN == TRUE) || (BLE_42_SCAN_EN == TRUE)) tBTM_BLE_INQ_CB *ble_inq_cb = &btm_cb.ble_ctr_cb.inq_var; - +#endif // #if ((BLE_42_ADV_EN == TRUE) || (BLE_42_SCAN_EN == TRUE)) +#if (BLE_42_ADV_EN == TRUE) if (ble_inq_cb->state & BTM_BLE_ADVERTISING) { btm_ble_stop_adv(); btm_ble_start_adv(); } +#endif // #if (BLE_42_ADV_EN == TRUE) +#if (BLE_42_SCAN_EN == TRUE) if (ble_inq_cb->state & BTM_BLE_SCANNING) { btm_ble_start_scan(); } - +#endif // #if (BLE_42_SCAN_EN == TRUE) return; } @@ -2205,6 +2172,26 @@ BOOLEAN BTM_GetCurrentConnParams(BD_ADDR bda, uint16_t *interval, uint16_t *late /******************************************************************************* ** +** Function btm_ble_map_adv_tx_power +** +** Description return the actual power in dBm based on the mapping in config file +** +** Parameters advertise parameters used for this instance. +** +** Returns tx power in dBm +** +*******************************************************************************/ +static const int btm_ble_tx_power[BTM_BLE_ADV_TX_POWER_MAX + 1] = BTM_BLE_ADV_TX_POWER; +char btm_ble_map_adv_tx_power(int tx_power_index) +{ + if (0 <= tx_power_index && tx_power_index <= BTM_BLE_ADV_TX_POWER_MAX) { + return (char)btm_ble_tx_power[tx_power_index]; + } + return 0; +} + +/******************************************************************************* +** ** Function btm_ble_build_adv_data ** ** Description This function is called build the adv data and rsp data. @@ -2564,6 +2551,7 @@ void btm_ble_set_adv_flag(UINT16 connect_mode, UINT16 disc_mode) btm_ble_update_adv_flag(flag); } } +#if 0 /******************************************************************************* ** ** Function btm_ble_set_discoverability @@ -2615,7 +2603,9 @@ tBTM_STATUS btm_ble_set_discoverability(UINT16 combined_mode) if (evt_type != p_cb->evt_type || p_cb->adv_addr_type != own_addr_type || !p_cb->fast_adv_on) { +#if (BLE_42_ADV_EN == TRUE) btm_ble_stop_adv(); +#endif // #if (BLE_42_ADV_EN == TRUE) /* update adv params */ if (!btsnd_hcic_ble_write_adv_params (adv_int_min, @@ -2635,11 +2625,13 @@ tBTM_STATUS btm_ble_set_discoverability(UINT16 combined_mode) } if (status == BTM_SUCCESS && p_cb->adv_mode != new_mode) { +#if (BLE_42_ADV_EN == TRUE) if (new_mode == BTM_BLE_ADV_ENABLE) { status = btm_ble_start_adv(); } else { status = btm_ble_stop_adv(); } +#endif // #if (BLE_42_ADV_EN == TRUE) } if (p_cb->adv_mode == BTM_BLE_ADV_ENABLE) { @@ -2662,7 +2654,7 @@ tBTM_STATUS btm_ble_set_discoverability(UINT16 combined_mode) } return status; } - +#endif /******************************************************************************* ** ** Function btm_ble_set_connectability @@ -2710,7 +2702,9 @@ tBTM_STATUS btm_ble_set_connectability(UINT16 combined_mode) btm_ble_set_adv_flag (combined_mode, btm_cb.btm_inq_vars.discoverable_mode); if (p_cb->evt_type != evt_type || p_cb->adv_addr_type != p_addr_cb->own_addr_type || !p_cb->fast_adv_on) { +#if (BLE_42_ADV_EN == TRUE) btm_ble_stop_adv(); +#endif // #if (BLE_42_ADV_EN == TRUE) if (!btsnd_hcic_ble_write_adv_params (adv_int_min, adv_int_max, @@ -2730,11 +2724,13 @@ tBTM_STATUS btm_ble_set_connectability(UINT16 combined_mode) /* update advertising mode */ if (status == BTM_SUCCESS && new_mode != p_cb->adv_mode) { +#if (BLE_42_ADV_EN == TRUE) if (new_mode == BTM_BLE_ADV_ENABLE) { status = btm_ble_start_adv(); } else { status = btm_ble_stop_adv(); } +#endif // #if (BLE_42_ADV_EN == TRUE) } if (p_cb->adv_mode == BTM_BLE_ADV_ENABLE) { @@ -2795,7 +2791,9 @@ tBTM_STATUS btm_ble_start_inquiry (UINT8 mode, UINT8 duration) /* enable IRK list */ //btm_ble_enable_resolving_list_for_platform(BTM_BLE_RL_SCAN); #endif +#if (BLE_42_SCAN_EN == TRUE) status = btm_ble_start_scan(); +#endif // #if (BLE_42_SCAN_EN == TRUE) } else if ((p_ble_cb->inq_var.scan_interval != BTM_BLE_LOW_LATENCY_SCAN_INT) || (p_ble_cb->inq_var.scan_window != BTM_BLE_LOW_LATENCY_SCAN_WIN)) { BTM_TRACE_DEBUG("%s, restart LE scan with low latency scan params", __FUNCTION__); @@ -3170,7 +3168,7 @@ UINT8 btm_ble_is_discoverable(BD_ADDR bda, UINT8 evt_type, UINT8 *p) } if (p_le_inq_cb->adv_len != 0) { - if ((p_flag = BTM_CheckAdvData(p_le_inq_cb->adv_data_cache, + if ((p_flag = BTM_CheckAdvData(p_le_inq_cb->adv_data_cache, p_le_inq_cb->adv_len, BTM_BLE_AD_TYPE_FLAG, &data_len)) != NULL) { flag = * p_flag; @@ -3386,7 +3384,7 @@ BOOLEAN btm_ble_update_inq_result(BD_ADDR bda, tINQ_DB_ENT *p_i, UINT8 addr_type p_i->inq_count = p_inq->inq_counter; /* Mark entry for current inquiry */ if (p_le_inq_cb->adv_len != 0) { - if ((p_flag = BTM_CheckAdvData(p_le_inq_cb->adv_data_cache, BTM_BLE_AD_TYPE_FLAG, &len)) != NULL) { + if ((p_flag = BTM_CheckAdvData(p_le_inq_cb->adv_data_cache, p_le_inq_cb->adv_len, BTM_BLE_AD_TYPE_FLAG, &len)) != NULL) { p_cur->flag = * p_flag; } } @@ -3396,11 +3394,11 @@ BOOLEAN btm_ble_update_inq_result(BD_ADDR bda, tINQ_DB_ENT *p_i, UINT8 addr_type * then try to convert the appearance value to a class of device value Bluedroid can use. * Otherwise fall back to trying to infer if it is a HID device based on the service class. */ - p_uuid16 = BTM_CheckAdvData(p_le_inq_cb->adv_data_cache, BTM_BLE_AD_TYPE_APPEARANCE, &len); + p_uuid16 = BTM_CheckAdvData(p_le_inq_cb->adv_data_cache, p_le_inq_cb->adv_len, BTM_BLE_AD_TYPE_APPEARANCE, &len); if (p_uuid16 && len == 2) { btm_ble_appearance_to_cod((UINT16)p_uuid16[0] | (p_uuid16[1] << 8), p_cur->dev_class); } else { - if ((p_uuid16 = BTM_CheckAdvData(p_le_inq_cb->adv_data_cache, + if ((p_uuid16 = BTM_CheckAdvData(p_le_inq_cb->adv_data_cache, p_le_inq_cb->adv_len, BTM_BLE_AD_TYPE_16SRV_CMPL, &len)) != NULL) { UINT8 i; for (i = 0; i + 2 <= len; i = i + 2) { @@ -3487,10 +3485,10 @@ void btm_send_sel_conn_callback(BD_ADDR remote_bda, UINT8 evt_type, UINT8 *p_dat /* get the device name if exist in ADV data */ if (data_len != 0) { - p_dev_name = BTM_CheckAdvData(p_data, BTM_BLE_AD_TYPE_NAME_CMPL, &len); + p_dev_name = BTM_CheckAdvData(p_data, data_len, BTM_BLE_AD_TYPE_NAME_CMPL, &len); if (p_dev_name == NULL) { - p_dev_name = BTM_CheckAdvData(p_data, BTM_BLE_AD_TYPE_NAME_SHORT, &len); + p_dev_name = BTM_CheckAdvData(p_data, data_len, BTM_BLE_AD_TYPE_NAME_SHORT, &len); } if (p_dev_name) { @@ -3504,6 +3502,7 @@ void btm_send_sel_conn_callback(BD_ADDR remote_bda, UINT8 evt_type, UINT8 *p_dat } } +#if (BLE_42_SCAN_EN == TRUE) static void btm_adv_pkt_handler(void *arg) { UINT8 hci_evt_code, hci_evt_len; @@ -3546,6 +3545,7 @@ static void btm_adv_pkt_handler(void *arg) UNUSED(hci_evt_code); UNUSED(hci_evt_len); } +#endif // #if (BLE_42_SCAN_EN == TRUE) /******************************************************************************* ** @@ -3832,6 +3832,7 @@ static void btm_ble_process_adv_pkt_cont(BD_ADDR bda, UINT8 addr_type, UINT8 evt void btm_ble_process_adv_discard_evt(UINT8 *p) { +#if (BLE_42_SCAN_EN == TRUE) #if (BLE_ADV_REPORT_FLOW_CONTROL == TRUE) uint32_t num_dis = 0; STREAM_TO_UINT32 (num_dis, p); @@ -3840,6 +3841,7 @@ void btm_ble_process_adv_discard_evt(UINT8 *p) (p_obs_discard_cb)(num_dis); } #endif +#endif // #if (BLE_42_SCAN_EN == TRUE) } void btm_ble_process_direct_adv_pkt(UINT8 *p) @@ -3847,6 +3849,7 @@ void btm_ble_process_direct_adv_pkt(UINT8 *p) // TODO } +#if (BLE_42_SCAN_EN == TRUE) /******************************************************************************* ** ** Function btm_ble_start_scan @@ -3884,6 +3887,7 @@ tBTM_STATUS btm_ble_start_scan(void) osi_mutex_unlock(&scan_enable_lock); return status; } +#endif // #if (BLE_42_SCAN_EN == TRUE) /******************************************************************************* ** @@ -3933,8 +3937,10 @@ void btm_ble_stop_inquiry(void) } else if ((p_ble_cb->inq_var.scan_interval != BTM_BLE_LOW_LATENCY_SCAN_INT) || (p_ble_cb->inq_var.scan_window != BTM_BLE_LOW_LATENCY_SCAN_WIN)) { BTM_TRACE_DEBUG("%s: setting default params for ongoing observe", __FUNCTION__); +#if (BLE_42_SCAN_EN == TRUE) btm_ble_stop_scan(); btm_ble_start_scan(); +#endif // #if (BLE_42_SCAN_EN == TRUE) } /* If we have a callback registered for inquiry complete, call it */ @@ -3985,6 +3991,7 @@ static void btm_ble_stop_observe(void) *******************************************************************************/ static void btm_ble_stop_discover(void) { +#if (BLE_42_SCAN_EN == TRUE) tBTM_BLE_CB *p_ble_cb = & btm_cb.ble_ctr_cb; tBTM_CMPL_CB *p_scan_cb = p_ble_cb->p_scan_cmpl_cb; btu_stop_timer (&p_ble_cb->scan_timer_ent); @@ -3997,18 +4004,21 @@ static void btm_ble_stop_discover(void) if (!BTM_BLE_IS_SCAN_ACTIVE(p_ble_cb->scan_activity)) { /* Clear the inquiry callback if set */ - btm_cb.ble_ctr_cb.inq_var.scan_type = BTM_BLE_SCAN_MODE_NONE; btm_cb.ble_ctr_cb.inq_var.state &= ~BTM_BLE_SCANNING; /* stop discovery now */ if(btsnd_hcic_ble_set_scan_enable (BTM_BLE_SCAN_DISABLE, BTM_BLE_DUPLICATE_ENABLE)) { osi_sem_take(&scan_enable_sem, OSI_SEM_MAX_TIMEOUT); } + /* reset status */ + btm_ble_clear_topology_mask(BTM_BLE_STATE_ACTIVE_SCAN_BIT); + btm_ble_clear_topology_mask(BTM_BLE_STATE_PASSIVE_SCAN_BIT); } if (p_scan_cb) { (p_scan_cb)((tBTM_INQUIRY_CMPL *) &btm_cb.btm_inq_vars.inq_cmpl_info); } osi_mutex_unlock(&scan_enable_lock); +#endif // #if (BLE_42_SCAN_EN == TRUE) } /******************************************************************************* @@ -4021,6 +4031,7 @@ static void btm_ble_stop_discover(void) ** *******************************************************************************/ typedef BOOLEAN (BTM_TOPOLOGY_FUNC_PTR)(tBTM_BLE_STATE_MASK); +#if (BLE_42_ADV_EN == TRUE) static BOOLEAN btm_ble_adv_states_operation(BTM_TOPOLOGY_FUNC_PTR *p_handler, UINT8 adv_evt) { BOOLEAN rt = FALSE; @@ -4053,7 +4064,6 @@ static BOOLEAN btm_ble_adv_states_operation(BTM_TOPOLOGY_FUNC_PTR *p_handler, UI return rt; } - /******************************************************************************* ** ** Function btm_ble_start_adv @@ -4165,14 +4175,19 @@ tBTM_STATUS btm_ble_stop_adv(void) } return rt; } +#endif // #if (BLE_42_ADV_EN == TRUE) tBTM_STATUS btm_ble_set_random_addr(BD_ADDR random_bda) { tBTM_STATUS rt = BTM_SUCCESS; - +#if (BLE_42_ADV_EN == TRUE) osi_mutex_lock(&adv_enable_lock, OSI_MUTEX_MAX_TIMEOUT); +#endif // #if (BLE_42_ADV_EN == TRUE) +#if (BLE_42_SCAN_EN == TRUE) osi_mutex_lock(&scan_enable_lock, OSI_MUTEX_MAX_TIMEOUT); +#endif // #if (BLE_42_SCAN_EN == TRUE) +#if (BLE_42_ADV_EN == TRUE) if (btm_cb.ble_ctr_cb.inq_var.adv_mode == BTM_BLE_ADV_ENABLE) { if (btsnd_hcic_ble_set_adv_enable (BTM_BLE_ADV_DISABLE)) { osi_sem_take(&adv_enable_sem, OSI_SEM_MAX_TIMEOUT); @@ -4181,7 +4196,9 @@ tBTM_STATUS btm_ble_set_random_addr(BD_ADDR random_bda) rt = BTM_BAD_VALUE_RET; } } +#endif // #if (BLE_42_ADV_EN == TRUE) +#if (BLE_42_SCAN_EN == TRUE) if (BTM_BLE_IS_DISCO_ACTIVE(btm_cb.ble_ctr_cb.scan_activity)) { if (btsnd_hcic_ble_set_scan_enable (BTM_BLE_SCAN_DISABLE, BTM_BLE_SCAN_DUPLICATE_DISABLE)) { osi_sem_take(&scan_enable_sem, OSI_SEM_MAX_TIMEOUT); @@ -4190,11 +4207,13 @@ tBTM_STATUS btm_ble_set_random_addr(BD_ADDR random_bda) rt = BTM_BAD_VALUE_RET; } } +#endif // #if (BLE_42_SCAN_EN == TRUE) if (rt == BTM_SUCCESS) { btsnd_hcic_ble_set_random_addr(random_bda); } +#if (BLE_42_ADV_EN == TRUE) if (btm_cb.ble_ctr_cb.inq_var.adv_mode == BTM_BLE_ADV_ENABLE) { if (btsnd_hcic_ble_set_adv_enable (BTM_BLE_ADV_ENABLE)) { osi_sem_take(&adv_enable_sem, OSI_SEM_MAX_TIMEOUT); @@ -4203,7 +4222,9 @@ tBTM_STATUS btm_ble_set_random_addr(BD_ADDR random_bda) rt = BTM_BAD_VALUE_RET; } } +#endif // #if (BLE_42_ADV_EN == TRUE) +#if (BLE_42_SCAN_EN == TRUE) if (BTM_BLE_IS_DISCO_ACTIVE(btm_cb.ble_ctr_cb.scan_activity)) { if (btsnd_hcic_ble_set_scan_enable (BTM_BLE_SCAN_ENABLE, btm_cb.ble_ctr_cb.inq_var.scan_duplicate_filter)) { osi_sem_take(&scan_enable_sem, OSI_SEM_MAX_TIMEOUT); @@ -4212,9 +4233,14 @@ tBTM_STATUS btm_ble_set_random_addr(BD_ADDR random_bda) rt = BTM_BAD_VALUE_RET; } } +#endif // #if (BLE_42_SCAN_EN == TRUE) +#if (BLE_42_ADV_EN == TRUE) osi_mutex_unlock(&adv_enable_lock); +#endif // #if (BLE_42_ADV_EN == TRUE) +#if (BLE_42_SCAN_EN == TRUE) osi_mutex_unlock(&scan_enable_lock); +#endif // #if (BLE_42_SCAN_EN == TRUE) return rt; } @@ -4231,6 +4257,7 @@ tBTM_STATUS btm_ble_set_random_addr(BD_ADDR random_bda) *******************************************************************************/ static void btm_ble_start_slow_adv (void) { +#if (BLE_42_ADV_EN == TRUE) tBTM_BLE_INQ_CB *p_cb = &btm_cb.ble_ctr_cb.inq_var; if (p_cb->adv_mode == BTM_BLE_ADV_ENABLE) { @@ -4249,9 +4276,9 @@ static void btm_ble_start_slow_adv (void) p_cb->evt_type, own_addr_type, init_addr_type, p_addr_ptr, p_cb->adv_chnl_map, p_cb->afp); - btm_ble_start_adv(); } +#endif // #if (BLE_42_ADV_EN == TRUE) } /******************************************************************************* ** @@ -4291,9 +4318,11 @@ void btm_ble_timeout(TIMER_LIST_ENT *p_tle) btm_gen_resolvable_private_addr((void *)btm_gen_resolve_paddr_low); #endif } else { +#if (BLE_HOST_BLE_MULTI_ADV_EN == TRUE) if (BTM_BleMaxMultiAdvInstanceCount() > 0) { btm_ble_multi_adv_configure_rpa((tBTM_BLE_MULTI_ADV_INST *)p_tle->param); } +#endif // #if (BLE_HOST_BLE_MULTI_ADV_EN == TRUE) } } break; @@ -4515,12 +4544,36 @@ BOOLEAN btm_ble_update_mode_operation(UINT8 link_role, BD_ADDR bd_addr, UINT8 st now in order */ if (btm_ble_get_conn_st() == BLE_CONN_IDLE && status != HCI_ERR_HOST_REJECT_RESOURCES && !btm_send_pending_direct_conn()) { +#if (tGATT_BG_CONN_DEV == TRUE) bg_con = btm_ble_resume_bg_conn(); +#endif // #if (tGATT_BG_CONN_DEV == TRUE) } return bg_con; } +#if (BLE_VENDOR_HCI_EN == TRUE) +static void btm_ble_vs_evt_callback(UINT8 len, UINT8 *p) +{ + UINT8 sub_event; + + if (!len || !p) { + return; + } + + STREAM_TO_UINT8(sub_event, p); + len--; + + if (sub_event < HCI_VSE_LE_SUBEVT_BASE) { + return; + } + + if (ble_vs_evt_callback) { + ble_vs_evt_callback(sub_event, len, p); + } +} +#endif // #if (BLE_VENDOR_HCI_EN == TRUE) + /******************************************************************************* ** ** Function btm_ble_init @@ -4566,17 +4619,22 @@ void btm_ble_init (void) p_cb->scan_int = p_cb->scan_win = BTM_BLE_SCAN_PARAM_UNDEF; p_cb->inq_var.evt_type = BTM_BLE_NON_CONNECT_EVT; - +#if (BLE_42_SCAN_EN == TRUE) p_cb->adv_rpt_queue = pkt_queue_create(); assert(p_cb->adv_rpt_queue != NULL); p_cb->adv_rpt_ready = osi_event_create(btm_adv_pkt_handler, NULL); assert(p_cb->adv_rpt_ready != NULL); osi_event_bind(p_cb->adv_rpt_ready, btu_get_current_thread(), 0); - +#endif // #if (BLE_42_SCAN_EN == TRUE) #if BLE_VND_INCLUDED == FALSE +#if BLE_ANDROID_CONTROLLER_SCAN_FILTER == TRUE btm_ble_adv_filter_init(); +#endif // #if BLE_ANDROID_CONTROLLER_SCAN_FILTER == TRUE #endif +#if (BLE_VENDOR_HCI_EN == TRUE) + BTM_RegisterForVSEvents(btm_ble_vs_evt_callback, TRUE); +#endif // #if (BLE_VENDOR_HCI_EN == TRUE) } /******************************************************************************* @@ -4595,19 +4653,25 @@ void btm_ble_free (void) BTM_TRACE_DEBUG("%s", __func__); fixed_queue_free(p_cb->conn_pending_q, osi_free_func); - +#if (BLE_42_SCAN_EN == TRUE) pkt_queue_destroy(p_cb->adv_rpt_queue, NULL); p_cb->adv_rpt_queue = NULL; osi_event_delete(p_cb->adv_rpt_ready); p_cb->adv_rpt_ready = NULL; - +#endif // #if (BLE_42_SCAN_EN == TRUE) #if BTM_DYNAMIC_MEMORY == TRUE osi_free(cmn_ble_gap_vsc_cb_ptr); cmn_ble_gap_vsc_cb_ptr = NULL; #endif } +static bool enable_topology_check_flag = true; +void esp_qa_enable_topology_check(bool enable) +{ + // This is a workaround: If the topology check is disabled, the 'Supported States' will not be checked. + enable_topology_check_flag = enable; +} /******************************************************************************* ** ** Function btm_ble_topology_check @@ -4620,6 +4684,7 @@ void btm_ble_free (void) *******************************************************************************/ BOOLEAN btm_ble_topology_check(tBTM_BLE_STATE_MASK request_state_mask) { + if(!enable_topology_check_flag) return TRUE; BOOLEAN rt = FALSE; UINT8 state_offset = 0; @@ -4696,6 +4761,7 @@ BOOLEAN BTM_Ble_Authorization(BD_ADDR bd_addr, BOOLEAN authorize) return FALSE; } +#if (BLE_VENDOR_HCI_EN == TRUE) /******************************************************************************* ** ** Function BTM_BleClearAdv @@ -4717,6 +4783,30 @@ BOOLEAN BTM_BleClearAdv(tBTM_CLEAR_ADV_CMPL_CBACK *p_clear_adv_cback) p_cb->inq_var.p_clear_adv_cb = p_clear_adv_cback; return TRUE; } + +BOOLEAN BTM_BleSetCsaSupport(UINT8 csa_select, tBTM_SET_CSA_SUPPORT_CMPL_CBACK *p_callback) +{ + if (btsnd_hcic_ble_set_csa_support(csa_select) != TRUE) { + BTM_TRACE_ERROR("LE SetCsaSupport csa_select=%d: error", csa_select); + return FALSE; + } + + btm_cb.ble_ctr_cb.set_csa_support_cmpl_cb = p_callback; + return TRUE; +} + +BOOLEAN BTM_BleSetVendorEventMask(UINT32 evt_mask, tBTM_SET_VENDOR_EVT_MASK_CBACK *p_callback) +{ + if (btsnd_hcic_ble_set_vendor_evt_mask(evt_mask) != TRUE) { + BTM_TRACE_ERROR("LE SetVendorEventMask evt_mask=%x: error", evt_mask); + return FALSE; + } + + btm_cb.ble_ctr_cb.set_vendor_evt_mask_cmpl_cb = p_callback; + return TRUE; +} +#endif // #if (BLE_VENDOR_HCI_EN == TRUE) + BOOLEAN BTM_BleSetRpaTimeout(uint16_t rpa_timeout,tBTM_SET_RPA_TIMEOUT_CMPL_CBACK *p_set_rpa_timeout_cback) { if ((btsnd_hcic_ble_set_rand_priv_addr_timeout(rpa_timeout)) != TRUE) { @@ -4752,6 +4842,7 @@ BOOLEAN BTM_BleSetPrivacyMode(UINT8 addr_type, BD_ADDR bd_addr, UINT8 privacy_mo return TRUE; } +#if (BLE_42_SCAN_EN == TRUE) bool btm_ble_adv_pkt_ready(void) { tBTM_BLE_CB *p_cb = &btm_cb.ble_ctr_cb; @@ -4770,4 +4861,6 @@ bool btm_ble_adv_pkt_post(pkt_linked_item_t *pkt) pkt_queue_enqueue(p_cb->adv_rpt_queue, pkt); return true; } +#endif // #if (BLE_42_SCAN_EN == TRUE) + #endif /* BLE_INCLUDED */ diff --git a/lib/bt/host/bluedroid/stack/btm/btm_ble_iso.c b/lib/bt/host/bluedroid/stack/btm/btm_ble_iso.c new file mode 100644 index 00000000..c66f10b9 --- /dev/null +++ b/lib/bt/host/bluedroid/stack/btm/btm_ble_iso.c @@ -0,0 +1,525 @@ +/* + * SPDX-FileCopyrightText: 2015-2021 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#include "btm_int.h" +#include "stack/hcimsgs.h" +#include "osi/allocator.h" +#include "device/controller.h" +#include <string.h> +#include "l2c_int.h" + +tBTM_BLE_ISO_CBACK ble_iso_cb; + +extern void btm_ble_inter_set(bool extble_inter); + +void BTM_BleIsoRegisterCallback(tBTM_BLE_ISO_CBACK cb) +{ + if (cb) { + ble_iso_cb = cb; + } else { + BTM_TRACE_ERROR("%s, register fail, the cb function is NULL.", __func__); + } +} + +void BTM_IsoBleCallbackTrigger(tBTM_BLE_5_GAP_EVENT event, tBTM_BLE_ISO_CB_PARAMS *params) +{ + if(params && params->status == BTM_SUCCESS) { + btm_ble_inter_set(true); + } + if (ble_iso_cb) { + ble_iso_cb(event, params); + } +} + +void btm_ble_iso_read_iso_tx_sync_complete(UINT8 *p) +{ + tBTM_BLE_ISO_CB_PARAMS cb_params = {0}; + STREAM_TO_UINT8(cb_params.btm_read_tx_sync.status, p); + STREAM_TO_UINT16(cb_params.btm_read_tx_sync.conn_hdl, p); + STREAM_TO_UINT16(cb_params.btm_read_tx_sync.pkt_seq_num, p); + STREAM_TO_UINT32(cb_params.btm_read_tx_sync.tx_time_stamp, p); + STREAM_TO_UINT24(cb_params.btm_read_tx_sync.time_offset, p); + + if (cb_params.btm_read_tx_sync.status != HCI_SUCCESS) { + cb_params.btm_read_tx_sync.status = (BTM_HCI_ERROR | cb_params.btm_read_tx_sync.status); + } + cb_params.btm_read_tx_sync.conn_hdl = (cb_params.btm_read_tx_sync.conn_hdl & 0xEFF); + cb_params.btm_read_tx_sync.time_offset = (cb_params.btm_read_tx_sync.time_offset & 0xFFFFFF); + BTM_TRACE_DEBUG("read tx sync cmpl, status 0x%x conn_hdl 0x%x pkt_seq_num %d tx_time_stamp %ld time_offset %ld\n", + cb_params.btm_read_tx_sync.status, cb_params.btm_read_tx_sync.conn_hdl, cb_params.btm_read_tx_sync.pkt_seq_num, + cb_params.btm_read_tx_sync.tx_time_stamp, cb_params.btm_read_tx_sync.time_offset); + + BTM_IsoBleCallbackTrigger(BTM_BLE_ISO_READ_TX_SYNC_EVT, &cb_params); +} + +void btm_ble_iso_read_iso_link_quality_complete(UINT8 *p) +{ + tBTM_BLE_ISO_CB_PARAMS cb_params = {0}; + STREAM_TO_UINT8(cb_params.btm_read_link_quality.status, p); + STREAM_TO_UINT16(cb_params.btm_read_link_quality.conn_hdl, p); + STREAM_TO_UINT32(cb_params.btm_read_link_quality.tx_unacked_pkts, p); + STREAM_TO_UINT32(cb_params.btm_read_link_quality.tx_flushed_pkts, p); + STREAM_TO_UINT32(cb_params.btm_read_link_quality.tx_last_subevt_pkts, p); + STREAM_TO_UINT32(cb_params.btm_read_link_quality.retransmitted_pkts, p); + STREAM_TO_UINT32(cb_params.btm_read_link_quality.crc_error_pkts, p); + STREAM_TO_UINT32(cb_params.btm_read_link_quality.rx_unreceived_pkts, p); + STREAM_TO_UINT32(cb_params.btm_read_link_quality.duplicate_pkts, p); + + if (cb_params.btm_read_link_quality.status != HCI_SUCCESS) { + cb_params.btm_read_link_quality.status = (BTM_HCI_ERROR | cb_params.btm_read_link_quality.status); + } + + BTM_TRACE_DEBUG("read link quality cmpl, status 0x%x conn_hdl 0x%x tx_unacked_pkts %d tx_flushed_pkts %ld tx_last_subevt_pkts %ld retransmitted_pkts %d\ + crc_error_pkts %d rx_unreceived_pkts %d duplicate_pkts %d\n", + cb_params.btm_read_link_quality.status, cb_params.btm_read_link_quality.conn_hdl, cb_params.btm_read_link_quality.tx_unacked_pkts, + cb_params.btm_read_link_quality.tx_flushed_pkts, cb_params.btm_read_link_quality.tx_last_subevt_pkts, cb_params.btm_read_link_quality.retransmitted_pkts, + cb_params.btm_read_link_quality.crc_error_pkts, cb_params.btm_read_link_quality.rx_unreceived_pkts, cb_params.btm_read_link_quality.duplicate_pkts); + + BTM_IsoBleCallbackTrigger(BTM_BLE_ISO_READ_LINK_QUALITY_EVT, &cb_params); +} + +#if (BLE_FEAT_ISO_CIG_CENTRAL_EN == TRUE) +void btm_ble_iso_set_cig_params_complete(UINT8 *p) +{ + tBTM_BLE_ISO_CB_PARAMS cb_params = {0}; + + STREAM_TO_UINT8(cb_params.btm_set_cig_params.status, p); + STREAM_TO_UINT8(cb_params.btm_set_cig_params.cig_id, p); + STREAM_TO_UINT8(cb_params.btm_set_cig_params.cis_count, p); + for (uint8_t i = 0; i < cb_params.btm_set_cig_params.cis_count; i++) + { + STREAM_TO_UINT16(cb_params.btm_set_cig_params.conn_hdl[i], p); + BTM_TRACE_DEBUG("i = %d, conn_hdl = %d", i, cb_params.btm_set_cig_params.conn_hdl[i]); + } + + if (cb_params.btm_set_cig_params.status != HCI_SUCCESS) { + cb_params.btm_set_cig_params.status = (BTM_HCI_ERROR | cb_params.btm_set_cig_params.status); + } + + BTM_TRACE_DEBUG("set cig params, status 0x%x cig_id %d cis_count %d\n", + cb_params.btm_set_cig_params.status, cb_params.btm_set_cig_params.cig_id, cb_params.btm_set_cig_params.cis_count); + + BTM_IsoBleCallbackTrigger(BTM_BLE_ISO_SET_CIG_PARAMS_EVT, &cb_params); +} +#endif // #if (BLE_FEAT_ISO_CIG_CENTRAL_EN == TRUE) + +#if (BLE_FEAT_ISO_CIG_EN == TRUE) +void btm_ble_cis_disconnected_evt(tBTM_BLE_CIS_DISCON_CMPL *params) +{ + tBTM_BLE_ISO_CB_PARAMS cb_params = {0}; + if (!params) { + BTM_TRACE_ERROR("%s, Invalid params.", __func__); + return; + } + cb_params.btm_cis_disconnectd_evt.cis_handle = params->cis_handle; + cb_params.btm_cis_disconnectd_evt.reason = params->reason; + + BTM_TRACE_DEBUG("btm cis disconnect, cis_handle %d reason 0x%x\n", params->cis_handle, params->reason); + BTM_IsoBleCallbackTrigger(BTM_BLE_ISO_CIS_DISCONNECTED_EVT, &cb_params); +} + +void btm_ble_cis_established_evt(tBTM_BLE_CIS_ESTABLISHED_CMPL *params) +{ + tBTM_BLE_ISO_CB_PARAMS cb_params = {0}; + if (!params) { + BTM_TRACE_ERROR("%s, Invalid params.", __func__); + return; + } + + if (params->status != HCI_SUCCESS) { + params->status = (params->status | BTM_HCI_ERROR); + } + + memcpy(&cb_params.btm_cis_established_evt, params, sizeof(tBTM_BLE_CIS_ESTABLISHED_CMPL)); + + BTM_IsoBleCallbackTrigger(BTM_BLE_ISO_CIS_ESTABLISHED_EVT, &cb_params); +} +#endif // #if (BLE_FEAT_ISO_CIG_EN == TRUE) + +#if (BLE_FEAT_ISO_CIG_PERIPHERAL_EN == TRUE) +void btm_ble_cis_request_evt(tBTM_BLE_CIS_REQUEST_CMPL *params) +{ + tBTM_BLE_ISO_CB_PARAMS cb_params = {0}; + if (!params) { + BTM_TRACE_ERROR("%s, Invalid params.", __func__); + return; + } + memcpy(&cb_params.btm_cis_request_evt, params, sizeof(tBTM_BLE_CIS_REQUEST_CMPL)); + + BTM_IsoBleCallbackTrigger(BTM_BLE_ISO_CIS_REQUEST_EVT, &cb_params); +} +#endif // #if (BLE_FEAT_ISO_CIG_PERIPHERAL_EN == TRUE) + +#if (BLE_FEAT_ISO_BIG_BROCASTER_EN == TRUE) +void btm_ble_big_create_cmpl_evt(tBTM_BLE_BIG_CREATE_CMPL *params) +{ + BTM_TRACE_DEBUG("%s", __func__); + tBTM_BLE_ISO_CB_PARAMS cb_params = {0}; + if (!params) { + BTM_TRACE_ERROR("%s, Invalid params.", __func__); + return; + } + + if (params->status != HCI_SUCCESS) { + params->status = (params->status | BTM_HCI_ERROR); + } + + cb_params.btm_big_cmpl.status = params->status; + cb_params.btm_big_cmpl.big_handle = params->big_handle; + cb_params.btm_big_cmpl.big_sync_delay = params->big_sync_delay; + cb_params.btm_big_cmpl.transport_latency = params->transport_latency; + cb_params.btm_big_cmpl.phy = params->phy; + cb_params.btm_big_cmpl.nse = params->nse; + cb_params.btm_big_cmpl.bn = params->bn; + cb_params.btm_big_cmpl.pto = params->pto; + cb_params.btm_big_cmpl.irc = params->irc; + cb_params.btm_big_cmpl.max_pdu = params->max_pdu; + cb_params.btm_big_cmpl.iso_interval = params->iso_interval; + cb_params.btm_big_cmpl.num_bis = params->num_bis; + // for (uint8_t i = 0; i < params->num_bis; i++) + // { + // cb_params.btm_big_cmpl.bis_handle[i] = params->bis_handle[i]; + // } + memcpy(&cb_params.btm_big_cmpl.bis_handle[0], ¶ms->bis_handle[0], params->num_bis * 2); + + //memcpy(&cb_params.btm_big_cmpl, params, sizeof(tBTM_BLE_BIG_CREATE_CMPL)); + + BTM_IsoBleCallbackTrigger(BTM_BLE_ISO_BIG_CREATE_COMPLETE_EVT, &cb_params); +} + +void btm_ble_big_terminate_cmpl_evt(tBTM_BLE_BIG_TERMINATE_CMPL *params) +{ + tBTM_BLE_ISO_CB_PARAMS cb_params = {0}; + if (!params) { + BTM_TRACE_ERROR("%s, Invalid params.", __func__); + return; + } + memcpy(&cb_params.btm_big_term, params, sizeof(tBTM_BLE_BIG_TERMINATE_CMPL)); + + BTM_IsoBleCallbackTrigger(BTM_BLE_ISO_BIG_TERMINATE_COMPLETE_EVT, &cb_params); +} +#endif // #if (BLE_FEAT_ISO_BIG_BROCASTER_EN == TRUE) + +#if (BLE_FEAT_ISO_BIG_SYNCER_EN == TRUE) +void btm_ble_big_sync_estab_evt(tBTM_BLE_BIG_SYNC_ESTAB_CMPL *params) +{ + tBTM_BLE_ISO_CB_PARAMS cb_params = {0}; + if (!params) { + BTM_TRACE_ERROR("%s, Invalid params.", __func__); + return; + } + + if (params->status != HCI_SUCCESS) { + params->status = (params->status | BTM_HCI_ERROR); + } + + memcpy(&cb_params.btm_big_sync_estab, params, sizeof(tBTM_BLE_BIG_SYNC_ESTAB_CMPL)); + + BTM_IsoBleCallbackTrigger(BTM_BLE_ISO_BIG_SYNC_ESTABLISHED_EVT, &cb_params); +} + +void btm_ble_big_sync_terminate_complete(UINT8 hci_status, UINT8 big_handle) +{ + BTM_TRACE_DEBUG("%s hci_status 0x%x big_handle %d\n", __func__, hci_status, big_handle); + tBTM_BLE_ISO_CB_PARAMS cb_params = {0}; + + if (hci_status != HCI_SUCCESS) { + hci_status = (hci_status | BTM_HCI_ERROR); + } + + cb_params.status = hci_status; + cb_params.btm_big_sync_ter.big_hdl = big_handle; + BTM_IsoBleCallbackTrigger(BTM_BLE_ISO_BIG_SYNC_TERMINATE_COMPLETE_EVT, &cb_params); +} + +void btm_ble_big_sync_lost_evt(tBTM_BLE_BIG_SYNC_LOST_EVT *params) +{ + tBTM_BLE_ISO_CB_PARAMS cb_params = {0}; + if (!params) { + BTM_TRACE_ERROR("%s, Invalid params.", __func__); + return; + } + + memcpy(&cb_params.btm_big_sync_lost, params, sizeof(tBTM_BLE_BIG_SYNC_LOST_EVT)); + + BTM_IsoBleCallbackTrigger(BTM_BLE_ISO_BIG_SYNC_LOST_EVT, &cb_params); +} + +void btm_ble_biginfo_adv_report_evt(tBTM_BLE_BIGINFO_ADV_REPORT_EVT *params) +{ + tBTM_BLE_ISO_CB_PARAMS cb_params = {0}; + if (!params) { + BTM_TRACE_ERROR("%s, Invalid params.", __func__); + return; + } + + memcpy(&cb_params.btm_biginfo_report, params, sizeof(tBTM_BLE_BIGINFO_ADV_REPORT_EVT)); + + BTM_IsoBleCallbackTrigger(BTM_BLE_ISO_BIGINFO_ADV_REPORT_EVT, &cb_params); +} +#endif // #if (BLE_FEAT_ISO_BIG_SYNCER_EN == TRUE) + +void btm_ble_iso_data_path_update_complete(UINT16 opcode, UINT8 hci_status, UINT16 conn_handle) +{ + tBTM_BLE_ISO_CB_PARAMS cb_params = {0}; + BTM_TRACE_DEBUG("data path update cmpl, opcode 0x%x status 0x%x conn_hdl %d\n", opcode, hci_status, conn_handle); + if (hci_status != HCI_SUCCESS) { + hci_status = (BTM_HCI_ERROR | hci_status); + } + cb_params.status = hci_status; + cb_params.btm_data_path_update.op_type = ((opcode == HCI_BLE_ISO_SET_DATA_PATH) ? BTM_BLE_ISO_DATA_PATH_SETUP : BTM_BLE_ISO_DATA_PATH_REMOVE); + cb_params.btm_data_path_update.conn_hdl = conn_handle; + + BTM_IsoBleCallbackTrigger(BTM_BLE_ISO_DATA_PATH_UPFATE_EVT, &cb_params); +} + +#if (BLE_FEAT_ISO_BIG_BROCASTER_EN == TRUE) +tBTM_STATUS BTM_BleBigCreate(uint8_t big_handle, uint8_t adv_handle, uint8_t num_bis, + uint32_t sdu_interval, uint16_t max_sdu, uint16_t max_transport_latency, + uint8_t rtn, uint8_t phy, uint8_t packing, uint8_t framing, + uint8_t encryption, uint8_t *broadcast_code) +{ + BTM_TRACE_API("big_handle %d adv_handle %d num_bis %d sdu_interval %d max_sdu %d max_transport_latency %d \ + rtn %d phy %d packing %d framing %d encryption %d broadcast_code %d", big_handle, adv_handle, num_bis, sdu_interval, max_sdu, max_transport_latency,\ + rtn, phy, packing, framing, encryption, broadcast_code); + + btsnd_hcic_ble_big_create(big_handle, adv_handle, num_bis, sdu_interval, max_sdu, max_transport_latency, + rtn, phy, packing, framing, encryption, broadcast_code); + + + return BTM_SUCCESS; +} + +tBTM_STATUS BTM_BleBigCreateTest(uint8_t big_handle, uint8_t adv_handle, uint8_t num_bis, + uint32_t sdu_interval, uint16_t iso_interval, uint8_t nse, + uint16_t max_sdu, uint16_t max_pdu, uint8_t phy, + uint8_t packing, uint8_t framing, uint8_t bn, uint8_t irc, + uint8_t pto, uint8_t encryption, uint8_t *broadcast_code) +{ + btsnd_hcic_ble_big_create_test(big_handle, adv_handle, num_bis, sdu_interval, iso_interval, nse, + max_sdu, max_pdu, phy, packing, framing, bn, irc, pto, encryption, + broadcast_code); + return BTM_SUCCESS; +} + +tBTM_STATUS BTM_BleBigTerminate(UINT8 big_handle, UINT8 reason) +{ + tHCI_STATUS err = HCI_SUCCESS; + tBTM_STATUS status = BTM_SUCCESS; + tBTM_BLE_ISO_CB_PARAMS cb_params = {0}; + + if ((err = btsnd_hcic_ble_big_terminate(big_handle, reason)) != TRUE) { + BTM_TRACE_ERROR("LE PA SyncCancel, cmd err=0x%x", err); + status = BTM_HCI_ERROR | err; + } + + if (status != BTM_SUCCESS) { + cb_params.status = status; + BTM_IsoBleCallbackTrigger(BTM_BLE_ISO_BIG_TERMINATE_COMPLETE_EVT, &cb_params); + } + + return status; +} +#endif // #if (BLE_FEAT_ISO_BIG_BROCASTER_EN == TRUE) + +#if (BLE_FEAT_ISO_BIG_SYNCER_EN == TRUE) +tBTM_STATUS BTM_BleBigSyncCreate(uint8_t big_handle, uint16_t sync_handle, + uint8_t encryption, uint8_t *bc_code, + uint8_t mse, uint16_t big_sync_timeout, + uint8_t num_bis, uint8_t *bis) +{ + btsnd_hcic_ble_big_sync_create(big_handle, sync_handle, encryption, bc_code, + mse, big_sync_timeout, num_bis, bis); + return BTM_SUCCESS; +} + +tBTM_STATUS BTM_BleBigSyncTerminate(uint8_t big_handle) +{ + tHCI_STATUS err = HCI_SUCCESS; + tBTM_STATUS status = BTM_SUCCESS; + + if ((err = btsnd_hcic_ble_big_sync_terminate(big_handle)) != HCI_SUCCESS) { + BTM_TRACE_ERROR("LE big sync terminate, cmd err=0x%x", err); + status = BTM_HCI_ERROR | err; + } + + return status; +} +#endif // #if (BLE_FEAT_ISO_BIG_SYNCER_EN == TRUE) + +tBTM_STATUS BTM_BleIsoSetDataPath(uint16_t conn_handle, uint8_t data_path_dir, uint8_t data_path_id, uint8_t coding_fmt, + uint16_t company_id, uint16_t vs_codec_id, uint32_t controller_delay, uint8_t codec_len, + uint8_t *codec_cfg) +{ + tHCI_STATUS err = HCI_SUCCESS; + tBTM_STATUS status = BTM_SUCCESS; + + if (codec_len && (codec_cfg == NULL)) { + tBTM_BLE_ISO_CB_PARAMS cb_params = {0}; + status = BTM_ILLEGAL_VALUE; + cb_params.btm_data_path_update.op_type = BTM_BLE_ISO_DATA_PATH_SETUP; + cb_params.status = status; + cb_params.btm_data_path_update.conn_hdl = conn_handle; + BTM_TRACE_ERROR("codec_cfg is NULL, set data path error"); + BTM_IsoBleCallbackTrigger(BTM_BLE_ISO_DATA_PATH_UPFATE_EVT, &cb_params); + return status; + } + + BTM_TRACE_DEBUG("BTM_BleIsoSetDataPath conn_handle %d data_path_dir %d\n", conn_handle, data_path_dir); + + if ((err = btsnd_hcic_ble_iso_set_data_path(conn_handle, data_path_dir, data_path_id, coding_fmt, company_id, vs_codec_id, + controller_delay, codec_len, codec_cfg)) != HCI_SUCCESS) { + BTM_TRACE_ERROR("iso data path update, cmd err=0x%x", err); + return BTM_HCI_ERROR | err; + } + + return status; +} + +tBTM_STATUS BTM_BleIsoRemoveDataPath(uint16_t conn_handle, uint8_t data_path_dir) +{ + tHCI_STATUS err = HCI_SUCCESS; + + BTM_TRACE_DEBUG("BTM_BleIsoRemoveDataPath conn_handle %d data_path_dir %d\n", conn_handle, data_path_dir); + + if ((err = btsnd_hcic_ble_iso_remove_data_path(conn_handle, data_path_dir)) != HCI_SUCCESS) { + BTM_TRACE_ERROR("iso data path remove, cmd err=0x%x", err); + return BTM_HCI_ERROR | err; + } + + return BTM_SUCCESS; +} + +tBTM_STATUS BTM_BleIsoReadTxSync(uint16_t iso_hdl) +{ + tHCI_STATUS err = HCI_SUCCESS; + tBTM_STATUS status = BTM_SUCCESS; + + BTM_TRACE_DEBUG("BTM_BleIsoReadTxSync iso_hdl %d\n", iso_hdl); + + if ((err = btsnd_hcic_ble_iso_read_tx_sync(iso_hdl)) != HCI_SUCCESS) { + BTM_TRACE_ERROR("iso read tx sync, cmd err=0x%x", err); + status = BTM_HCI_ERROR | err; + } + + return status; +} + +tBTM_STATUS BTM_BleIsoReadLinkQuality(uint16_t iso_hdl) +{ + tHCI_STATUS err = HCI_SUCCESS; + tBTM_STATUS status = BTM_SUCCESS; + + BTM_TRACE_DEBUG("BTM_BleIsoReadLinkQuality iso_hdl %d\n", iso_hdl); + + if ((err = btsnd_hcic_ble_iso_read_iso_link_quality(iso_hdl)) != HCI_SUCCESS) { + BTM_TRACE_ERROR("iso read link quality, cmd err=0x%x", err); + status = BTM_HCI_ERROR | err; + } + + return status; +} + +#if (BLE_FEAT_ISO_CIG_CENTRAL_EN == TRUE) +tBTM_STATUS BTM_BleSetCigParams(uint8_t cig_id, uint32_t sdu_int_c_to_p, uint32_t sdu_int_p_to_c, uint8_t worse_case_SCA, uint8_t packing, + uint8_t framing, uint16_t mtl_c_to_p, uint16_t mtl_p_to_c, uint8_t cis_cnt, uint8_t *cis_params) +{ + tHCI_STATUS err = HCI_SUCCESS; + tBTM_STATUS status = BTM_SUCCESS; + + if ((err = btsnd_hcic_ble_iso_set_cig_params(cig_id, sdu_int_c_to_p, sdu_int_p_to_c, worse_case_SCA, packing, + framing, mtl_c_to_p, mtl_p_to_c, cis_cnt, (struct ble_hci_le_cis_params *)cis_params)) != HCI_SUCCESS) { + BTM_TRACE_ERROR("iso set cig params, cmd err=0x%x", err); + status = BTM_HCI_ERROR | err; + } + + return status; +} + +tBTM_STATUS BTM_BleSetCigParamsTest(uint8_t cig_id, uint32_t sdu_int_c_to_p, uint32_t sdu_int_p_to_c, uint8_t ft_c_to_p, uint8_t ft_p_to_c, uint16_t iso_interval, + uint8_t worse_case_SCA, uint8_t packing, uint8_t framing, uint8_t cis_cnt, uint8_t *cis_params) +{ + tHCI_STATUS err = HCI_SUCCESS; + tBTM_STATUS status = BTM_SUCCESS; + + if ((err = btsnd_hcic_ble_iso_set_cig_params_test(cig_id, sdu_int_c_to_p, sdu_int_p_to_c,ft_c_to_p, ft_p_to_c, iso_interval, + worse_case_SCA, packing, framing, cis_cnt, (struct ble_hci_le_cis_params_test *)cis_params)) != HCI_SUCCESS) { + BTM_TRACE_ERROR("iso set cig params test, cmd err=0x%x", err); + status = BTM_HCI_ERROR | err; + } + + return status; +} + +void btm_ble_create_cis_cmd_status(tBTM_BLE_ISO_CB_PARAMS *cb_params) +{ + BTM_IsoBleCallbackTrigger(BTM_BLE_ISO_CREATE_CIS_EVT, cb_params); +} + +tBTM_STATUS BTM_BleCreateCis(uint8_t cis_count, uint8_t *cis_hdls) +{ + btsnd_hcic_ble_iso_create_cis(cis_count, (struct ble_hci_cis_hdls *)cis_hdls); + + return BTM_SUCCESS; +} + +tBTM_STATUS BTM_BleRemoveCig(uint8_t cig_id) +{ + tHCI_STATUS err = HCI_SUCCESS; + tBTM_STATUS status = BTM_SUCCESS; + tBTM_BLE_ISO_CB_PARAMS cb_params = {0}; + + if ((err = btsnd_hcic_ble_iso_remove_cig(cig_id)) != HCI_SUCCESS) { + BTM_TRACE_ERROR("iso remove cig, cmd err=0x%x", err); + status = BTM_HCI_ERROR | err; + } + + cb_params.btm_remove_cig.status = status; + cb_params.btm_remove_cig.cig_id = cig_id; + BTM_IsoBleCallbackTrigger(BTM_BLE_ISO_REMOVE_CIG_EVT, &cb_params); + + return status; +} +#endif // #if (BLE_FEAT_ISO_CIG_CENTRAL_EN == TRUE) + +#if (BLE_FEAT_ISO_CIG_PERIPHERAL_EN == TRUE) +void btm_ble_accept_cis_req_cmd_status(tBTM_BLE_ISO_CB_PARAMS *cb_params) +{ + BTM_IsoBleCallbackTrigger(BTM_BLE_ISO_ACCEPT_CIS_REQ_EVT, cb_params); +} + +tBTM_STATUS BTM_BleAcceptCisReq(uint16_t cis_handle) +{ + btsnd_hcic_ble_iso_accept_cis_req(cis_handle); + return BTM_SUCCESS; +} + +tBTM_STATUS BTM_BleRejectCisReq(uint16_t cis_handle, uint8_t reason) +{ + tHCI_STATUS err = HCI_SUCCESS; + tBTM_STATUS status = BTM_SUCCESS; + tBTM_BLE_ISO_CB_PARAMS cb_params = {0}; + + if ((err = btsnd_hcic_ble_iso_reject_cis_req(cis_handle, reason)) != HCI_SUCCESS) { + BTM_TRACE_ERROR("iso reject cis req, cmd err=0x%x", err); + status = BTM_HCI_ERROR | err; + } + + cb_params.btm_reject_cis_req.status = status; + cb_params.btm_reject_cis_req.cis_handle = cis_handle; + BTM_IsoBleCallbackTrigger(BTM_BLE_ISO_REJECT_CIS_REQ_EVT, &cb_params); + return status; +} +#endif // #if (BLE_FEAT_ISO_CIG_PERIPHERAL_EN == TRUE) + +#if (BLE_FEAT_ISO_CIG_EN == TRUE) +tBTM_STATUS BTM_BleDisconCis(uint16_t cis_handle, uint8_t reason) +{ + btsnd_hcic_disconnect(cis_handle, reason); + + return BTM_SUCCESS; +} +#endif // #if (BLE_FEAT_ISO_CIG_EN == TRUE) diff --git a/lib/bt/host/bluedroid/stack/btm/btm_ble_multi_adv.c b/lib/bt/host/bluedroid/stack/btm/btm_ble_multi_adv.c index bc300b02..31d60546 100644 --- a/lib/bt/host/bluedroid/stack/btm/btm_ble_multi_adv.c +++ b/lib/bt/host/bluedroid/stack/btm/btm_ble_multi_adv.c @@ -22,6 +22,8 @@ #include "device/controller.h" #if (BLE_INCLUDED == TRUE) + +#if (BLE_HOST_BLE_MULTI_ADV_EN == TRUE) #include "stack/bt_types.h" #include "stack/hcimsgs.h" #include "stack/btu.h" @@ -218,25 +220,7 @@ tBTM_STATUS btm_ble_enable_multi_adv (BOOLEAN enable, UINT8 inst_id, UINT8 cb_ev } return rt; } -/******************************************************************************* -** -** Function btm_ble_map_adv_tx_power -** -** Description return the actual power in dBm based on the mapping in config file -** -** Parameters advertise parameters used for this instance. -** -** Returns tx power in dBm -** -*******************************************************************************/ -static const int btm_ble_tx_power[BTM_BLE_ADV_TX_POWER_MAX + 1] = BTM_BLE_ADV_TX_POWER; -char btm_ble_map_adv_tx_power(int tx_power_index) -{ - if (0 <= tx_power_index && tx_power_index <= BTM_BLE_ADV_TX_POWER_MAX) { - return (char)btm_ble_tx_power[tx_power_index]; - } - return 0; -} + /******************************************************************************* ** ** Function btm_ble_multi_adv_set_params @@ -882,4 +866,5 @@ void *btm_ble_multi_adv_get_ref(UINT8 inst_id) return NULL; } +#endif // #if (BLE_HOST_BLE_MULTI_ADV_EN == TRUE) #endif diff --git a/lib/bt/host/bluedroid/stack/btm/btm_ble_privacy.c b/lib/bt/host/bluedroid/stack/btm/btm_ble_privacy.c index be4b9d15..28e06658 100644 --- a/lib/bt/host/bluedroid/stack/btm/btm_ble_privacy.c +++ b/lib/bt/host/bluedroid/stack/btm/btm_ble_privacy.c @@ -330,7 +330,7 @@ void btm_ble_remove_resolving_list_entry_complete(UINT8 *p, UINT16 evt_len) BTM_TRACE_DEBUG("%s status = %d", __func__, status); if (!btm_ble_deq_resolving_pending(pseudo_bda)) { - BTM_TRACE_ERROR("%s no pending resolving list operation", __func__); + BTM_TRACE_DEBUG("%s no pending resolving list operation", __func__); return; } @@ -683,20 +683,22 @@ BOOLEAN btm_ble_suspend_resolving_list_activity(void) p_ble_cb->suspended_rl_state = BTM_BLE_RL_IDLE; +#if (BLE_42_ADV_EN == TRUE) if (p_ble_cb->inq_var.adv_mode == BTM_BLE_ADV_ENABLE) { btm_ble_stop_adv(); p_ble_cb->suspended_rl_state |= BTM_BLE_RL_ADV; } +#endif // #if (BLE_42_ADV_EN == TRUE) if (BTM_BLE_IS_SCAN_ACTIVE(p_ble_cb->scan_activity)) { btm_ble_stop_scan(); p_ble_cb->suspended_rl_state |= BTM_BLE_RL_SCAN; } - +#if (tGATT_BG_CONN_DEV == TRUE) if (btm_ble_suspend_bg_conn()) { p_ble_cb->suspended_rl_state |= BTM_BLE_RL_INIT; } - +#endif // #if (tGATT_BG_CONN_DEV == TRUE) return TRUE; } @@ -714,19 +716,21 @@ BOOLEAN btm_ble_suspend_resolving_list_activity(void) void btm_ble_resume_resolving_list_activity(void) { tBTM_BLE_CB *p_ble_cb = &btm_cb.ble_ctr_cb; - +#if (BLE_42_ADV_EN == TRUE) if (p_ble_cb->suspended_rl_state & BTM_BLE_RL_ADV) { btm_ble_start_adv(); } - +#endif // #if (BLE_42_ADV_EN == TRUE) +#if (BLE_42_SCAN_EN == TRUE) if (p_ble_cb->suspended_rl_state & BTM_BLE_RL_SCAN) { btm_ble_start_scan(); } - +#endif // #if (BLE_42_SCAN_EN == TRUE) +#if (tGATT_BG_CONN_DEV == TRUE) if (p_ble_cb->suspended_rl_state & BTM_BLE_RL_INIT) { btm_ble_resume_bg_conn(); } - +#endif // #if (tGATT_BG_CONN_DEV == TRUE) p_ble_cb->suspended_rl_state = BTM_BLE_RL_IDLE; } @@ -1147,6 +1151,9 @@ void btm_ble_add_default_entry_to_resolving_list(void) BD_ADDR peer_addr = {0x0, 0x0, 0x0, 0x0, 0x0, 0x0}; BT_OCTET16 peer_irk = {0x0}; + // Remove the existing entry in resolving list When resetting the device identity + btsnd_hcic_ble_rm_device_resolving_list(BLE_ADDR_PUBLIC, peer_addr); + btsnd_hcic_ble_add_device_resolving_list (BLE_ADDR_PUBLIC, peer_addr, peer_irk, btm_cb.devcb.id_keys.irk); } #endif diff --git a/lib/bt/host/bluedroid/stack/btm/btm_dev.c b/lib/bt/host/bluedroid/stack/btm/btm_dev.c index f9e3ed2b..f705a8dc 100644 --- a/lib/bt/host/bluedroid/stack/btm/btm_dev.c +++ b/lib/bt/host/bluedroid/stack/btm/btm_dev.c @@ -179,20 +179,33 @@ BOOLEAN BTM_SecAddDevice (BD_ADDR bd_addr, DEV_CLASS dev_class, BD_NAME bd_name, *******************************************************************************/ BOOLEAN BTM_SecDeleteDevice (BD_ADDR bd_addr, tBT_TRANSPORT transport) { - tBTM_SEC_DEV_REC *p_dev_rec; if (BTM_IsAclConnectionUp(bd_addr, transport)) { BTM_TRACE_WARNING("%s FAILED: Cannot Delete when connection is active\n", __func__); return FALSE; } + if ((p_dev_rec = btm_find_dev(bd_addr)) != NULL) { +#if (CLASSIC_BT_INCLUDED == TRUE) /* Tell controller to get rid of the link key, if it has one stored */ BTM_DeleteStoredLinkKey (p_dev_rec->bd_addr, NULL); +#endif // (CLASSIC_BT_INCLUDED == TRUE) - btm_sec_free_dev(p_dev_rec, transport); + btm_sec_free_dev(p_dev_rec, transport); } +#if (BLE_SMP_ID_RESET_ENABLE == TRUE) + /* + * There are tracking risks associated with using a fixed or static IRK. + * A best-practices approach, when all pairing and bonding records are deleted, + * assign a new randomly-generated IRK. + */ + if (list_is_empty(btm_cb.p_sec_dev_rec_list)) { + btm_ble_reset_id(); + } +#endif + return TRUE; } @@ -640,7 +653,7 @@ tBTM_SEC_DEV_REC *btm_find_oldest_dev (void) tBTM_SEC_DEV_REC *p_dev_rec = NULL; tBTM_SEC_DEV_REC *p_oldest = NULL; list_node_t *p_node = NULL; - UINT32 ot = 0xFFFFFFFF; + UINT32 old_ts = 0xFFFFFFFF; /* First look for the non-paired devices for the oldest entry */ for (p_node = list_begin(btm_cb.p_sec_dev_rec_list); p_node; p_node = list_next(p_node)) { @@ -650,13 +663,13 @@ tBTM_SEC_DEV_REC *btm_find_oldest_dev (void) continue; /* Device is paired so skip it */ } - if (p_dev_rec->timestamp < ot) { + if (p_dev_rec->timestamp < old_ts) { p_oldest = p_dev_rec; - ot = p_dev_rec->timestamp; + old_ts = p_dev_rec->timestamp; } } - if (ot != 0xFFFFFFFF) { + if (old_ts != 0xFFFFFFFF) { return (p_oldest); } @@ -666,9 +679,9 @@ tBTM_SEC_DEV_REC *btm_find_oldest_dev (void) continue; } - if (p_dev_rec->timestamp < ot) { + if (p_dev_rec->timestamp < old_ts) { p_oldest = p_dev_rec; - ot = p_dev_rec->timestamp; + old_ts = p_dev_rec->timestamp; } } return (p_oldest); diff --git a/lib/bt/host/bluedroid/stack/btm/btm_devctl.c b/lib/bt/host/bluedroid/stack/btm/btm_devctl.c index bab88739..2250c78b 100644 --- a/lib/bt/host/bluedroid/stack/btm/btm_devctl.c +++ b/lib/bt/host/bluedroid/stack/btm/btm_devctl.c @@ -82,7 +82,9 @@ void btm_dev_init (void) /* Initialize nonzero defaults */ #if (BTM_MAX_LOC_BD_NAME_LEN > 0) memset(btm_cb.cfg.ble_bd_name, 0, sizeof(tBTM_LOC_BD_NAME)); +#if (CLASSIC_BT_INCLUDED == TRUE) memset(btm_cb.cfg.bredr_bd_name, 0, sizeof(tBTM_LOC_BD_NAME)); +#endif // #if (CLASSIC_BT_INCLUDED == TRUE) #endif btm_cb.devcb.reset_timer.param = (TIMER_PARAM_TYPE)TT_DEV_RESET; @@ -169,8 +171,12 @@ static void reset_complete(void) btm_cb.ble_ctr_cb.conn_state = BLE_CONN_IDLE; btm_cb.ble_ctr_cb.bg_conn_type = BTM_BLE_CONN_NONE; btm_cb.ble_ctr_cb.p_select_cback = NULL; +#if (tGATT_BG_CONN_DEV == TRUE) gatt_reset_bgdev_list(); +#endif // #if (tGATT_BG_CONN_DEV == TRUE) +#if (BLE_HOST_BLE_MULTI_ADV_EN == TRUE) btm_ble_multi_adv_init(); +#endif // #if (BLE_HOST_BLE_MULTI_ADV_EN == TRUE) #endif btm_pm_reset(); @@ -193,6 +199,9 @@ static void reset_complete(void) if (controller->supports_ble()) { btm_ble_white_list_init(controller->get_ble_white_list_size()); + #if (BLE_50_EXTEND_SYNC_EN == TRUE) + btm_ble_periodic_adv_list_init(controller->get_ble_periodic_adv_list_size()); + #endif //#if (BLE_50_EXTEND_SYNC_EN == TRUE) l2c_link_processs_ble_num_bufs(controller->get_acl_buffer_count_ble()); } #endif @@ -471,7 +480,7 @@ tBTM_STATUS BTM_SetLocalDeviceName (char *p_name, tBT_DEVICE_TYPE name_type) btm_cb.cfg.ble_bd_name[BTM_MAX_LOC_BD_NAME_LEN] = '\0'; } } - +#if (CLASSIC_BT_INCLUDED == TRUE) if (name_type & BT_DEVICE_TYPE_BREDR) { p = (UINT8 *)btm_cb.cfg.bredr_bd_name; if (p != (UINT8 *)p_name) { @@ -479,6 +488,7 @@ tBTM_STATUS BTM_SetLocalDeviceName (char *p_name, tBT_DEVICE_TYPE name_type) btm_cb.cfg.bredr_bd_name[BTM_MAX_LOC_BD_NAME_LEN] = '\0'; } } +#endif // #if (CLASSIC_BT_INCLUDED == TRUE) #else p = (UINT8 *)p_name; #endif @@ -519,21 +529,22 @@ tBTM_STATUS BTM_ReadLocalDeviceName (char **p_name, tBT_DEVICE_TYPE name_type) */ #if BTM_MAX_LOC_BD_NAME_LEN > 0 +#if (CLASSIC_BT_INCLUDED == TRUE) if ((name_type == BT_DEVICE_TYPE_DUMO) && (BCM_STRNCMP_S(btm_cb.cfg.bredr_bd_name, btm_cb.cfg.ble_bd_name, BTM_MAX_LOC_BD_NAME_LEN) != 0)) { *p_name = NULL; BTM_TRACE_ERROR("Error, BLE and BREDR have different names, return NULL\n"); return (BTM_NO_RESOURCES); } - +#endif // #if (CLASSIC_BT_INCLUDED == TRUE) if (name_type & BT_DEVICE_TYPE_BLE) { *p_name = btm_cb.cfg.ble_bd_name; } - +#if (CLASSIC_BT_INCLUDED == TRUE) if (name_type & BT_DEVICE_TYPE_BREDR) { *p_name = btm_cb.cfg.bredr_bd_name; } - +#endif // #if (CLASSIC_BT_INCLUDED == TRUE) return (BTM_SUCCESS); #else *p_name = NULL; @@ -752,9 +763,6 @@ void btm_vsc_complete (UINT8 *p, UINT16 opcode, UINT16 evt_len, #if (BLE_INCLUDED == TRUE) tBTM_BLE_CB *ble_cb = &btm_cb.ble_ctr_cb; switch(opcode) { - case HCI_VENDOR_BLE_LONG_ADV_DATA: - BTM_TRACE_EVENT("Set long adv data complete\n"); - break; case HCI_VENDOR_BLE_UPDATE_DUPLICATE_EXCEPTIONAL_LIST: { uint8_t subcode, status; uint32_t length; STREAM_TO_UINT8(status, p); @@ -773,6 +781,22 @@ void btm_vsc_complete (UINT8 *p, UINT16 opcode, UINT16 evt_len, } break; } + case HCI_VENDOR_BLE_SET_CSA_SUPPORT: { + uint8_t status; + STREAM_TO_UINT8(status, p); + if (ble_cb && ble_cb->set_csa_support_cmpl_cb) { + ble_cb->set_csa_support_cmpl_cb(status); + } + break; + } + case HCI_VENDOR_BLE_SET_EVT_MASK: { + uint8_t status; + STREAM_TO_UINT8(status, p); + if (ble_cb && ble_cb->set_vendor_evt_mask_cmpl_cb) { + ble_cb->set_vendor_evt_mask_cmpl_cb(status); + } + break; + } default: break; } @@ -863,7 +887,7 @@ void btm_vendor_specific_evt (UINT8 *p, UINT8 evt_len) STREAM_TO_UINT8(sub_event, p_evt); /* Check in subevent if authentication is through Legacy Authentication. */ - if (sub_event == ESP_VS_REM_LEGACY_AUTH_CMP) { + if (sub_event == HCI_VENDOR_LEGACY_REM_AUTH_EVT_SUBCODE) { UINT16 hci_handle; STREAM_TO_UINT16(hci_handle, p_evt); btm_sec_handle_remote_legacy_auth_cmp(hci_handle); @@ -1066,6 +1090,7 @@ tBTM_STATUS BTM_WriteVoiceSettings(UINT16 settings) return (BTM_NO_RESOURCES); } +#if (BLE_HOST_ENABLE_TEST_MODE_EN == TRUE) /******************************************************************************* ** ** Function BTM_EnableTestMode @@ -1122,7 +1147,9 @@ tBTM_STATUS BTM_EnableTestMode(void) return (BTM_NO_RESOURCES); } } +#endif // #if (BLE_HOST_ENABLE_TEST_MODE_EN == TRUE) +#if (CLASSIC_BT_INCLUDED == TRUE) /******************************************************************************* ** ** Function BTM_DeleteStoredLinkKey @@ -1197,6 +1224,7 @@ void btm_delete_stored_link_key_complete (UINT8 *p) } } +#endif // (CLASSIC_BT_INCLUDED == TRUE) /******************************************************************************* ** ** Function btm_report_device_status diff --git a/lib/bt/host/bluedroid/stack/btm/btm_inq.c b/lib/bt/host/bluedroid/stack/btm/btm_inq.c index b8da2327..528c7a06 100644 --- a/lib/bt/host/bluedroid/stack/btm/btm_inq.c +++ b/lib/bt/host/bluedroid/stack/btm/btm_inq.c @@ -163,7 +163,7 @@ tBTM_STATUS BTM_SetDiscoverability (UINT16 inq_mode, UINT16 window, UINT16 inter UINT8 scan_mode = 0; UINT16 service_class; UINT8 *p_cod; - UINT8 major, minor; + UINT8 major, minor, reserved_2; DEV_CLASS cod; LAP temp_lap[2]; BOOLEAN is_limited; @@ -255,13 +255,14 @@ tBTM_STATUS BTM_SetDiscoverability (UINT16 inq_mode, UINT16 window, UINT16 inter if (is_limited ^ cod_limited) { BTM_COD_MINOR_CLASS(minor, p_cod ); BTM_COD_MAJOR_CLASS(major, p_cod ); + BTM_COD_RESERVED_2(reserved_2, p_cod); if (is_limited) { service_class |= BTM_COD_SERVICE_LMTD_DISCOVER; } else { service_class &= ~BTM_COD_SERVICE_LMTD_DISCOVER; } - FIELDS_TO_COD(cod, minor, major, service_class); + FIELDS_TO_COD(cod, reserved_2, minor, major, service_class); (void) BTM_SetDeviceClass (cod); } @@ -515,7 +516,7 @@ tBTM_STATUS BTM_SetPeriodicInquiryMode (tBTM_INQ_PARMS *p_inqparms, UINT16 max_d /* Before beginning the inquiry the current filter must be cleared, so initiate the command */ if ((status = btm_set_inq_event_filter (p_inqparms->filter_cond_type, &p_inqparms->filter_cond)) != BTM_CMD_STARTED) { - /* If set filter command is not succesful reset the state */ + /* If set filter command is not successful reset the state */ p_inq->p_inq_results_cb = NULL; p_inq->state = BTM_INQ_INACTIVE_STATE; @@ -688,7 +689,7 @@ UINT16 BTM_ReadConnectability (UINT16 *p_window, UINT16 *p_interval) ** Description This function returns a bit mask of the current inquiry state ** ** Returns BTM_INQUIRY_INACTIVE if inactive (0) -** BTM_LIMITED_INQUIRY_ACTIVE if a limted inquiry is active +** BTM_LIMITED_INQUIRY_ACTIVE if a limited inquiry is active ** BTM_GENERAL_INQUIRY_ACTIVE if a general inquiry is active ** BTM_PERIODIC_INQUIRY_ACTIVE if a periodic inquiry is active ** @@ -783,7 +784,7 @@ tBTM_STATUS BTM_CancelInquiry(void) ** Description This function is called to start an inquiry. ** ** Parameters: p_inqparms - pointer to the inquiry information -** mode - GENERAL or LIMITED inquiry, BR/LE bit mask seperately +** mode - GENERAL or LIMITED inquiry, BR/LE bit mask separately ** duration - length in 1.28 sec intervals (If '0', the inquiry is CANCELLED) ** max_resps - maximum amount of devices to search for before ending the inquiry ** filter_cond_type - BTM_CLR_INQUIRY_FILTER, BTM_FILTER_COND_DEVICE_CLASS, or @@ -1858,7 +1859,7 @@ void btm_process_inq_results (UINT8 *p, UINT8 inq_res_mode) #if BLE_INCLUDED == TRUE /* new device response */ && ( p_i == NULL || - /* exisiting device with BR/EDR info */ + /* existing device with BR/EDR info */ (p_i && (p_i->inq_info.results.device_type & BT_DEVICE_TYPE_BREDR) != 0) ) #endif diff --git a/lib/bt/host/bluedroid/stack/btm/btm_main.c b/lib/bt/host/bluedroid/stack/btm/btm_main.c index 8e49aa3e..67882af0 100644 --- a/lib/bt/host/bluedroid/stack/btm/btm_main.c +++ b/lib/bt/host/bluedroid/stack/btm/btm_main.c @@ -39,7 +39,9 @@ tBTM_CB *btm_cb_ptr; #if (BLE_50_FEATURE_SUPPORT == TRUE) extern void btm_ble_extendadvcb_init(void); +#if (BLE_50_EXTEND_ADV_EN == TRUE) extern void btm_ble_advrecod_init(void); +#endif // #if (BLE_50_EXTEND_ADV_EN == TRUE) #endif @@ -84,11 +86,14 @@ void btm_init (void) #if BLE_INCLUDED == TRUE btm_ble_lock_init(); btm_ble_sem_init(); + btm_cb.addr_res_en = TRUE; #endif btm_sec_dev_init(); #if (BLE_50_FEATURE_SUPPORT == TRUE) btm_ble_extendadvcb_init(); +#if (BLE_50_EXTEND_ADV_EN == TRUE) btm_ble_advrecod_init(); +#endif // #if (BLE_50_EXTEND_ADV_EN == TRUE) #endif } @@ -109,6 +114,9 @@ void btm_free(void) fixed_queue_free(btm_cb.sec_pending_q, osi_free_func); btm_acl_free(); btm_sec_dev_free(); +#if BTM_SCO_INCLUDED == TRUE + btm_sco_free(); +#endif #if BTM_DYNAMIC_MEMORY FREE_AND_RESET(btm_cb_ptr); #endif @@ -118,7 +126,8 @@ void btm_free(void) #endif } -uint8_t btm_acl_active_count(void) +#if (BLE_INCLUDED == TRUE) +uint8_t btm_ble_acl_active_count(void) { list_node_t *p_node = NULL; tACL_CONN *p_acl_conn = NULL; @@ -126,10 +135,23 @@ uint8_t btm_acl_active_count(void) for (p_node = list_begin(btm_cb.p_acl_db_list); p_node; p_node = list_next(p_node)) { p_acl_conn = list_node(p_node); - if (p_acl_conn && p_acl_conn->in_use) { + if (p_acl_conn && p_acl_conn->in_use && p_acl_conn->transport == BT_TRANSPORT_LE) { count++; } } return count; } + +// Address resolution status +uint8_t btm_get_ble_addr_resolve_disable_status(void) +{ + // Returns false if address resolution is enabled, true if disabled + return (btm_cb.addr_res_en) ? 0 : 1; +} + +void btm_ble_addr_resolve_enable(bool enable) +{ + btm_cb.addr_res_en = enable; +} +#endif /*BLE_INCLUDED*/ diff --git a/lib/bt/host/bluedroid/stack/btm/btm_pm.c b/lib/bt/host/bluedroid/stack/btm/btm_pm.c index 4c52348e..1c46a744 100644 --- a/lib/bt/host/bluedroid/stack/btm/btm_pm.c +++ b/lib/bt/host/bluedroid/stack/btm/btm_pm.c @@ -543,7 +543,7 @@ static tBTM_PM_MODE btm_pm_get_set_mode(UINT8 pm_id, tBTM_PM_MCB *p_cb, tBTM_PM_ ** Function btm_pm_snd_md_req ** Description get the resulting mode and send the resuest to host controller ** Returns tBTM_STATUS -**, BOOLEAN *p_chg_ind +** *******************************************************************************/ static tBTM_STATUS btm_pm_snd_md_req(UINT8 pm_id, UINT16 link_hdl, tBTM_PM_PWR_MD *p_mode) { @@ -565,6 +565,8 @@ static tBTM_STATUS btm_pm_snd_md_req(UINT8 pm_id, UINT16 link_hdl, tBTM_PM_PWR_M /* already in the resulting mode */ if ( (mode == BTM_PM_MD_ACTIVE) || ((md_res.max >= p_cb->interval) && (md_res.min <= p_cb->interval)) ) { + // Clear request change indication because already in result mode + p_cb->chg_ind = FALSE; return BTM_CMD_STORED; } /* Otherwise, needs to wake, then sleep */ @@ -689,7 +691,7 @@ static void btm_pm_check_stored(void) ** Description This function is called when an HCI command status event occurs ** for power manager related commands. ** -** Input Parms status - status of the event (HCI_SUCCESS if no errors) +** Input Params status - status of the event (HCI_SUCCESS if no errors) ** ** Returns none. ** @@ -717,7 +719,7 @@ void btm_pm_proc_cmd_status(UINT8 status) #if BTM_PM_DEBUG == TRUE BTM_TRACE_DEBUG( "btm_pm_proc_cmd_status new state:0x%x", p_cb->state); #endif // BTM_PM_DEBUG - } else { /* the command was not successfull. Stay in the same state */ + } else { /* the command was not successful. Stay in the same state */ pm_status = BTM_PM_STS_ERROR; } @@ -743,7 +745,7 @@ void btm_pm_proc_cmd_status(UINT8 status) ** ** Description This function is called when an HCI mode change event occurs. ** -** Input Parms hci_status - status of the event (HCI_SUCCESS if no errors) +** Input Params hci_status - status of the event (HCI_SUCCESS if no errors) ** hci_handle - connection handle associated with the change ** mode - HCI_MODE_ACTIVE, HCI_MODE_HOLD, HCI_MODE_SNIFF, or HCI_MODE_PARK ** interval - number of baseband slots (meaning depends on mode) diff --git a/lib/bt/host/bluedroid/stack/btm/btm_sco.c b/lib/bt/host/bluedroid/stack/btm/btm_sco.c index 53a9768a..69640280 100644 --- a/lib/bt/host/bluedroid/stack/btm/btm_sco.c +++ b/lib/bt/host/bluedroid/stack/btm/btm_sco.c @@ -117,14 +117,28 @@ void btm_sco_init (void) } #endif /* Initialize nonzero defaults */ - btm_cb.sco_cb.sco_disc_reason = BTM_INVALID_SCO_DISC_REASON; - btm_cb.sco_cb.def_esco_parms = btm_esco_defaults; /* Initialize with defaults */ btm_cb.sco_cb.desired_sco_mode = BTM_DEFAULT_SCO_MODE; } /******************************************************************************* ** +** Function btm_sco_free +** +** Description Free sco specific fixed_queue from btm control block +** +*******************************************************************************/ +void btm_sco_free(void) +{ +#if (BTM_SCO_HCI_INCLUDED == TRUE) + for (int i = 0; i < BTM_MAX_SCO_LINKS; i++) { + fixed_queue_free(btm_cb.sco_cb.sco_db[i].xmit_data_q, osi_free_func); + } +#endif +} + +/******************************************************************************* +** ** Function btm_esco_conn_rsp ** ** Description This function is called upon receipt of an (e)SCO connection @@ -233,7 +247,7 @@ void btm_sco_process_num_bufs (UINT16 num_lm_sco_bufs) ** pointer is used, PCM parameter maintained in ** the control block will be used; otherwise update ** control block value. -** err_data_rpt: Lisbon feature to enable the erronous data report +** err_data_rpt: Lisbon feature to enable the erroneous data report ** or not. ** ** Returns BTM_SUCCESS if the successful. @@ -598,12 +612,12 @@ static tBTM_STATUS btm_send_connect_request(UINT16 acl_handle, ** If so, we cannot use SCO-only packet types (HFP 1.7) */ if (BTM_BothEndsSupportSecureConnections(p_acl->remote_addr)) { - temp_pkt_types &= ~(BTM_SCO_PKT_TYPE_MASK); + temp_pkt_types &= ~(BTM_SCO_LINK_ONLY_MASK); BTM_TRACE_DEBUG("%s: SCO Conn: pkt_types after removing SCO (0x%04x)", __FUNCTION__, temp_pkt_types); /* Return error if no packet types left */ - if (temp_pkt_types == 0) { + if (temp_pkt_types == BTM_SCO_EXCEPTION_PKTS_MASK) { BTM_TRACE_ERROR("%s: SCO Conn (BR/EDR SC): No packet types available",__FUNCTION__); return (BTM_WRONG_MODE); } @@ -947,7 +961,7 @@ void btm_sco_conn_req (BD_ADDR bda, DEV_CLASS dev_class, UINT8 link_type) for (xx = 0; xx < BTM_MAX_SCO_LINKS; xx++, p++) { /* * If the sco state is in the SCO_ST_CONNECTING state, we still need - * to return accept sco to avoid race conditon for sco creation + * to return accept sco to avoid race condition for sco creation */ int rem_bd_matches = p->rem_bd_known && !memcmp (p->esco.data.bd_addr, bda, BD_ADDR_LEN); @@ -1032,7 +1046,6 @@ void btm_sco_connected (UINT8 hci_status, BD_ADDR bda, UINT16 hci_handle, tBTM_CHG_ESCO_PARAMS parms; #endif - btm_cb.sco_cb.sco_disc_reason = hci_status; BTM_TRACE_API("%s, handle %x", __FUNCTION__, hci_handle); #if (BTM_MAX_SCO_LINKS>0) for (xx = 0; xx < BTM_MAX_SCO_LINKS; xx++, p++) { @@ -1203,21 +1216,16 @@ void btm_remove_sco_links (BD_ADDR bda) ** Returns void ** *******************************************************************************/ -void btm_sco_removed (UINT16 hci_handle, UINT8 reason) +BOOLEAN btm_sco_removed (UINT16 hci_handle, UINT8 reason) { #if (BTM_MAX_SCO_LINKS>0) tSCO_CONN *p = &btm_cb.sco_cb.sco_db[0]; UINT16 xx; -#endif - - btm_cb.sco_cb.sco_disc_reason = reason; -#if (BTM_MAX_SCO_LINKS>0) p = &btm_cb.sco_cb.sco_db[0]; for (xx = 0; xx < BTM_MAX_SCO_LINKS; xx++, p++) { if ((p->state != SCO_ST_UNUSED) && (p->state != SCO_ST_LISTENING) && (p->hci_handle == hci_handle)) { btm_sco_flush_sco_data(xx); - p->state = SCO_ST_UNUSED; #if BTM_SCO_HCI_INCLUDED == TRUE btm_cb.sco_cb.xmit_window_size += p->sent_not_acked; @@ -1232,10 +1240,11 @@ void btm_sco_removed (UINT16 hci_handle, UINT8 reason) p->esco.p_esco_cback = NULL; /* Deregister eSCO callback */ (*p->p_disc_cb)(xx); - return; + return TRUE; } } #endif + return FALSE; } @@ -1361,24 +1370,6 @@ UINT16 BTM_ReadScoPacketTypes (UINT16 sco_inx) /******************************************************************************* ** -** Function BTM_ReadScoDiscReason -** -** Description This function is returns the reason why an (e)SCO connection -** has been removed. It contains the value until read, or until -** another (e)SCO connection has disconnected. -** -** Returns HCI reason or BTM_INVALID_SCO_DISC_REASON if not set. -** -*******************************************************************************/ -UINT16 BTM_ReadScoDiscReason (void) -{ - UINT16 res = btm_cb.sco_cb.sco_disc_reason; - btm_cb.sco_cb.sco_disc_reason = BTM_INVALID_SCO_DISC_REASON; - return (res); -} - -/******************************************************************************* -** ** Function BTM_ReadDeviceScoPacketTypes ** ** Description This function is read the SCO packet types that @@ -1878,10 +1869,6 @@ UINT8 *BTM_ReadScoBdAddr(UINT16 sco_inx) { return ((UINT8 *) NULL); } -UINT16 BTM_ReadScoDiscReason (void) -{ - return (BTM_INVALID_SCO_DISC_REASON); -} tBTM_STATUS BTM_SetEScoMode (tBTM_SCO_TYPE sco_mode, tBTM_ESCO_PARAMS *p_parms) { return (BTM_MODE_UNSUPPORTED); diff --git a/lib/bt/host/bluedroid/stack/btm/btm_sec.c b/lib/bt/host/bluedroid/stack/btm/btm_sec.c index ca5f99e1..3ed5d4b1 100644 --- a/lib/bt/host/bluedroid/stack/btm/btm_sec.c +++ b/lib/bt/host/bluedroid/stack/btm/btm_sec.c @@ -1001,12 +1001,12 @@ tBTM_STATUS btm_sec_bond_by_transport (BD_ADDR bd_addr, tBT_TRANSPORT transport, return (BTM_SUCCESS); } +#if (CLASSIC_BT_INCLUDED == TRUE) /* Tell controller to get rid of the link key if it has one stored */ if ((BTM_DeleteStoredLinkKey (bd_addr, NULL)) != BTM_SUCCESS) { return (BTM_NO_RESOURCES); } -#if (CLASSIC_BT_INCLUDED == TRUE) /* Save the PIN code if we got a valid one */ if (p_pin && (pin_len <= PIN_CODE_LEN) && (pin_len != 0)) { btm_cb.pin_code_len = pin_len; @@ -1720,7 +1720,7 @@ void BTM_RemoteOobDataReply(tBTM_STATUS res, BD_ADDR bd_addr, BT_OCTET16 c, BT_O btsnd_hcic_rem_oob_reply (bd_addr, c, r); } } - +#if 0 /******************************************************************************* ** ** Function BTM_BuildOobData @@ -1745,8 +1745,10 @@ UINT16 BTM_BuildOobData(UINT8 *p_data, UINT16 max_len, BT_OCTET16 c, UINT8 *p = p_data; UINT16 len = 0; #if BTM_MAX_LOC_BD_NAME_LEN > 0 +#if (CLASSIC_BT_INCLUDED == TRUE) UINT16 name_size; UINT8 name_type = BTM_EIR_SHORTENED_LOCAL_NAME_TYPE; +#endif // #if (CLASSIC_BT_INCLUDED == TRUE) #endif if (p_data && max_len >= BTM_OOB_MANDATORY_SIZE) { @@ -1789,6 +1791,7 @@ UINT16 BTM_BuildOobData(UINT8 *p_data, UINT16 max_len, BT_OCTET16 c, max_len -= delta; } #if BTM_MAX_LOC_BD_NAME_LEN > 0 +#if (CLASSIC_BT_INCLUDED == TRUE) name_size = name_len; if (name_size > strlen(btm_cb.cfg.bredr_bd_name)) { name_type = BTM_EIR_COMPLETE_LOCAL_NAME_TYPE; @@ -1802,6 +1805,7 @@ UINT16 BTM_BuildOobData(UINT8 *p_data, UINT16 max_len, BT_OCTET16 c, len += delta; max_len -= delta; } +#endif // #if (CLASSIC_BT_INCLUDED == TRUE) #endif /* update len */ p = p_data; @@ -1871,6 +1875,7 @@ UINT8 *BTM_ReadOobData(UINT8 *p_data, UINT8 eir_tag, UINT8 *p_len) return p_ret; } +#endif #endif ///BTM_OOB_INCLUDED == TRUE && SMP_INCLUDED == TRUE #if (CLASSIC_BT_INCLUDED == TRUE) @@ -4589,10 +4594,10 @@ tBTM_STATUS btm_sec_disconnect (UINT16 handle, UINT8 reason) ** Description This function is when a connection to the peer device is ** dropped ** -** Returns void +** Returns tBTM_SEC_DEV_REC is not NULL ** *******************************************************************************/ -void btm_sec_disconnected (UINT16 handle, UINT8 reason) +BOOLEAN btm_sec_disconnected (UINT16 handle, UINT8 reason) { tBTM_SEC_DEV_REC *p_dev_rec = btm_find_dev_by_handle (handle); UINT8 old_pairing_flags = btm_cb.pairing_flags; @@ -4608,7 +4613,7 @@ void btm_sec_disconnected (UINT16 handle, UINT8 reason) #endif if (!p_dev_rec) { - return; + return FALSE; } p_dev_rec->enc_init_by_we = FALSE; transport = (handle == p_dev_rec->hci_handle) ? BT_TRANSPORT_BR_EDR : BT_TRANSPORT_LE; @@ -4649,7 +4654,7 @@ void btm_sec_disconnected (UINT16 handle, UINT8 reason) if (p_dev_rec->sec_state == BTM_SEC_STATE_DISCONNECTING_BOTH) { p_dev_rec->sec_state = (transport == BT_TRANSPORT_LE) ? BTM_SEC_STATE_DISCONNECTING : BTM_SEC_STATE_DISCONNECTING_BLE; - return; + return TRUE; } #endif p_dev_rec->sec_state = BTM_SEC_STATE_IDLE; @@ -4685,6 +4690,7 @@ void btm_sec_disconnected (UINT16 handle, UINT8 reason) p_dev_rec->sec_bd_name, result); } } + return TRUE; } /******************************************************************************* diff --git a/lib/bt/host/bluedroid/stack/btm/include/btm_ble_int.h b/lib/bt/host/bluedroid/stack/btm/include/btm_ble_int.h index 0f8888fb..de25c6fa 100644 --- a/lib/bt/host/bluedroid/stack/btm/include/btm_ble_int.h +++ b/lib/bt/host/bluedroid/stack/btm/include/btm_ble_int.h @@ -212,11 +212,14 @@ typedef struct { #define BTM_BLE_MAX_BG_CONN_DEV_NUM 10 typedef struct { + UINT16 scan_interval; + UINT16 scan_window; UINT16 min_conn_int; UINT16 max_conn_int; UINT16 slave_latency; UINT16 supervision_tout; - + UINT16 min_ce_len; + UINT16 max_ce_len; } tBTM_LE_CONN_PRAMS; @@ -339,10 +342,10 @@ typedef struct { tBTM_INQ_RESULTS_CB *p_scan_results_cb; tBTM_CMPL_CB *p_scan_cmpl_cb; TIMER_LIST_ENT scan_timer_ent; - +#if (BLE_42_SCAN_EN == TRUE) struct pkt_queue *adv_rpt_queue; struct osi_event *adv_rpt_ready; - +#endif // #if (BLE_42_SCAN_EN == TRUE) /* background connection procedure cb value */ tBTM_BLE_CONN_TYPE bg_conn_type; UINT32 scan_int; @@ -350,6 +353,10 @@ typedef struct { tBTM_BLE_SEL_CBACK *p_select_cback; /* white list information */ UINT8 white_list_avail_size; +#if (BLE_50_EXTEND_SYNC_EN == TRUE) + /* periodic list information */ + UINT8 periodic_adv_list_size; +#endif //#if (BLE_50_EXTEND_SYNC_EN == TRUE) tBTM_UPDATE_WHITELIST_CBACK *update_wl_cb; tBTM_BLE_WL_STATE wl_state; @@ -377,6 +384,8 @@ typedef struct { tBTM_BLE_STATE_MASK cur_states; /* bit mask of tBTM_BLE_STATE */ UINT8 link_count[2]; /* total link count master and slave*/ tBTM_UPDATE_DUPLICATE_EXCEPTIONAL_LIST_CMPL_CBACK *update_exceptional_list_cmp_cb; + tBTM_SET_CSA_SUPPORT_CMPL_CBACK *set_csa_support_cmpl_cb; + tBTM_SET_VENDOR_EVT_MASK_CBACK *set_vendor_evt_mask_cmpl_cb; } tBTM_BLE_CB; #ifdef __cplusplus @@ -384,12 +393,14 @@ extern "C" { #endif void btm_ble_timeout(TIMER_LIST_ENT *p_tle); +#if (BLE_42_SCAN_EN == TRUE) void btm_ble_process_adv_pkt (UINT8 *p); void btm_ble_process_adv_discard_evt(UINT8 *p); void btm_ble_process_direct_adv_pkt (UINT8 *p); bool btm_ble_adv_pkt_ready(void); bool btm_ble_adv_pkt_post(pkt_linked_item_t *pkt); void btm_ble_proc_scan_rsp_rpt (UINT8 *p); +#endif // #if (BLE_42_SCAN_EN == TRUE) tBTM_STATUS btm_ble_read_remote_name(BD_ADDR remote_bda, tBTM_INQ_INFO *p_cur, tBTM_CMPL_CB *p_cb); BOOLEAN btm_ble_cancel_remote_name(BD_ADDR remote_bda); @@ -405,7 +416,11 @@ void btm_ble_init (void); void btm_ble_free (void); void btm_ble_connected (UINT8 *bda, UINT16 handle, UINT8 enc_mode, UINT8 role, tBLE_ADDR_TYPE addr_type, BOOLEAN addr_matched); void btm_ble_read_remote_features_complete(UINT8 *p); + +#if (BLE_42_ADV_EN == TRUE) void btm_ble_write_adv_enable_complete(UINT8 *p); +#endif // #if (BLE_42_ADV_EN == TRUE) + void btm_ble_conn_complete(UINT8 *p, UINT16 evt_len, BOOLEAN enhanced); void btm_read_ble_local_supported_states_complete(UINT8 *p, UINT16 evt_len); tBTM_BLE_CONN_ST btm_ble_get_conn_st(void); @@ -455,9 +470,12 @@ void btm_ble_remove_from_white_list_complete(UINT8 *p, UINT16 evt_len); void btm_ble_clear_white_list_complete(UINT8 *p, UINT16 evt_len); void btm_ble_white_list_init(UINT8 white_list_size); +#if (tGATT_BG_CONN_DEV == TRUE) /* background connection function */ BOOLEAN btm_ble_suspend_bg_conn(void); BOOLEAN btm_ble_resume_bg_conn(void); +#endif // #if (tGATT_BG_CONN_DEV == TRUE) + void btm_ble_initiate_select_conn(BD_ADDR bda); BOOLEAN btm_ble_start_auto_conn(BOOLEAN start); BOOLEAN btm_ble_start_select_conn(BOOLEAN start, tBTM_BLE_SEL_CBACK *p_select_cback); @@ -500,12 +518,14 @@ void btm_ble_add_default_entry_to_resolving_list(void); void btm_ble_set_privacy_mode_complete(UINT8 *p, UINT16 evt_len); #endif +#if (BLE_HOST_BLE_MULTI_ADV_EN == TRUE) void btm_ble_multi_adv_configure_rpa (tBTM_BLE_MULTI_ADV_INST *p_inst); void btm_ble_multi_adv_init(void); void *btm_ble_multi_adv_get_ref(UINT8 inst_id); void btm_ble_multi_adv_cleanup(void); void btm_ble_multi_adv_reenable(UINT8 inst_id); void btm_ble_multi_adv_enb_privacy(BOOLEAN enable); +#endif // #if (BLE_HOST_BLE_MULTI_ADV_EN == TRUE) char btm_ble_map_adv_tx_power(int tx_power_index); void btm_ble_batchscan_init(void); void btm_ble_batchscan_cleanup(void); @@ -536,12 +556,57 @@ void btm_ble_channel_select_algorithm_evt(tBTM_BLE_CHANNEL_SEL_ALG *params); void btm_ble_periodic_adv_report_evt(tBTM_PERIOD_ADV_REPORT *params); void btm_ble_periodic_adv_sync_lost_evt(tBTM_BLE_PERIOD_ADV_SYNC_LOST *params); void btm_ble_periodic_adv_sync_establish_evt(tBTM_BLE_PERIOD_ADV_SYNC_ESTAB *params); +#if (BLE_50_EXTEND_SYNC_EN == TRUE) +void btm_ble_periodic_adv_list_init(UINT8 periodic_adv_size); +#endif //#if (BLE_50_EXTEND_SYNC_EN == TRUE) #endif // #if (BLE_50_FEATURE_SUPPORT == TRUE) #if (BLE_FEAT_PERIODIC_ADV_SYNC_TRANSFER == TRUE) void btm_ble_periodic_adv_sync_trans_recv_evt(tBTM_BLE_PERIOD_ADV_SYNC_TRANS_RECV *params); #endif // #if (BLE_FEAT_PERIODIC_ADV_SYNC_TRANSFER == TRUE) +#if (BLE_FEAT_ISO_EN == TRUE) +#if (BLE_FEAT_ISO_CIG_EN == TRUE) +void btm_ble_cis_established_evt(tBTM_BLE_CIS_ESTABLISHED_CMPL *params); +void btm_ble_cis_disconnected_evt(tBTM_BLE_CIS_DISCON_CMPL *params); +#endif // #if (BLE_FEAT_ISO_CIG_EN == TRUE) +void btm_ble_iso_read_iso_tx_sync_complete(UINT8 *p); +void btm_ble_iso_read_iso_link_quality_complete(UINT8 *p); +#if (BLE_FEAT_ISO_CIG_PERIPHERAL_EN == TRUE) +void btm_ble_cis_request_evt(tBTM_BLE_CIS_REQUEST_CMPL *params); +void btm_ble_accept_cis_req_cmd_status(tBTM_BLE_ISO_CB_PARAMS *cb_params); +#endif // #if (BLE_FEAT_ISO_CIG_PERIPHERAL_EN == TRUE) +#if (BLE_FEAT_ISO_CIG_CENTRAL_EN == TRUE) +void btm_ble_create_cis_cmd_status(tBTM_BLE_ISO_CB_PARAMS *cb_params); +void btm_ble_iso_set_cig_params_complete(UINT8 *p); +#endif // #if (BLE_FEAT_ISO_CIG_CENTRAL_EN == TRUE) +#if (BLE_FEAT_ISO_BIG_BROCASTER_EN == TRUE) +void btm_ble_big_create_cmpl_evt(tBTM_BLE_BIG_CREATE_CMPL *param); +void btm_ble_big_terminate_cmpl_evt(tBTM_BLE_BIG_TERMINATE_CMPL *params); +#endif // #if (BLE_FEAT_ISO_BIG_BROCASTER_EN == TRUE) +#if (BLE_FEAT_ISO_BIG_SYNCER_EN == TRUE) +void btm_ble_big_sync_estab_evt(tBTM_BLE_BIG_SYNC_ESTAB_CMPL *params); +void btm_ble_big_sync_lost_evt(tBTM_BLE_BIG_SYNC_LOST_EVT *params); +void btm_ble_biginfo_adv_report_evt(tBTM_BLE_BIGINFO_ADV_REPORT_EVT *params); +#endif // #if (BLE_FEAT_ISO_BIG_SYNCER_EN == TRUE) +void btm_ble_iso_data_path_update_complete(UINT16 opcode, UINT8 hci_status, UINT16 conn_handle); +#endif // #if (BLE_FEAT_ISO_EN == TRUE) + +#if (BLE_FEAT_CTE_EN == TRUE) +void btm_ble_cte_read_ant_infor_complete(UINT8 *p); +void btm_ble_connless_iq_report_evt(tBTM_BLE_CTE_CONNLESS_IQ_REPORT_EVT *params); +void btm_ble_conn_iq_report_evt(tBTM_BLE_CTE_CONN_IQ_REPORT_EVT *params); +void btm_ble_cte_req_failed_evt(tBTM_BLE_CTE_REQ_FAILED_EVT *params); +#endif // #if (BLE_FEAT_CTE_EN == TRUE) + +#if (BLE_FEAT_POWER_CONTROL_EN == TRUE) +void btm_ble_path_loss_threshold_evt(tBTM_BLE_PATH_LOSS_THRESHOLD_EVT *params); +void btm_ble_transmit_power_report_evt(tBTM_BLE_TRANS_POWER_REPORT_EVT *params); +#endif // #if (BLE_FEAT_POWER_CONTROL_EN == TRUE) +#if (BLE_FEAT_CONN_SUBRATING == TRUE) +void btm_ble_subrate_change_evt(tBTM_BLE_SUBRATE_CHANGE_EVT *params); +#endif // #if (BLE_FEAT_CONN_SUBRATING == TRUE) + /* #ifdef __cplusplus } diff --git a/lib/bt/host/bluedroid/stack/btm/include/btm_int.h b/lib/bt/host/bluedroid/stack/btm/include/btm_int.h index 3d01a5c2..d5b69c68 100644 --- a/lib/bt/host/bluedroid/stack/btm/include/btm_int.h +++ b/lib/bt/host/bluedroid/stack/btm/include/btm_int.h @@ -43,13 +43,12 @@ typedef struct tBTM_SEC_DEV_REC tBTM_SEC_DEV_REC; #include "stack/smp_api.h" #endif -#define ESP_VS_REM_LEGACY_AUTH_CMP 0x03 - #if BTM_MAX_LOC_BD_NAME_LEN > 0 typedef char tBTM_LOC_BD_NAME[BTM_MAX_LOC_BD_NAME_LEN + 1]; #endif #define BTM_ACL_IS_CONNECTED(bda) (btm_bda_to_acl (bda, BT_TRANSPORT_BR_EDR) != NULL) +#define BTM_LE_ACL_IS_CONNECTED(bda) (btm_bda_to_acl (bda, BT_TRANSPORT_LE) != NULL) /* Definitions for Server Channel Number (SCN) management */ @@ -192,6 +191,10 @@ tBTM_CMPL_CB *p_rln_cmpl_cb; /* Callback function to be called when TIMER_LIST_ENT rssi_timer; tBTM_CMPL_CB *p_rssi_cmpl_cb; /* Callback function to be called when */ /* read rssi function completes */ + +tBTM_CMPL_CB *p_ble_ch_map_cmpl_cb; /* Callback function to be called when */ +/* read channel map function completes */ + TIMER_LIST_ENT lnk_quality_timer; tBTM_CMPL_CB *p_lnk_qual_cmpl_cb;/* Callback function to be called when */ /* read link quality function completes */ @@ -207,8 +210,10 @@ tBTM_ROLE_SWITCH_CMPL switch_role_ref_data; tBTM_CMPL_CB *p_switch_role_cb; /* Callback function to be called when */ /* requested switch role is completed */ +#if (BLE_HOST_READ_TX_POWER_EN == TRUE) TIMER_LIST_ENT tx_power_timer; tBTM_CMPL_CB *p_tx_power_cmpl_cb;/* Callback function to be called */ +#endif // #if (BLE_HOST_READ_TX_POWER_EN == TRUE) #if CLASSIC_BT_INCLUDED == TRUE TIMER_LIST_ENT afh_channels_timer; @@ -469,7 +474,6 @@ typedef struct { tSCO_CONN sco_db[BTM_MAX_SCO_LINKS]; tBTM_ESCO_PARAMS def_esco_parms; BD_ADDR xfer_addr; - UINT16 sco_disc_reason; BOOLEAN esco_supported; /* TRUE if 1.2 cntlr AND supports eSCO links */ tBTM_SCO_TYPE desired_sco_mode; tBTM_SCO_TYPE xfer_sco_type; @@ -724,14 +728,18 @@ struct tBTM_SEC_DEV_REC{ */ typedef struct { #if BTM_MAX_LOC_BD_NAME_LEN > 0 +#if (CLASSIC_BT_INCLUDED == TRUE) tBTM_LOC_BD_NAME bredr_bd_name; /* local BREDR device name */ +#endif // #if (CLASSIC_BT_INCLUDED == TRUE) tBTM_LOC_BD_NAME ble_bd_name; /* local BLE device name */ #endif +#if (CLASSIC_BT_INCLUDED == TRUE) BOOLEAN pin_type; /* TRUE if PIN type is fixed */ UINT8 pin_code_len; /* Bonding information */ PIN_CODE pin_code; /* PIN CODE if pin type is fixed */ - BOOLEAN connectable; /* If TRUE page scan should be enabled */ - UINT8 def_inq_scan_mode; /* ??? limited/general/none */ + // BOOLEAN connectable; /* If TRUE page scan should be enabled */ + // UINT8 def_inq_scan_mode; /* ??? limited/general/none */ +#endif // #if (CLASSIC_BT_INCLUDED == TRUE) } tBTM_CFG; enum { @@ -885,6 +893,7 @@ typedef struct { UINT16 ediv; /* received ediv value from LTK request */ UINT8 key_size; tBTM_BLE_VSC_CB cmn_ble_vsc_cb; + BOOLEAN addr_res_en; /* internal use for test: address resolution enable/disable */ #endif /* Packet types supported by the local device */ @@ -951,7 +960,7 @@ typedef struct { #endif // SMP_INCLUDED == TRUE || BT_CLASSIC_ENABLED == TRUE list_t *p_sec_dev_rec_list; tBTM_SEC_SERV_REC *p_out_serv; - tBTM_MKEY_CALLBACK *mkey_cback; + // tBTM_MKEY_CALLBACK *mkey_cback; BD_ADDR connecting_bda; DEV_CLASS connecting_dc; @@ -1063,6 +1072,7 @@ void btm_cont_rswitch (tACL_CONN *p, tACL_CONN *btm_handle_to_acl (UINT16 hci_handle); void btm_read_link_policy_complete (UINT8 *p); void btm_read_rssi_complete (UINT8 *p); +void btm_read_channel_map_complete (UINT8 *p); void btm_read_tx_power_complete (UINT8 *p, BOOLEAN is_ble); void btm_acl_pkt_types_changed(UINT8 status, UINT16 handle, UINT16 pkt_types); void btm_read_link_quality_complete (UINT8 *p); @@ -1113,17 +1123,29 @@ void btm_read_phy_callback(uint8_t hci_status, uint16_t conn_handle, uint8_t tx_ #if (BLE_FEAT_PERIODIC_ADV_SYNC_TRANSFER == TRUE) void btm_ble_periodic_adv_sync_trans_complete(UINT16 op_code, UINT8 hci_status, UINT16 conn_handle); #endif +void btm_ble_big_sync_terminate_complete(UINT8 hci_status, UINT8 big_handle); + +#if (BLE_FEAT_POWER_CONTROL_EN == TRUE) +void btm_enh_read_trans_pwr_level_cmpl_evt(uint8_t *p); +void btm_read_remote_trans_pwr_level_cmpl(UINT8 status); +#endif // #if (BLE_FEAT_POWER_CONTROL_EN == TRUE) + +#if (BLE_FEAT_CONN_SUBRATING == TRUE) +void btm_subrate_req_cmd_status(UINT8 status); +#endif // #if (BLE_FEAT_CONN_SUBRATING == TRUE) + /* Internal functions provided by btm_sco.c ******************************************** */ void btm_sco_init (void); +void btm_sco_free(void); void btm_sco_connected (UINT8 hci_status, BD_ADDR bda, UINT16 hci_handle, tBTM_ESCO_DATA *p_esco_data); void btm_esco_proc_conn_chg (UINT8 status, UINT16 handle, UINT8 tx_interval, UINT8 retrans_window, UINT16 rx_pkt_len, UINT16 tx_pkt_len); void btm_sco_conn_req (BD_ADDR bda, DEV_CLASS dev_class, UINT8 link_type); -void btm_sco_removed (UINT16 hci_handle, UINT8 reason); +BOOLEAN btm_sco_removed (UINT16 hci_handle, UINT8 reason); void btm_sco_acl_removed (BD_ADDR bda); void btm_route_sco_data (BT_HDR *p_msg); BOOLEAN btm_is_sco_active (UINT16 handle); @@ -1203,7 +1225,7 @@ void btm_sec_auth_complete (UINT16 handle, UINT8 status); void btm_sec_encrypt_change (UINT16 handle, UINT8 status, UINT8 encr_enable); void btm_sec_connected (UINT8 *bda, UINT16 handle, UINT8 status, UINT8 enc_mode); tBTM_STATUS btm_sec_disconnect (UINT16 handle, UINT8 reason); -void btm_sec_disconnected (UINT16 handle, UINT8 reason); +BOOLEAN btm_sec_disconnected (UINT16 handle, UINT8 reason); void btm_sec_rmt_name_request_complete (UINT8 *bd_addr, UINT8 *bd_name, UINT8 status); void btm_sec_rmt_host_support_feat_evt (UINT8 *p); void btm_io_capabilities_req (UINT8 *p); |