/****************************************************************************** * * Copyright (C) 1999-2012 Broadcom Corporation * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at: * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * ******************************************************************************/ /****************************************************************************** * * This file contains functions that handle BTM interface functions for the * Bluetooth device including Rest, HCI buffer size and others * ******************************************************************************/ #include #include //#include #include #include "common/bt_trace.h" #include "stack/bt_types.h" //#include "bt_utils.h" #include "btm_int.h" #include "stack/btu.h" #include "device/controller.h" #include "hci/hci_layer.h" #include "stack/hcimsgs.h" #include "l2c_int.h" //#include "btcore/include/module.h" //#include "osi/include/osi/thread.h" #if BLE_INCLUDED == TRUE #include "gatt_int.h" #endif /* BLE_INCLUDED */ //extern thread_t *bt_workqueue_thread; /********************************************************************************/ /* L O C A L D A T A D E F I N I T I O N S */ /********************************************************************************/ #ifndef BTM_DEV_RESET_TIMEOUT #define BTM_DEV_RESET_TIMEOUT 4 #endif #define BTM_DEV_REPLY_TIMEOUT 2 /* 1 second expiration time is not good. Timer may start between 0 and 1 second. */ /* if it starts at the very end of the 0 second, timer will expire really easily. */ #define BTM_INFO_TIMEOUT 5 /* 5 seconds for info response */ /********************************************************************************/ /* L O C A L F U N C T I O N P R O T O T Y P E S */ /********************************************************************************/ static void btm_decode_ext_features_page (UINT8 page_number, const BD_FEATURES p_features); /******************************************************************************* ** ** Function btm_dev_init ** ** Description This function is on the BTM startup ** ** Returns void ** *******************************************************************************/ void btm_dev_init (void) { #if 0 /* cleared in btm_init; put back in if called from anywhere else! */ memset (&btm_cb.devcb, 0, sizeof (tBTM_DEVCB)); #endif /* Initialize nonzero defaults */ #if (BTM_MAX_LOC_BD_NAME_LEN > 0) memset(btm_cb.cfg.bd_name, 0, sizeof(tBTM_LOC_BD_NAME)); #endif btm_cb.devcb.reset_timer.param = (TIMER_PARAM_TYPE)TT_DEV_RESET; btm_cb.devcb.rln_timer.param = (TIMER_PARAM_TYPE)TT_DEV_RLN; btm_cb.btm_acl_pkt_types_supported = BTM_ACL_PKT_TYPES_MASK_DH1 + BTM_ACL_PKT_TYPES_MASK_DM1 + BTM_ACL_PKT_TYPES_MASK_DH3 + BTM_ACL_PKT_TYPES_MASK_DM3 + BTM_ACL_PKT_TYPES_MASK_DH5 + BTM_ACL_PKT_TYPES_MASK_DM5; btm_cb.btm_sco_pkt_types_supported = BTM_SCO_PKT_TYPES_MASK_HV1 + BTM_SCO_PKT_TYPES_MASK_HV2 + BTM_SCO_PKT_TYPES_MASK_HV3 + BTM_SCO_PKT_TYPES_MASK_EV3 + BTM_SCO_PKT_TYPES_MASK_EV4 + BTM_SCO_PKT_TYPES_MASK_EV5; } /******************************************************************************* ** ** Function btm_db_reset ** ** Description This function is called by BTM_DeviceReset and clears out any ** pending callbacks for inquiries, discoveries, other pending ** functions that may be in progress. ** ** Returns void ** *******************************************************************************/ static void btm_db_reset (void) { tBTM_CMPL_CB *p_cb; tBTM_STATUS status = BTM_DEV_RESET; btm_inq_db_reset(); if (btm_cb.devcb.p_rln_cmpl_cb) { p_cb = btm_cb.devcb.p_rln_cmpl_cb; btm_cb.devcb.p_rln_cmpl_cb = NULL; if (p_cb) { (*p_cb)((void *) NULL); } } if (btm_cb.devcb.p_rssi_cmpl_cb) { p_cb = btm_cb.devcb.p_rssi_cmpl_cb; btm_cb.devcb.p_rssi_cmpl_cb = NULL; if (p_cb) { (*p_cb)((tBTM_RSSI_RESULTS *) &status); } } } static void reset_complete(void) { const controller_t *controller = controller_get_interface(); /* Tell L2CAP that all connections are gone */ l2cu_device_reset (); #if (SMP_INCLUDED == TRUE) /* Clear current security state */ for (int devinx = 0; devinx < BTM_SEC_MAX_DEVICE_RECORDS; devinx++) { btm_cb.sec_dev_rec[devinx].sec_state = BTM_SEC_STATE_IDLE; } #endif ///SMP_INCLUDED == TRUE /* After the reset controller should restore all parameters to defaults. */ btm_cb.btm_inq_vars.inq_counter = 1; btm_cb.btm_inq_vars.inq_scan_window = HCI_DEF_INQUIRYSCAN_WINDOW; btm_cb.btm_inq_vars.inq_scan_period = HCI_DEF_INQUIRYSCAN_INTERVAL; btm_cb.btm_inq_vars.inq_scan_type = HCI_DEF_SCAN_TYPE; btm_cb.btm_inq_vars.page_scan_window = HCI_DEF_PAGESCAN_WINDOW; btm_cb.btm_inq_vars.page_scan_period = HCI_DEF_PAGESCAN_INTERVAL; btm_cb.btm_inq_vars.page_scan_type = HCI_DEF_SCAN_TYPE; #if (BLE_INCLUDED == TRUE) 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; gatt_reset_bgdev_list(); btm_ble_multi_adv_init(); #endif btm_pm_reset(); l2c_link_processs_num_bufs(controller->get_acl_buffer_count_classic()); #if BTM_SCO_HCI_INCLUDED == TRUE btm_sco_process_num_bufs(controller->get_sco_buffer_count()); #endif #if (BLE_INCLUDED == TRUE) #if (defined BLE_PRIVACY_SPT && BLE_PRIVACY_SPT == TRUE) /* Set up the BLE privacy settings */ if (controller->supports_ble() && controller->supports_ble_privacy() && controller->get_ble_resolving_list_max_size() > 0) { btm_ble_resolving_list_init(controller->get_ble_resolving_list_max_size()); /* set the default random private address timeout */ btsnd_hcic_ble_set_rand_priv_addr_timeout(BTM_BLE_PRIVATE_ADDR_INT); } #endif if (controller->supports_ble()) { btm_ble_white_list_init(controller->get_ble_white_list_size()); l2c_link_processs_ble_num_bufs(controller->get_acl_buffer_count_ble()); } #endif #if (SMP_INCLUDED == TRUE) BTM_SetPinType (btm_cb.cfg.pin_type, btm_cb.cfg.pin_code, btm_cb.cfg.pin_code_len); #endif ///SMP_INCLUDED == TRUE for (int i = 0; i <= controller->get_last_features_classic_index(); i++) { btm_decode_ext_features_page(i, controller->get_features_classic(i)->as_array); } btm_report_device_status(BTM_DEV_STATUS_UP); } // TODO(zachoverflow): remove this function void BTM_DeviceReset (UNUSED_ATTR tBTM_CMPL_CB *p_cb) { /* Flush all ACL connections */ btm_acl_device_down(); /* Clear the callback, so application would not hang on reset */ btm_db_reset(); /* todo: review the below logic; start_up executes under another task context * reset_complete runs in btu task */ controller_get_interface()->start_up(); reset_complete(); } /******************************************************************************* ** ** Function BTM_IsDeviceUp ** ** Description This function is called to check if the device is up. ** ** Returns TRUE if device is up, else FALSE ** *******************************************************************************/ BOOLEAN BTM_IsDeviceUp (void) { return controller_get_interface()->get_is_ready(); } /******************************************************************************* ** ** Function btm_dev_timeout ** ** Description This function is called when a timer list entry expires. ** ** Returns void ** *******************************************************************************/ void btm_dev_timeout (TIMER_LIST_ENT *p_tle) { TIMER_PARAM_TYPE timer_type = (TIMER_PARAM_TYPE)p_tle->param; if (timer_type == (TIMER_PARAM_TYPE)TT_DEV_RLN) { tBTM_CMPL_CB *p_cb = btm_cb.devcb.p_rln_cmpl_cb; btm_cb.devcb.p_rln_cmpl_cb = NULL; if (p_cb) { (*p_cb)((void *) NULL); } } } /******************************************************************************* ** ** Function btm_decode_ext_features_page ** ** Description This function is decodes a features page. ** ** Returns void ** *******************************************************************************/ static void btm_decode_ext_features_page (UINT8 page_number, const UINT8 *p_features) { BTM_TRACE_DEBUG ("btm_decode_ext_features_page page: %d", page_number); switch (page_number) { /* Extended (Legacy) Page 0 */ case HCI_EXT_FEATURES_PAGE_0: /* Create ACL supported packet types mask */ btm_cb.btm_acl_pkt_types_supported = (BTM_ACL_PKT_TYPES_MASK_DH1 + BTM_ACL_PKT_TYPES_MASK_DM1); if (HCI_3_SLOT_PACKETS_SUPPORTED(p_features)) { btm_cb.btm_acl_pkt_types_supported |= (BTM_ACL_PKT_TYPES_MASK_DH3 + BTM_ACL_PKT_TYPES_MASK_DM3); } if (HCI_5_SLOT_PACKETS_SUPPORTED(p_features)) { btm_cb.btm_acl_pkt_types_supported |= (BTM_ACL_PKT_TYPES_MASK_DH5 + BTM_ACL_PKT_TYPES_MASK_DM5); } /* Add in EDR related ACL types */ if (!HCI_EDR_ACL_2MPS_SUPPORTED(p_features)) { btm_cb.btm_acl_pkt_types_supported |= (BTM_ACL_PKT_TYPES_MASK_NO_2_DH1 + BTM_ACL_PKT_TYPES_MASK_NO_2_DH3 + BTM_ACL_PKT_TYPES_MASK_NO_2_DH5); } if (!HCI_EDR_ACL_3MPS_SUPPORTED(p_features)) { btm_cb.btm_acl_pkt_types_supported |= (BTM_ACL_PKT_TYPES_MASK_NO_3_DH1 + BTM_ACL_PKT_TYPES_MASK_NO_3_DH3 + BTM_ACL_PKT_TYPES_MASK_NO_3_DH5); } /* Check to see if 3 and 5 slot packets are available */ if (HCI_EDR_ACL_2MPS_SUPPORTED(p_features) || HCI_EDR_ACL_3MPS_SUPPORTED(p_features)) { if (!HCI_3_SLOT_EDR_ACL_SUPPORTED(p_features)) { btm_cb.btm_acl_pkt_types_supported |= (BTM_ACL_PKT_TYPES_MASK_NO_2_DH3 + BTM_ACL_PKT_TYPES_MASK_NO_3_DH3); } if (!HCI_5_SLOT_EDR_ACL_SUPPORTED(p_features)) { btm_cb.btm_acl_pkt_types_supported |= (BTM_ACL_PKT_TYPES_MASK_NO_2_DH5 + BTM_ACL_PKT_TYPES_MASK_NO_3_DH5); } } BTM_TRACE_DEBUG("Local supported ACL packet types: 0x%04x", btm_cb.btm_acl_pkt_types_supported); /* Create (e)SCO supported packet types mask */ btm_cb.btm_sco_pkt_types_supported = 0; #if BTM_SCO_INCLUDED == TRUE btm_cb.sco_cb.esco_supported = FALSE; #endif if (HCI_SCO_LINK_SUPPORTED(p_features)) { btm_cb.btm_sco_pkt_types_supported = BTM_SCO_PKT_TYPES_MASK_HV1; if (HCI_HV2_PACKETS_SUPPORTED(p_features)) { btm_cb.btm_sco_pkt_types_supported |= BTM_SCO_PKT_TYPES_MASK_HV2; } if (HCI_HV3_PACKETS_SUPPORTED(p_features)) { btm_cb.btm_sco_pkt_types_supported |= BTM_SCO_PKT_TYPES_MASK_HV3; } } if (HCI_ESCO_EV3_SUPPORTED(p_features)) { btm_cb.btm_sco_pkt_types_supported |= BTM_SCO_PKT_TYPES_MASK_EV3; } if (HCI_ESCO_EV4_SUPPORTED(p_features)) { btm_cb.btm_sco_pkt_types_supported |= BTM_SCO_PKT_TYPES_MASK_EV4; } if (HCI_ESCO_EV5_SUPPORTED(p_features)) { btm_cb.btm_sco_pkt_types_supported |= BTM_SCO_PKT_TYPES_MASK_EV5; } #if BTM_SCO_INCLUDED == TRUE if (btm_cb.btm_sco_pkt_types_supported & BTM_ESCO_LINK_ONLY_MASK) { btm_cb.sco_cb.esco_supported = TRUE; /* Add in EDR related eSCO types */ if (HCI_EDR_ESCO_2MPS_SUPPORTED(p_features)) { if (!HCI_3_SLOT_EDR_ESCO_SUPPORTED(p_features)) { btm_cb.btm_sco_pkt_types_supported |= BTM_SCO_PKT_TYPES_MASK_NO_2_EV5; } } else { btm_cb.btm_sco_pkt_types_supported |= (BTM_SCO_PKT_TYPES_MASK_NO_2_EV3 + BTM_SCO_PKT_TYPES_MASK_NO_2_EV5); } if (HCI_EDR_ESCO_3MPS_SUPPORTED(p_features)) { if (!HCI_3_SLOT_EDR_ESCO_SUPPORTED(p_features)) { btm_cb.btm_sco_pkt_types_supported |= BTM_SCO_PKT_TYPES_MASK_NO_3_EV5; } } else { btm_cb.btm_sco_pkt_types_supported |= (BTM_SCO_PKT_TYPES_MASK_NO_3_EV3 + BTM_SCO_PKT_TYPES_MASK_NO_3_EV5); } } #endif BTM_TRACE_DEBUG("Local supported SCO packet types: 0x%04x", btm_cb.btm_sco_pkt_types_supported); /* Create Default Policy Settings */ if (HCI_SWITCH_SUPPORTED(p_features)) { btm_cb.btm_def_link_policy |= HCI_ENABLE_MASTER_SLAVE_SWITCH; } else { btm_cb.btm_def_link_policy &= ~HCI_ENABLE_MASTER_SLAVE_SWITCH; } if (HCI_HOLD_MODE_SUPPORTED(p_features)) { btm_cb.btm_def_link_policy |= HCI_ENABLE_HOLD_MODE; } else { btm_cb.btm_def_link_policy &= ~HCI_ENABLE_HOLD_MODE; } if (HCI_SNIFF_MODE_SUPPORTED(p_features)) { btm_cb.btm_def_link_policy |= HCI_ENABLE_SNIFF_MODE; } else { btm_cb.btm_def_link_policy &= ~HCI_ENABLE_SNIFF_MODE; } if (HCI_PARK_MODE_SUPPORTED(p_features)) { btm_cb.btm_def_link_policy |= HCI_ENABLE_PARK_MODE; } else { btm_cb.btm_def_link_policy &= ~HCI_ENABLE_PARK_MODE; } btm_sec_dev_reset (); if (HCI_LMP_INQ_RSSI_SUPPORTED(p_features)) { if (HCI_EXT_INQ_RSP_SUPPORTED(p_features)) { BTM_SetInquiryMode (BTM_INQ_RESULT_EXTENDED); } else { BTM_SetInquiryMode (BTM_INQ_RESULT_WITH_RSSI); } } #if L2CAP_NON_FLUSHABLE_PB_INCLUDED == TRUE if ( HCI_NON_FLUSHABLE_PB_SUPPORTED(p_features)) { l2cu_set_non_flushable_pbf(TRUE); } else { l2cu_set_non_flushable_pbf(FALSE); } #endif BTM_SetPageScanType (BTM_DEFAULT_SCAN_TYPE); BTM_SetInquiryScanType (BTM_DEFAULT_SCAN_TYPE); break; /* Extended Page 1 */ case HCI_EXT_FEATURES_PAGE_1: /* Nothing to do for page 1 */ break; /* Extended Page 2 */ case HCI_EXT_FEATURES_PAGE_2: /* Nothing to do for page 2 */ break; default: BTM_TRACE_ERROR("btm_decode_ext_features_page page=%d unknown", page_number); break; } } /******************************************************************************* ** ** Function BTM_SetLocalDeviceName ** ** Description This function is called to set the local device name. ** ** Returns status of the operation ** *******************************************************************************/ tBTM_STATUS BTM_SetLocalDeviceName (char *p_name) { UINT8 *p; if (!p_name || !p_name[0] || (strlen ((char *)p_name) > BD_NAME_LEN)) { return (BTM_ILLEGAL_VALUE); } if (!controller_get_interface()->get_is_ready()) { return (BTM_DEV_RESET); } #if BTM_MAX_LOC_BD_NAME_LEN > 0 /* Save the device name if local storage is enabled */ p = (UINT8 *)btm_cb.cfg.bd_name; if (p != (UINT8 *)p_name) { BCM_STRNCPY_S(btm_cb.cfg.bd_name, p_name, BTM_MAX_LOC_BD_NAME_LEN); btm_cb.cfg.bd_name[BTM_MAX_LOC_BD_NAME_LEN] = '\0'; } #else p = (UINT8 *)p_name; #endif if (btsnd_hcic_change_name(p)) { return (BTM_CMD_STARTED); } else { return (BTM_NO_RESOURCES); } } /******************************************************************************* ** ** Function BTM_ReadLocalDeviceName ** ** Description This function is called to read the local device name. ** ** Returns status of the operation ** If success, BTM_SUCCESS is returned and p_name points stored ** local device name ** If BTM doesn't store local device name, BTM_NO_RESOURCES is ** is returned and p_name is set to NULL ** *******************************************************************************/ tBTM_STATUS BTM_ReadLocalDeviceName (char **p_name) { #if BTM_MAX_LOC_BD_NAME_LEN > 0 *p_name = btm_cb.cfg.bd_name; return (BTM_SUCCESS); #else *p_name = NULL; return (BTM_NO_RESOURCES); #endif } /******************************************************************************* ** ** Function BTM_ReadLocalDeviceNameFromController ** ** Description Get local device name from controller. Do not use cached ** name (used to get chip-id prior to btm reset complete). ** ** Returns BTM_CMD_STARTED if successful, otherwise an error ** *******************************************************************************/ tBTM_STATUS BTM_ReadLocalDeviceNameFromController (tBTM_CMPL_CB *p_rln_cmpl_cback) { /* Check if rln already in progress */ if (btm_cb.devcb.p_rln_cmpl_cb) { return (BTM_NO_RESOURCES); } /* Save callback */ btm_cb.devcb.p_rln_cmpl_cb = p_rln_cmpl_cback; btsnd_hcic_read_name(); btu_start_timer (&btm_cb.devcb.rln_timer, BTU_TTYPE_BTM_DEV_CTL, BTM_DEV_REPLY_TIMEOUT); return BTM_CMD_STARTED; } /******************************************************************************* ** ** Function btm_read_local_name_complete ** ** Description This function is called when local name read complete. ** message is received from the HCI. ** ** Returns void ** *******************************************************************************/ void btm_read_local_name_complete (UINT8 *p, UINT16 evt_len) { tBTM_CMPL_CB *p_cb = btm_cb.devcb.p_rln_cmpl_cb; UINT8 status; UNUSED(evt_len); btu_free_timer (&btm_cb.devcb.rln_timer); /* If there was a callback address for read local name, call it */ btm_cb.devcb.p_rln_cmpl_cb = NULL; if (p_cb) { STREAM_TO_UINT8 (status, p); if (status == HCI_SUCCESS) { (*p_cb)(p); } else { (*p_cb)(NULL); } } } /******************************************************************************* ** ** Function BTM_SetDeviceClass ** ** Description This function is called to set the local device class ** ** Returns status of the operation ** *******************************************************************************/ tBTM_STATUS BTM_SetDeviceClass (DEV_CLASS dev_class) { if (!memcmp (btm_cb.devcb.dev_class, dev_class, DEV_CLASS_LEN)) { return (BTM_SUCCESS); } memcpy (btm_cb.devcb.dev_class, dev_class, DEV_CLASS_LEN); if (!controller_get_interface()->get_is_ready()) { return (BTM_DEV_RESET); } if (!btsnd_hcic_write_dev_class (dev_class)) { return (BTM_NO_RESOURCES); } return (BTM_SUCCESS); } /******************************************************************************* ** ** Function BTM_ReadDeviceClass ** ** Description This function is called to read the local device class ** ** Returns pointer to the device class ** *******************************************************************************/ UINT8 *BTM_ReadDeviceClass (void) { return ((UINT8 *)btm_cb.devcb.dev_class); } /******************************************************************************* ** ** Function BTM_ReadLocalFeatures ** ** Description This function is called to read the local features ** ** Returns pointer to the local features string ** *******************************************************************************/ // TODO(zachoverflow): get rid of this function UINT8 *BTM_ReadLocalFeatures (void) { // Discarding const modifier for now, until this function dies return (UINT8 *)controller_get_interface()->get_features_classic(0)->as_array; } /******************************************************************************* ** ** Function BTM_RegisterForDeviceStatusNotif ** ** Description This function is called to register for device status ** change notifications. ** ** If one registration is already there calling function should ** save the pointer to the function that is return and ** call it when processing of the event is complete ** ** Returns status of the operation ** *******************************************************************************/ tBTM_DEV_STATUS_CB *BTM_RegisterForDeviceStatusNotif (tBTM_DEV_STATUS_CB *p_cb) { tBTM_DEV_STATUS_CB *p_prev = btm_cb.devcb.p_dev_status_cb; btm_cb.devcb.p_dev_status_cb = p_cb; return (p_prev); } /******************************************************************************* ** ** Function BTM_VendorSpecificCommand ** ** Description Send a vendor specific HCI command to the controller. ** ** Returns ** BTM_SUCCESS Command sent. Does not expect command complete ** event. (command cmpl callback param is NULL) ** BTM_CMD_STARTED Command sent. Waiting for command cmpl event. ** ** Notes ** Opcode will be OR'd with HCI_GRP_VENDOR_SPECIFIC. ** *******************************************************************************/ tBTM_STATUS BTM_VendorSpecificCommand(UINT16 opcode, UINT8 param_len, UINT8 *p_param_buf, tBTM_VSC_CMPL_CB *p_cb) { void *p_buf; BTM_TRACE_EVENT ("BTM: BTM_VendorSpecificCommand: Opcode: 0x%04X, ParamLen: %i.", opcode, param_len); /* Allocate a buffer to hold HCI command plus the callback function */ if ((p_buf = osi_malloc((UINT16)(sizeof(BT_HDR) + sizeof (tBTM_CMPL_CB *) + param_len + HCIC_PREAMBLE_SIZE))) != NULL) { /* Send the HCI command (opcode will be OR'd with HCI_GRP_VENDOR_SPECIFIC) */ btsnd_hcic_vendor_spec_cmd (p_buf, opcode, param_len, p_param_buf, (void *)p_cb); /* Return value */ if (p_cb != NULL) { return (BTM_CMD_STARTED); } else { return (BTM_SUCCESS); } } else { return (BTM_NO_RESOURCES); } } /******************************************************************************* ** ** Function btm_vsc_complete ** ** Description This function is called when local HCI Vendor Specific ** Command complete message is received from the HCI. ** ** Returns void ** *******************************************************************************/ void btm_vsc_complete (UINT8 *p, UINT16 opcode, UINT16 evt_len, tBTM_CMPL_CB *p_vsc_cplt_cback) { 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); STREAM_TO_UINT8(subcode, p); STREAM_TO_UINT32(length, p); if(ble_cb && ble_cb->update_exceptional_list_cmp_cb) { (*ble_cb->update_exceptional_list_cmp_cb)(status, subcode, length, p); } break; } default: break; } tBTM_VSC_CMPL vcs_cplt_params; /* If there was a callback address for vcs complete, call it */ if (p_vsc_cplt_cback) { /* Pass paramters to the callback function */ vcs_cplt_params.opcode = opcode; /* Number of bytes in return info */ vcs_cplt_params.param_len = evt_len; /* Number of bytes in return info */ vcs_cplt_params.p_param_buf = p; (*p_vsc_cplt_cback)(&vcs_cplt_params); /* Call the VSC complete callback function */ } } /******************************************************************************* ** ** Function BTM_RegisterForVSEvents ** ** Description This function is called to register/deregister for vendor ** specific HCI events. ** ** If is_register=TRUE, then the function will be registered; ** if is_register=FALSE, then the function will be deregistered. ** ** Returns BTM_SUCCESS if successful, ** BTM_BUSY if maximum number of callbacks have already been ** registered. ** *******************************************************************************/ tBTM_STATUS BTM_RegisterForVSEvents (tBTM_VS_EVT_CB *p_cb, BOOLEAN is_register) { tBTM_STATUS retval = BTM_SUCCESS; UINT8 i, free_idx = BTM_MAX_VSE_CALLBACKS; /* See if callback is already registered */ for (i = 0; i < BTM_MAX_VSE_CALLBACKS; i++) { if (btm_cb.devcb.p_vend_spec_cb[i] == NULL) { /* Found a free slot. Store index */ free_idx = i; } else if (btm_cb.devcb.p_vend_spec_cb[i] == p_cb) { /* Found callback in lookup table. If deregistering, clear the entry. */ if (is_register == FALSE) { btm_cb.devcb.p_vend_spec_cb[i] = NULL; BTM_TRACE_EVENT("BTM Deregister For VSEvents is successfully"); } return (BTM_SUCCESS); } } /* Didn't find callback. Add callback to free slot if registering */ if (is_register) { if (free_idx < BTM_MAX_VSE_CALLBACKS) { btm_cb.devcb.p_vend_spec_cb[free_idx] = p_cb; BTM_TRACE_EVENT("BTM Register For VSEvents is successfully"); } else { /* No free entries available */ BTM_TRACE_ERROR ("BTM_RegisterForVSEvents: too many callbacks registered"); retval = BTM_NO_RESOURCES; } } return (retval); } /******************************************************************************* ** ** Function btm_vendor_specific_evt ** ** Description Process event HCI_VENDOR_SPECIFIC_EVT ** ** Note: Some controllers do not send command complete, so ** the callback and busy flag are cleared here also. ** ** Returns void ** *******************************************************************************/ void btm_vendor_specific_evt (UINT8 *p, UINT8 evt_len) { UINT8 i; #if (CLASSIC_BT_INCLUDED == TRUE) UINT8 sub_event; UINT8 *p_evt = p; 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) { UINT16 hci_handle; STREAM_TO_UINT16(hci_handle, p_evt); btm_sec_handle_remote_legacy_auth_cmp(hci_handle); } #endif /// (CLASSIC_BT_INCLUDED == TRUE) for (i = 0; i < BTM_MAX_VSE_CALLBACKS; i++) { if (btm_cb.devcb.p_vend_spec_cb[i]) { (*btm_cb.devcb.p_vend_spec_cb[i])(evt_len, p); } } BTM_TRACE_DEBUG ("BTM Event: Vendor Specific event from controller"); } /******************************************************************************* ** ** Function BTM_WritePageTimeout ** ** Description Send HCI Write Page Timeout. ** ** Returns ** BTM_SUCCESS Command sent. ** BTM_NO_RESOURCES If out of resources to send the command. ** ** *******************************************************************************/ tBTM_STATUS BTM_WritePageTimeout(UINT16 timeout) { BTM_TRACE_EVENT ("BTM: BTM_WritePageTimeout: Timeout: %d.", timeout); /* Send the HCI command */ if (btsnd_hcic_write_page_tout (timeout)) { return (BTM_SUCCESS); } else { return (BTM_NO_RESOURCES); } } /******************************************************************************* ** ** Function BTM_WriteVoiceSettings ** ** Description Send HCI Write Voice Settings command. ** See stack/hcidefs.h for settings bitmask values. ** ** Returns ** BTM_SUCCESS Command sent. ** BTM_NO_RESOURCES If out of resources to send the command. ** ** *******************************************************************************/ tBTM_STATUS BTM_WriteVoiceSettings(UINT16 settings) { BTM_TRACE_EVENT ("BTM: BTM_WriteVoiceSettings: Settings: 0x%04x.", settings); /* Send the HCI command */ if (btsnd_hcic_write_voice_settings ((UINT16)(settings & 0x03ff))) { return (BTM_SUCCESS); } return (BTM_NO_RESOURCES); } /******************************************************************************* ** ** Function BTM_EnableTestMode ** ** Description Send HCI the enable device under test command. ** ** Note: Controller can only be taken out of this mode by ** resetting the controller. ** ** Returns ** BTM_SUCCESS Command sent. ** BTM_NO_RESOURCES If out of resources to send the command. ** ** *******************************************************************************/ tBTM_STATUS BTM_EnableTestMode(void) { UINT8 cond; BTM_TRACE_EVENT ("BTM: BTM_EnableTestMode"); /* set auto accept connection as this is needed during test mode */ /* Allocate a buffer to hold HCI command */ cond = HCI_DO_AUTO_ACCEPT_CONNECT; if (!btsnd_hcic_set_event_filter(HCI_FILTER_CONNECTION_SETUP, HCI_FILTER_COND_NEW_DEVICE, &cond, sizeof(cond))) { return (BTM_NO_RESOURCES); } /* put device to connectable mode */ if (!BTM_SetConnectability(BTM_CONNECTABLE, BTM_DEFAULT_CONN_WINDOW, BTM_DEFAULT_CONN_INTERVAL) == BTM_SUCCESS) { return BTM_NO_RESOURCES; } /* put device to discoverable mode */ if (!BTM_SetDiscoverability(BTM_GENERAL_DISCOVERABLE, BTM_DEFAULT_DISC_WINDOW, BTM_DEFAULT_DISC_INTERVAL) == BTM_SUCCESS) { return BTM_NO_RESOURCES; } /* mask off all of event from controller */ hci_layer_get_interface()->transmit_command( hci_packet_factory_get_interface()->make_set_event_mask((const bt_event_mask_t *)("\x00\x00\x00\x00\x00\x00\x00\x00")), NULL, NULL, NULL); /* Send the HCI command */ if (btsnd_hcic_enable_test_mode ()) { return (BTM_SUCCESS); } else { return (BTM_NO_RESOURCES); } } /******************************************************************************* ** ** Function BTM_DeleteStoredLinkKey ** ** Description This function is called to delete link key for the specified ** device addresses from the NVRAM storage attached to the Bluetooth ** controller. ** ** Parameters: bd_addr - Addresses of the devices ** p_cb - Call back function to be called to return ** the results ** *******************************************************************************/ tBTM_STATUS BTM_DeleteStoredLinkKey(BD_ADDR bd_addr, tBTM_CMPL_CB *p_cb) { BD_ADDR local_bd_addr; BOOLEAN delete_all_flag = FALSE; /* Check if the previous command is completed */ if (btm_cb.devcb.p_stored_link_key_cmpl_cb) { return (BTM_BUSY); } if (!bd_addr) { /* This is to delete all link keys */ delete_all_flag = TRUE; /* We don't care the BD address. Just pass a non zero pointer */ bd_addr = local_bd_addr; } BTM_TRACE_EVENT ("BTM: BTM_DeleteStoredLinkKey: delete_all_flag: %s", delete_all_flag ? "TRUE" : "FALSE"); /* Send the HCI command */ btm_cb.devcb.p_stored_link_key_cmpl_cb = p_cb; if (!btsnd_hcic_delete_stored_key (bd_addr, delete_all_flag)) { return (BTM_NO_RESOURCES); } else { return (BTM_SUCCESS); } } /******************************************************************************* ** ** Function btm_delete_stored_link_key_complete ** ** Description This function is called when the command complete message ** is received from the HCI for the delete stored link key command. ** ** Returns void ** *******************************************************************************/ void btm_delete_stored_link_key_complete (UINT8 *p) { tBTM_CMPL_CB *p_cb = btm_cb.devcb.p_stored_link_key_cmpl_cb; tBTM_DELETE_STORED_LINK_KEY_COMPLETE result; /* If there was a callback registered for read stored link key, call it */ btm_cb.devcb.p_stored_link_key_cmpl_cb = NULL; if (p_cb) { /* Set the call back event to indicate command complete */ result.event = BTM_CB_EVT_DELETE_STORED_LINK_KEYS; /* Extract the result fields from the HCI event */ STREAM_TO_UINT8 (result.status, p); STREAM_TO_UINT16 (result.num_keys, p); /* Call the call back and pass the result */ (*p_cb)(&result); } } /******************************************************************************* ** ** Function btm_report_device_status ** ** Description This function is called when there is a change in the device ** status. This function will report the new device status to ** the application ** ** Returns void ** *******************************************************************************/ void btm_report_device_status (tBTM_DEV_STATUS status) { tBTM_DEV_STATUS_CB *p_cb = btm_cb.devcb.p_dev_status_cb; /* Call the call back to pass the device status to application */ if (p_cb) { (*p_cb)(status); } }