/******************************************************************************* ** ** Function btm_ble_batchscan_filter_track_adv_vse_cback ** ** Description VSE callback for batch scan, filter, and tracking events. ** ** Returns None ** *******************************************************************************/ void btm_ble_batchscan_filter_track_adv_vse_cback(UINT8 len, UINT8 *p) { UINT8 sub_event = 0, filt_index = 0, addr_type = 0, adv_state = 0; BD_ADDR bd_addr; STREAM_TO_UINT8(sub_event, p); BTM_TRACE_EVENT("btm_ble_batchscan_filter_track_adv_vse_cback called with event:%x", sub_event); if (HCI_VSE_SUBCODE_BLE_THRESHOLD_SUB_EVT == sub_event && NULL != ble_batchscan_cb.p_thres_cback) { ble_batchscan_cb.p_thres_cback(ble_batchscan_cb.ref_value); return; } if (HCI_VSE_SUBCODE_BLE_TRACKING_SUB_EVT == sub_event && NULL != ble_advtrack_cb.p_track_cback) { if (len < 10) return; STREAM_TO_UINT8(filt_index, p); STREAM_TO_UINT8(addr_type, p); STREAM_TO_BDADDR(bd_addr, p); STREAM_TO_UINT8(adv_state, p); BTM_TRACE_EVENT("track_adv_vse_cback called: %d, %d, %d", filt_index, addr_type, adv_state); ble_advtrack_cb.p_track_cback(filt_index, addr_type, bd_addr, adv_state, ble_advtrack_cb.ref_value); return; } }
/******************************************************************************* ** ** 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 = GKI_getbuf((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_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_gen_resolvable_private_addr ** ** Description This function generate a resolvable private address. ** ** Returns void ** *******************************************************************************/ void btm_gen_resolvable_private_addr (void *p_cmd_cplt_cback) { BTM_TRACE_EVENT ("btm_gen_resolvable_private_addr"); /* generate 3B rand as BD LSB, SRK with it, get BD MSB */ if (!btsnd_hcic_ble_rand((void *)p_cmd_cplt_cback)) btm_gen_resolve_paddr_cmpl(NULL); }
/******************************************************************************* ** ** Function btm_ble_match_random_bda ** ** Description This function match the random address to the appointed device ** record, starting from calculating IRK. If record index exceed ** the maximum record number, matching failed and send callback. ** ** Returns None. ** *******************************************************************************/ static BOOLEAN btm_ble_match_random_bda(UINT16 rec_index) { /* use the 3 MSB of bd address as prand */ tBTM_LE_RANDOM_CB *p_mgnt_cb = &btm_cb.ble_ctr_cb.addr_mgnt_cb; UINT8 rand[3]; rand[0] = p_mgnt_cb->random_bda[2]; rand[1] = p_mgnt_cb->random_bda[1]; rand[2] = p_mgnt_cb->random_bda[0]; BTM_TRACE_EVENT("%s rec_index = %d", __func__, rec_index); if (rec_index < BTM_SEC_MAX_DEVICE_RECORDS) { tSMP_ENC output; tBTM_SEC_DEV_REC *p_dev_rec; p_dev_rec = &btm_cb.sec_dev_rec[rec_index]; BTM_TRACE_DEBUG("sec_flags = %02x device_type = %d", p_dev_rec->sec_flags, p_dev_rec->device_type); if ((p_dev_rec->device_type & BT_DEVICE_TYPE_BLE) && (p_dev_rec->ble.key_type & BTM_LE_KEY_PID)) { /* generate X = E irk(R0, R1, R2) and R is random address 3 LSO */ SMP_Encrypt(p_dev_rec->ble.keys.irk, BT_OCTET16_LEN, &rand[0], 3, &output); return btm_ble_proc_resolve_x(&output); } else { // not completed return FALSE; } } else { /* no match found */ btm_ble_resolve_address_cmpl(); return TRUE; } }
/******************************************************************************* ** ** Function btm_ble_remove_from_white_list_complete ** ** Description White list element removal complete ** *******************************************************************************/ void btm_ble_remove_from_white_list_complete(UINT8 *p, UINT16 evt_len) { UNUSED(evt_len); BTM_TRACE_EVENT ("%s status=%d", __func__, *p); if (*p == HCI_SUCCESS) ++btm_cb.ble_ctr_cb.white_list_avail_size; }
/******************************************************************************* ** ** Function btm_gen_non_resolve_paddr_cmpl ** ** Description This is the callback function when non-resolvable private ** function is generated and write to controller. ** ** Returns void ** *******************************************************************************/ static void btm_gen_non_resolve_paddr_cmpl(tBTM_RAND_ENC *p) { tBTM_LE_RANDOM_CB *p_cb = &btm_cb.ble_ctr_cb.addr_mgnt_cb; tBTM_BLE_ADDR_CBACK *p_cback = p_cb->p_generate_cback; void *p_data = p_cb->p; UINT8 *pp; BD_ADDR static_random; BTM_TRACE_EVENT ("btm_gen_non_resolve_paddr_cmpl"); p_cb->p_generate_cback = NULL; if (p) { pp = p->param_buf; STREAM_TO_BDADDR(static_random, pp); /* mask off the 2 MSB */ static_random[0] &= BLE_STATIC_PRIVATE_MSB_MASK; /* report complete */ if (p_cback) (* p_cback)(static_random, p_data); } else { BTM_TRACE_DEBUG("btm_gen_non_resolvable_private_addr failed"); if (p_cback) (* p_cback)(NULL, p_data); } }
/******************************************************************************* ** ** Function btm_update_scanner_filter_policy ** ** Description This function updates the filter policy of scanner *******************************************************************************/ void btm_update_scanner_filter_policy(tBTM_BLE_SFP scan_policy) { tBTM_BLE_INQ_CB *p_inq = &btm_cb.ble_ctr_cb.inq_var; UINT32 scan_interval = !p_inq->scan_interval ? BTM_BLE_GAP_DISC_SCAN_INT : p_inq->scan_interval; UINT32 scan_window = !p_inq->scan_window ? BTM_BLE_GAP_DISC_SCAN_WIN : p_inq->scan_window; BTM_TRACE_EVENT ("%s", __func__); p_inq->sfp = scan_policy; p_inq->scan_type = p_inq->scan_type == BTM_BLE_SCAN_MODE_NONE ? BTM_BLE_SCAN_MODE_ACTI : p_inq->scan_type; if (btm_cb.cmn_ble_vsc_cb.extended_scan_support == 0) { btsnd_hcic_ble_set_scan_params(p_inq->scan_type, (UINT16)scan_interval, (UINT16)scan_window, btm_cb.ble_ctr_cb.addr_mgnt_cb.own_addr_type, scan_policy); } else { btm_ble_send_extended_scan_params(p_inq->scan_type, scan_interval, scan_window, btm_cb.ble_ctr_cb.addr_mgnt_cb.own_addr_type, scan_policy); } }
/******************************************************************************* ** ** Function btm_ble_resolve_random_addr ** ** Description This function is called to resolve a random address. ** ** Returns pointer to the security record of the device whom a random ** address is matched to. ** *******************************************************************************/ void btm_ble_resolve_random_addr(BD_ADDR random_bda, tBTM_BLE_RESOLVE_CBACK * p_cback, void *p) { tBTM_LE_RANDOM_CB *p_mgnt_cb = &btm_cb.ble_ctr_cb.addr_mgnt_cb; BTM_TRACE_EVENT ("btm_ble_resolve_random_addr"); if ( !p_mgnt_cb->busy) { p_mgnt_cb->p = p; p_mgnt_cb->busy = TRUE; p_mgnt_cb->index = 0; p_mgnt_cb->p_resolve_cback = p_cback; memcpy(p_mgnt_cb->random_bda, random_bda, BD_ADDR_LEN); /* start to resolve random address */ /* check for next security record */ while (TRUE) { if (btm_ble_match_random_bda(p_mgnt_cb->index)) { /* atch found or went through the list */ break; } p_mgnt_cb->index ++; } } else (*p_cback)(NULL, p); }
/******************************************************************************* ** ** Function btm_public_addr_to_random_pseudo ** ** Description This function map a static BD address to a pseudo random address ** in security database. ** *******************************************************************************/ BOOLEAN btm_public_addr_to_random_pseudo(BD_ADDR bd_addr, UINT8 *p_addr_type, BOOLEAN read_irk) { #if BLE_PRIVACY_SPT == TRUE tBTM_SEC_DEV_REC *p_dev_rec = btm_find_dev_by_public_static_addr(bd_addr); BTM_TRACE_EVENT ("btm_public_addr_to_random_pseudo"); /* evt reported on static address, map static address to random pseudo */ if (p_dev_rec != NULL && read_irk && /* static address is not static address */ memcmp(p_dev_rec->bd_addr, bd_addr, BD_ADDR_LEN) != 0) /* update current random */ btm_ble_read_irk_entry(p_dev_rec->ble.static_addr); if (p_dev_rec != NULL) { /* assign the orginal random to be the current report address */ memcpy(bd_addr, p_dev_rec->bd_addr, BD_ADDR_LEN); /* always be a resolvable random if a match is found */ *p_addr_type = BLE_ADDR_RANDOM; BTM_TRACE_ERROR("matched a public/reconnect address and map to random pseudo"); return TRUE; } #endif return FALSE; }
/******************************************************************************* ** ** Function btm_gen_resolve_paddr_cmpl ** ** Description This is callback functioin when resolvable private address ** generation is complete. ** ** Returns void ** *******************************************************************************/ static void btm_gen_resolve_paddr_cmpl(tSMP_ENC *p) { tBTM_LE_RANDOM_CB *p_cb = &btm_cb.ble_ctr_cb.addr_mgnt_cb; BTM_TRACE_EVENT ("btm_gen_resolve_paddr_cmpl"); if (p) { /* set hash to be LSB of rpAddress */ p_cb->private_addr[5] = p->param_buf[0]; p_cb->private_addr[4] = p->param_buf[1]; p_cb->private_addr[3] = p->param_buf[2]; /* set it to controller */ btsnd_hcic_ble_set_random_addr(p_cb->private_addr); p_cb->own_addr_type = BLE_ADDR_RANDOM; /* start a periodical timer to refresh random addr */ btu_stop_timer_oneshot(&p_cb->raddr_timer_ent); #if (BTM_BLE_CONFORMANCE_TESTING == TRUE) btu_start_timer_oneshot(&p_cb->raddr_timer_ent, BTU_TTYPE_BLE_RANDOM_ADDR, btm_cb.ble_ctr_cb.rpa_tout); #else btu_start_timer_oneshot(&p_cb->raddr_timer_ent, BTU_TTYPE_BLE_RANDOM_ADDR, BTM_BLE_PRIVATE_ADDR_INT); #endif } else { /* random address set failure */ BTM_TRACE_DEBUG("set random address failed"); } }
/******************************************************************************* ** ** Function btm_gen_resolve_paddr_low ** ** Description This function is called when random address has generate the ** random number base for low 3 byte bd address. ** ** Returns void ** *******************************************************************************/ void btm_gen_resolve_paddr_low(tBTM_RAND_ENC *p) { #if (BLE_INCLUDED == TRUE && SMP_INCLUDED == TRUE) tBTM_LE_RANDOM_CB *p_cb = &btm_cb.ble_ctr_cb.addr_mgnt_cb; tSMP_ENC output; BTM_TRACE_EVENT ("btm_gen_resolve_paddr_low"); if (p) { p->param_buf[2] &= (~BLE_RESOLVE_ADDR_MASK); p->param_buf[2] |= BLE_RESOLVE_ADDR_MSB; p_cb->private_addr[2] = p->param_buf[0]; p_cb->private_addr[1] = p->param_buf[1]; p_cb->private_addr[0] = p->param_buf[2]; /* encrypt with ur IRK */ if (!SMP_Encrypt(btm_cb.devcb.id_keys.irk, BT_OCTET16_LEN, p->param_buf, 3, &output)) { btm_gen_resolve_paddr_cmpl(NULL); } else { btm_gen_resolve_paddr_cmpl(&output); } } #endif }
/******************************************************************************* ** ** 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_ble_add_2_white_list_complete ** ** Description This function read the current white list size. *******************************************************************************/ void btm_ble_add_2_white_list_complete(UINT8 status) { tBTM_BLE_CB *p_cb = &btm_cb.ble_ctr_cb; BTM_TRACE_EVENT ("btm_ble_add_2_white_list_complete"); if (status == HCI_SUCCESS) { p_cb->num_empty_filter --; } }
/******************************************************************************* ** ** Function btm_ble_initiate_select_conn ** ** Description This function is to start/stop selective connection procedure. ** ** Parameters start: TRUE to start; FALSE to stop. ** p_select_cback: callback function to return application ** selection. ** ** Returns BOOLEAN: selective connectino procedure is started. ** *******************************************************************************/ void btm_ble_initiate_select_conn(BD_ADDR bda) { BTM_TRACE_EVENT ("btm_ble_initiate_select_conn"); /* use direct connection procedure to initiate connection */ if (!L2CA_ConnectFixedChnl(L2CAP_ATT_CID, bda)) { BTM_TRACE_ERROR("btm_ble_initiate_select_conn failed"); } }
/******************************************************************************* ** ** Function BTM_WriteVoiceSettings ** ** Description Send HCI Write Voice Settings command. ** See 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_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_ble_remove_from_white_list_complete ** ** Description This function remove the white list element complete. *******************************************************************************/ void btm_ble_remove_from_white_list_complete(UINT8 *p, UINT16 evt_len) { tBTM_BLE_CB *p_cb = &btm_cb.ble_ctr_cb; UNUSED(evt_len); BTM_TRACE_EVENT ("btm_ble_remove_from_white_list_complete"); if (*p == HCI_SUCCESS) { p_cb->num_empty_filter ++; } }
/******************************************************************************* ** ** Function btm_ble_suspend_bg_conn ** ** Description This function is to suspend an active background connection ** procedure. ** ** Parameters none. ** ** Returns none. ** *******************************************************************************/ BOOLEAN btm_ble_suspend_bg_conn(void) { BTM_TRACE_EVENT ("%s", __func__); if (btm_cb.ble_ctr_cb.bg_conn_type == BTM_BLE_CONN_AUTO) return btm_ble_start_auto_conn(FALSE); else if (btm_cb.ble_ctr_cb.bg_conn_type == BTM_BLE_CONN_SELECTIVE) return btm_ble_start_select_conn(FALSE, NULL); return FALSE; }
/******************************************************************************* ** ** Function btm_ble_clear_white_list_complete ** ** Description Indicates white list cleared. ** *******************************************************************************/ void btm_ble_clear_white_list_complete(UINT8 *p_data, UINT16 evt_len) { tBTM_BLE_CB *p_cb = &btm_cb.ble_ctr_cb; UINT8 status; UNUSED(evt_len); BTM_TRACE_EVENT ("btm_ble_clear_white_list_complete"); STREAM_TO_UINT8 (status, p_data); if (status == HCI_SUCCESS) p_cb->white_list_avail_size = controller_get_interface()->get_ble_white_list_size(); }
/******************************************************************************* ** ** Function btm_ble_proc_resolve_x ** ** Description This function compares the X with random address 3 MSO bytes ** to find a match, if not match, continue for next record. ** ** Returns None. ** *******************************************************************************/ static BOOLEAN btm_ble_proc_resolve_x(tSMP_ENC *p) { tBTM_LE_RANDOM_CB *p_mgnt_cb = &btm_cb.ble_ctr_cb.addr_mgnt_cb; UINT8 comp[3]; BTM_TRACE_EVENT ("btm_ble_proc_resolve_x"); /* compare the hash with 3 LSB of bd address */ comp[0] = p_mgnt_cb->random_bda[5]; comp[1] = p_mgnt_cb->random_bda[4]; comp[2] = p_mgnt_cb->random_bda[3]; if (p) { if (!memcmp(p->param_buf, &comp[0], 3)) { /* match is found */ BTM_TRACE_EVENT ("match is found"); btm_ble_resolve_address_cmpl(); return TRUE; } } return FALSE; }
/******************************************************************************* ** ** Function btm_ble_clear_white_list_complete ** ** Description This function clears the white list complete. *******************************************************************************/ void btm_ble_clear_white_list_complete(UINT8 *p_data, UINT16 evt_len) { tBTM_BLE_CB *p_cb = &btm_cb.ble_ctr_cb; UINT8 status; UNUSED(evt_len); BTM_TRACE_EVENT ("btm_ble_clear_white_list_complete"); STREAM_TO_UINT8 (status, p_data); if (status == HCI_SUCCESS) p_cb->num_empty_filter = p_cb->max_filter_entries; }
/******************************************************************************* ** ** Function btm_update_bg_conn_list ** ** Description This function update the local background connection device list. *******************************************************************************/ BOOLEAN btm_update_bg_conn_list(BOOLEAN to_add, BD_ADDR bd_addr) { tBTM_BLE_CB *p_cb = &btm_cb.ble_ctr_cb; tBTM_LE_BG_CONN_DEV *p_bg_dev = &p_cb->bg_dev_list[0], *p_next, *p_cur; UINT8 i, j; BOOLEAN ret = FALSE; BTM_TRACE_EVENT ("btm_update_bg_conn_list"); if ((to_add && (p_cb->bg_dev_num == BTM_BLE_MAX_BG_CONN_DEV_NUM || p_cb->num_empty_filter == 0))) { BTM_TRACE_DEBUG("num_empty_filter = %d", p_cb->num_empty_filter); return ret; } for (i = 0; i < BTM_BLE_MAX_BG_CONN_DEV_NUM; i ++, p_bg_dev ++) { if (p_bg_dev->in_use && memcmp(p_bg_dev->bd_addr, bd_addr, BD_ADDR_LEN) == 0) { if (!to_add) { memset(p_bg_dev, 0, sizeof(tBTM_LE_BG_CONN_DEV)); p_cb->bg_dev_num --; p_cur = p_bg_dev; p_next = p_bg_dev + 1; for (j = i + 1; j < BTM_BLE_MAX_BG_CONN_DEV_NUM && p_next->in_use; j ++, p_cur ++, p_next ++) { memcpy(p_cur, p_next, sizeof(tBTM_LE_BG_CONN_DEV)); memset(p_next, 0, sizeof(tBTM_LE_BG_CONN_DEV)); } } ret = TRUE; break; } else if (!p_bg_dev->in_use && to_add) { BTM_TRACE_DEBUG("add new WL entry in bg_dev_list"); memcpy(p_bg_dev->bd_addr, bd_addr, BD_ADDR_LEN); p_bg_dev->in_use = TRUE; p_cb->bg_dev_num ++; ret = TRUE; break; } } return ret; }
/******************************************************************************* ** ** Function btm_update_scanner_filter_policy ** ** Description This function update the filter policy of scnner or advertiser. *******************************************************************************/ void btm_update_scanner_filter_policy(tBTM_BLE_SFP scan_policy) { tBTM_BLE_INQ_CB *p_inq = &btm_cb.ble_ctr_cb.inq_var; BTM_TRACE_EVENT ("btm_update_scanner_filter_policy"); p_inq->sfp = scan_policy; p_inq->scan_type = (p_inq->scan_type == BTM_BLE_SCAN_MODE_NONE) ? BTM_BLE_SCAN_MODE_ACTI: p_inq->scan_type; btsnd_hcic_ble_set_scan_params (p_inq->scan_type, (UINT16)(!p_inq->scan_interval ? BTM_BLE_GAP_DISC_SCAN_INT : p_inq->scan_interval), (UINT16)(!p_inq->scan_window ? BTM_BLE_GAP_DISC_SCAN_WIN : p_inq->scan_window), btm_cb.ble_ctr_cb.addr_mgnt_cb.own_addr_type, scan_policy); }
/******************************************************************************* ** ** Function btm_ble_suspend_bg_conn ** ** Description This function is to suspend an active background connection ** procedure. ** ** Parameters none. ** ** Returns none. ** *******************************************************************************/ void btm_ble_suspend_bg_conn(void) { tBTM_BLE_CB *p_cb = &btm_cb.ble_ctr_cb; BTM_TRACE_EVENT ("btm_ble_suspend_bg_conn"); if (p_cb->bg_conn_type == BTM_BLE_CONN_AUTO) { btm_ble_start_auto_conn(FALSE); } else if (p_cb->bg_conn_type == BTM_BLE_CONN_SELECTIVE) { btm_ble_start_select_conn(FALSE, NULL); } }
static void btm_ble_resolve_address_cmpl(void) { tBTM_LE_RANDOM_CB *p_mgnt_cb = &btm_cb.ble_ctr_cb.addr_mgnt_cb; tBTM_SEC_DEV_REC *p_dev_rec = NULL; BTM_TRACE_EVENT ("btm_ble_resolve_address_cmpl p_mgnt_cb->index = %d", p_mgnt_cb->index); if (p_mgnt_cb->index < BTM_SEC_MAX_DEVICE_RECORDS) { p_dev_rec = &btm_cb.sec_dev_rec[p_mgnt_cb->index]; } p_mgnt_cb->busy = FALSE; (* p_mgnt_cb->p_resolve_cback)(p_dev_rec, p_mgnt_cb->p); }
/******************************************************************************* ** ** Function btm_ble_map_bda_to_conn_bda ** ** Description This function map a BD address to the real connection address ** and return the connection address type. *******************************************************************************/ tBLE_ADDR_TYPE btm_ble_map_bda_to_conn_bda(BD_ADDR bd_addr) { tBTM_SEC_DEV_REC *p_dev_rec = NULL; BTM_TRACE_EVENT ("btm_ble_map_bda_to_conn_bda"); if ((p_dev_rec = btm_find_dev (bd_addr)) != NULL && p_dev_rec->device_type == BT_DEVICE_TYPE_BLE) { if (p_dev_rec->ble.ble_addr_type != BLE_ADDR_PUBLIC) { memcpy(bd_addr, p_dev_rec->ble.static_addr, BD_ADDR_LEN); } return p_dev_rec->ble.ble_addr_type; } else return BLE_ADDR_PUBLIC; }
/******************************************************************************* ** ** Function btm_gen_non_resolvable_private_addr ** ** Description This function generate a non-resolvable private address. ** ** ** Returns void ** *******************************************************************************/ void btm_gen_non_resolvable_private_addr (tBTM_BLE_ADDR_CBACK *p_cback, void *p) { tBTM_LE_RANDOM_CB *p_mgnt_cb = &btm_cb.ble_ctr_cb.addr_mgnt_cb; BTM_TRACE_EVENT ("btm_gen_non_resolvable_private_addr"); if (p_mgnt_cb->p_generate_cback != NULL) return; p_mgnt_cb->p_generate_cback = p_cback; p_mgnt_cb->p = p; if (!btsnd_hcic_ble_rand((void *)btm_gen_non_resolve_paddr_cmpl)) { btm_gen_non_resolve_paddr_cmpl(NULL); } }
/******************************************************************************* ** ** Function SMP_PairCancel ** ** Description This function call to cancel a SMP pairing with peer device. ** ** Parameters bd_addr - peer device bd address. ** ** Returns TRUE - Pairining is cancelled ** *******************************************************************************/ BOOLEAN SMP_PairCancel (BD_ADDR bd_addr) { tSMP_CB *p_cb = &smp_cb; UINT8 err_code = SMP_PAIR_FAIL_UNKNOWN; BOOLEAN status = FALSE; BTM_TRACE_EVENT ("SMP_CancelPair state=%d flag=0x%x ", p_cb->state, p_cb->flags); if ( (p_cb->state != SMP_STATE_IDLE) && (!memcmp (p_cb->pairing_bda, bd_addr, BD_ADDR_LEN)) ) { p_cb->is_pair_cancel = TRUE; SMP_TRACE_DEBUG("Cancel Pairing: set fail reason Unknown"); smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &err_code); status = TRUE; } return status; }
/******************************************************************************* ** ** 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); }