1 /******************************************************************************
2 *
3 * Copyright (C) 2003-2014 Broadcom Corporation
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at:
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 ******************************************************************************/
18
19 /******************************************************************************
20 *
21 * This file contains the action functions for device manager state
22 * machine.
23 *
24 ******************************************************************************/
25
26 #include "common/bt_target.h"
27 #include "stack/bt_types.h"
28 #include "bta/bta_sys.h"
29 #include "bta/bta_api.h"
30 #include "bta_dm_int.h"
31 #include "bta/bta_dm_co.h"
32 #include "bta/bta_gattc_co.h"
33 #include "stack/btm_api.h"
34 #include "btm_int.h"
35 #include "stack/btu.h"
36 #include "stack/sdp_api.h"
37 #include "stack/l2c_api.h"
38 #include "bta/utl.h"
39 #include "stack/gap_api.h" /* For GAP_BleReadPeerPrefConnParams */
40 #include <string.h>
41 #include "device/controller.h"
42
43 #define LOG_TAG "bt_bta_dm"
44 // #include "osi/include/log.h"
45
46 #if (GAP_INCLUDED == TRUE)
47 #include "stack/gap_api.h"
48 #endif
49
50 static void bta_dm_inq_results_cb (tBTM_INQ_RESULTS *p_inq, UINT8 *p_eir);
51 static void bta_dm_inq_cmpl_cb (void *p_result);
52 static void bta_dm_service_search_remname_cback (BD_ADDR bd_addr, DEV_CLASS dc, BD_NAME bd_name);
53 static void bta_dm_remname_cback (tBTM_REMOTE_DEV_NAME *p_remote_name);
54 #if (SDP_INCLUDED == TRUE)
55 static void bta_dm_find_services ( BD_ADDR bd_addr);
56 #endif ///SDP_INCLUDED == TRUE
57 static void bta_dm_discover_next_device(void);
58 #if (SDP_INCLUDED == TRUE)
59 static void bta_dm_sdp_callback (UINT16 sdp_status);
60 #endif ///SDP_INCLUDED == TRUE
61 #if (SMP_INCLUDED == TRUE)
62 static UINT8 bta_dm_authorize_cback (BD_ADDR bd_addr, DEV_CLASS dev_class, BD_NAME bd_name, UINT8 *service_name, UINT8 service_id, BOOLEAN is_originator);
63 #if (CLASSIC_BT_INCLUDED == TRUE)
64 static UINT8 bta_dm_pin_cback (BD_ADDR bd_addr, DEV_CLASS dev_class, BD_NAME bd_name, BOOLEAN min_16_digit);
65 #endif /// CLASSIC_BT_INCLUDED == TRUE
66 static UINT8 bta_dm_new_link_key_cback(BD_ADDR bd_addr, DEV_CLASS dev_class, BD_NAME bd_name, LINK_KEY key, UINT8 key_type, BOOLEAN sc_support);
67 static UINT8 bta_dm_authentication_complete_cback(BD_ADDR bd_addr, DEV_CLASS dev_class, BD_NAME bd_name, int result);
68 #endif ///SMP_INCLUDED == TRUE
69 static void bta_dm_local_name_cback(const BD_ADDR bd_addr);
70 static BOOLEAN bta_dm_check_av(UINT16 event);
71 static void bta_dm_bl_change_cback (tBTM_BL_EVENT_DATA *p_data);
72
73
74 static void bta_dm_acl_link_stat_cback(tBTM_ACL_LINK_STAT_EVENT_DATA *p_data);
75 static void bta_dm_policy_cback(tBTA_SYS_CONN_STATUS status, UINT8 id, UINT8 app_id, BD_ADDR peer_addr);
76
77 /* Extended Inquiry Response */
78 #if (BT_SSP_INCLUDED == TRUE && SMP_INCLUDED == TRUE)
79 static UINT8 bta_dm_sp_cback (tBTM_SP_EVT event, tBTM_SP_EVT_DATA *p_data);
80 #endif /* (BT_SSP_INCLUDED == TRUE) */
81 #if (CLASSIC_BT_INCLUDED == TRUE)
82 static void bta_dm_set_eir (char *local_name);
83 #endif
84 #if (SDP_INCLUDED == TRUE)
85 static void bta_dm_eir_search_services( tBTM_INQ_RESULTS *p_result,
86 tBTA_SERVICE_MASK *p_services_to_search,
87 tBTA_SERVICE_MASK *p_services_found);
88 #endif ///SDP_INCLUDED == TRUE
89 static void bta_dm_search_timer_cback (TIMER_LIST_ENT *p_tle);
90 static void bta_dm_disable_conn_down_timer_cback (TIMER_LIST_ENT *p_tle);
91 static void bta_dm_rm_cback(tBTA_SYS_CONN_STATUS status, UINT8 id, UINT8 app_id, BD_ADDR peer_addr);
92 static void bta_dm_adjust_roles(BOOLEAN delay_role_switch);
93 #if (SDP_INCLUDED == TRUE || SMP_INCLUDED == TRUE)
94 static char *bta_dm_get_remname(void);
95 #endif ///SDP_INCLUDED == TRUE || SMP_INCLUDED == TRUE
96 #if (SMP_INCLUDED == TRUE)
97 static void bta_dm_bond_cancel_complete_cback(tBTM_STATUS result);
98 #endif ///SMP_INCLUDED == TRUE
99 #if (SDP_INCLUDED == TRUE)
100 static BOOLEAN bta_dm_read_remote_device_name (BD_ADDR bd_addr, tBT_TRANSPORT transport);
101 static void bta_dm_discover_device(BD_ADDR remote_bd_addr);
102 #endif ///SDP_INCLUDED == TRUE
103 static void bta_dm_sys_hw_cback( tBTA_SYS_HW_EVT status );
104 static void bta_dm_disable_search_and_disc(void);
105
106 #if ((defined BLE_INCLUDED) && (BLE_INCLUDED == TRUE))
107 #if ((defined SMP_INCLUDED) && (SMP_INCLUDED == TRUE))
108 static UINT8 bta_dm_ble_smp_cback (tBTM_LE_EVT event, BD_ADDR bda, tBTM_LE_EVT_DATA *p_data);
109 static void bta_dm_ble_id_key_cback (UINT8 key_type, tBTM_BLE_LOCAL_KEYS *p_key);
110 #endif ///SMP_INCLUDED == TRUE
111 #if ((defined BTA_GATT_INCLUDED) && (BTA_GATT_INCLUDED == TRUE) && SDP_INCLUDED == TRUE)
112 #if (GATTC_INCLUDED == TRUE)
113 static void bta_dm_gattc_register(void);
114 static void btm_dm_start_gatt_discovery(BD_ADDR bd_addr);
115 static void bta_dm_cancel_gatt_discovery(BD_ADDR bd_addr);
116 static void bta_dm_gattc_callback(tBTA_GATTC_EVT event, tBTA_GATTC *p_data);
117 #endif // (GATTC_INCLUDED == TRUE)
118 extern tBTA_DM_CONTRL_STATE bta_dm_pm_obtain_controller_state(void);
119 #endif
120
121 #if BLE_VND_INCLUDED == TRUE
122 static void bta_dm_ctrl_features_rd_cmpl_cback(tBTM_STATUS result);
123 #endif
124
125 #ifndef BTA_DM_BLE_ADV_CHNL_MAP
126 #define BTA_DM_BLE_ADV_CHNL_MAP (BTM_BLE_ADV_CHNL_37|BTM_BLE_ADV_CHNL_38|BTM_BLE_ADV_CHNL_39)
127 #endif
128 #endif
129 #if (SMP_INCLUDED == TRUE)
130 static BOOLEAN bta_dm_remove_sec_dev_entry(BD_ADDR remote_bd_addr);
131 #endif ///SMP_INCLUDED == TRUE
132 #if (BLE_INCLUDED == TRUE)
133 static void bta_dm_observe_results_cb(tBTM_INQ_RESULTS *p_inq, UINT8 *p_eir);
134 static void bta_dm_observe_cmpl_cb(void *p_result);
135 static void bta_dm_observe_discard_cb (uint32_t num_dis);
136 #endif ///BLE_INCLUDED == TRUE
137
138 static void bta_dm_delay_role_switch_cback(TIMER_LIST_ENT *p_tle);
139 extern void sdpu_uuid16_to_uuid128(UINT16 uuid16, UINT8 *p_uuid128);
140 static void bta_dm_disable_timer_cback(TIMER_LIST_ENT *p_tle);
141 extern int bredr_txpwr_get(int *min_power_level, int *max_power_level);
142
143 const UINT16 bta_service_id_to_uuid_lkup_tbl [BTA_MAX_SERVICE_ID] = {
144 UUID_SERVCLASS_PNP_INFORMATION, /* Reserved */
145 UUID_SERVCLASS_SERIAL_PORT, /* BTA_SPP_SERVICE_ID */
146 UUID_SERVCLASS_DIALUP_NETWORKING, /* BTA_DUN_SERVICE_ID */
147 UUID_SERVCLASS_AUDIO_SOURCE, /* BTA_A2DP_SOURCE_SERVICE_ID */
148 UUID_SERVCLASS_LAN_ACCESS_USING_PPP, /* BTA_LAP_SERVICE_ID */
149 UUID_SERVCLASS_HEADSET, /* BTA_HSP_HS_SERVICE_ID */
150 UUID_SERVCLASS_HF_HANDSFREE, /* BTA_HFP_HS_SERVICE_ID */
151 UUID_SERVCLASS_OBEX_OBJECT_PUSH, /* BTA_OPP_SERVICE_ID */
152 UUID_SERVCLASS_OBEX_FILE_TRANSFER, /* BTA_FTP_SERVICE_ID */
153 UUID_SERVCLASS_CORDLESS_TELEPHONY, /* BTA_CTP_SERVICE_ID */
154 UUID_SERVCLASS_INTERCOM, /* BTA_ICP_SERVICE_ID */
155 UUID_SERVCLASS_IRMC_SYNC, /* BTA_SYNC_SERVICE_ID */
156 UUID_SERVCLASS_DIRECT_PRINTING, /* BTA_BPP_SERVICE_ID */
157 UUID_SERVCLASS_IMAGING_RESPONDER, /* BTA_BIP_SERVICE_ID */
158 UUID_SERVCLASS_PANU, /* BTA_PANU_SERVICE_ID */
159 UUID_SERVCLASS_NAP, /* BTA_NAP_SERVICE_ID */
160 UUID_SERVCLASS_GN, /* BTA_GN_SERVICE_ID */
161 UUID_SERVCLASS_SAP, /* BTA_SAP_SERVICE_ID */
162 UUID_SERVCLASS_AUDIO_SINK, /* BTA_A2DP_SERVICE_ID */
163 UUID_SERVCLASS_AV_REMOTE_CONTROL, /* BTA_AVRCP_SERVICE_ID */
164 UUID_SERVCLASS_HUMAN_INTERFACE, /* BTA_HID_SERVICE_ID */
165 UUID_SERVCLASS_VIDEO_SINK, /* BTA_VDP_SERVICE_ID */
166 UUID_SERVCLASS_PBAP_PSE, /* BTA_PBAP_SERVICE_ID */
167 UUID_SERVCLASS_HEADSET_AUDIO_GATEWAY, /* BTA_HSP_SERVICE_ID */
168 UUID_SERVCLASS_AG_HANDSFREE, /* BTA_HFP_SERVICE_ID */
169 UUID_SERVCLASS_MESSAGE_ACCESS, /* BTA_MAP_SERVICE_ID */
170 UUID_SERVCLASS_MESSAGE_NOTIFICATION, /* BTA_MN_SERVICE_ID */
171 UUID_SERVCLASS_HDP_PROFILE, /* BTA_HDP_SERVICE_ID */
172 UUID_SERVCLASS_PBAP_PCE /* BTA_PCE_SERVICE_ID */
173 #if BLE_INCLUDED && BTA_GATT_INCLUDED
174 , UUID_PROTOCOL_ATT /* BTA_GATT_SERVICE_ID */
175 #endif
176 };
177
178 /*
179 * NOTE : The number of element in bta_service_id_to_btm_srv_id_lkup_tbl should be matching with
180 * the value BTA_MAX_SERVICE_ID in bta/bta_api.h
181 *
182 * i.e., If you add new Service ID for BTA, the correct security ID of the new service
183 * from Security service definitions (stack/btm_api.h) should be added to this lookup table.
184 */
185 const UINT32 bta_service_id_to_btm_srv_id_lkup_tbl [BTA_MAX_SERVICE_ID] = {
186 0, /* Reserved */
187 BTM_SEC_SERVICE_SERIAL_PORT, /* BTA_SPP_SERVICE_ID */
188 BTM_SEC_SERVICE_DUN, /* BTA_DUN_SERVICE_ID */
189 BTM_SEC_SERVICE_AVDTP, /* BTA_AUDIO_SOURCE_SERVICE_ID */
190 BTM_SEC_SERVICE_LAN_ACCESS, /* BTA_LAP_SERVICE_ID */
191 BTM_SEC_SERVICE_HEADSET_AG, /* BTA_HSP_SERVICE_ID */
192 BTM_SEC_SERVICE_AG_HANDSFREE, /* BTA_HFP_SERVICE_ID */
193 BTM_SEC_SERVICE_OBEX, /* BTA_OPP_SERVICE_ID */
194 BTM_SEC_SERVICE_OBEX_FTP, /* BTA_FTP_SERVICE_ID */
195 BTM_SEC_SERVICE_CORDLESS, /* BTA_CTP_SERVICE_ID */
196 BTM_SEC_SERVICE_INTERCOM, /* BTA_ICP_SERVICE_ID */
197 BTM_SEC_SERVICE_IRMC_SYNC, /* BTA_SYNC_SERVICE_ID */
198 BTM_SEC_SERVICE_BPP_JOB, /* BTA_BPP_SERVICE_ID */
199 BTM_SEC_SERVICE_BIP, /* BTA_BIP_SERVICE_ID */
200 BTM_SEC_SERVICE_BNEP_PANU, /* BTA_PANU_SERVICE_ID */
201 BTM_SEC_SERVICE_BNEP_NAP, /* BTA_NAP_SERVICE_ID */
202 BTM_SEC_SERVICE_BNEP_GN, /* BTA_GN_SERVICE_ID */
203 BTM_SEC_SERVICE_SAP, /* BTA_SAP_SERVICE_ID */
204 BTM_SEC_SERVICE_AVDTP, /* BTA_A2DP_SERVICE_ID */
205 BTM_SEC_SERVICE_AVCTP, /* BTA_AVRCP_SERVICE_ID */
206 BTM_SEC_SERVICE_HIDH_SEC_CTRL, /* BTA_HID_SERVICE_ID */
207 BTM_SEC_SERVICE_AVDTP, /* BTA_VDP_SERVICE_ID */
208 BTM_SEC_SERVICE_PBAP, /* BTA_PBAP_SERVICE_ID */
209 BTM_SEC_SERVICE_HEADSET, /* BTA_HSP_HS_SERVICE_ID */
210 BTM_SEC_SERVICE_HF_HANDSFREE, /* BTA_HFP_HS_SERVICE_ID */
211 BTM_SEC_SERVICE_MAP, /* BTA_MAP_SERVICE_ID */
212 BTM_SEC_SERVICE_MAP, /* BTA_MN_SERVICE_ID */
213 BTM_SEC_SERVICE_HDP_SNK, /* BTA_HDP_SERVICE_ID */
214 BTM_SEC_SERVICE_PBAP /* BTA_PCE_SERVICE_ID */
215 #if BLE_INCLUDED && BTA_GATT_INCLUDED
216 , BTM_SEC_SERVICE_ATT /* BTA_GATT_SERVICE_ID */
217 #endif
218
219 };
220
221 /* bta security callback */
222 #if (SMP_INCLUDED == TRUE)
223 const tBTM_APPL_INFO bta_security = {
224 &bta_dm_authorize_cback,
225 #if (CLASSIC_BT_INCLUDED == TRUE)
226 &bta_dm_pin_cback,
227 #else
228 NULL,
229 #endif
230 &bta_dm_new_link_key_cback,
231 &bta_dm_authentication_complete_cback,
232 &bta_dm_bond_cancel_complete_cback,
233 #if (BT_SSP_INCLUDED == TRUE)
234 &bta_dm_sp_cback,
235 #else
236 NULL,
237 #endif
238 #if BLE_INCLUDED == TRUE
239 &bta_dm_ble_smp_cback,
240 &bta_dm_ble_id_key_cback,
241 #endif ///BLE_INCLUDED == TRUE
242
243 };
244 #endif ///SMP_INCLUDED == TRUE
245
246 #if (SDP_INCLUDED == TRUE)
247 #if BTA_DYNAMIC_MEMORY == FALSE
248 UINT8 g_disc_raw_data_buf[MAX_DISC_RAW_DATA_BUF];
249 #else
250 UINT8 *g_disc_raw_data_buf;
251 #endif
252 #endif ///SDP_INCLUDED == TRUE
253
254 /*******************************************************************************
255 **
256 ** Function bta_dm_enable
257 **
258 ** Description Initialises the BT device manager
259 **
260 **
261 ** Returns void
262 **
263 *******************************************************************************/
bta_dm_enable(tBTA_DM_MSG * p_data)264 void bta_dm_enable(tBTA_DM_MSG *p_data)
265 {
266 tBTA_SYS_HW_MSG *sys_enable_event;
267 tBTA_DM_ENABLE enable_event;
268
269 /* if already in use, return an error */
270 if ( bta_dm_cb.is_bta_dm_active == TRUE ) {
271 APPL_TRACE_WARNING("%s Device already started by another application", __func__);
272 memset(&enable_event, 0, sizeof(tBTA_DM_ENABLE));
273 enable_event.status = BTA_FAILURE;
274 if (p_data->enable.p_sec_cback != NULL) {
275 p_data->enable.p_sec_cback(BTA_DM_ENABLE_EVT, (tBTA_DM_SEC *)&enable_event);
276 }
277 return;
278 }
279
280 /* first, register our callback to SYS HW manager */
281 bta_sys_hw_register( BTA_SYS_HW_BLUETOOTH, bta_dm_sys_hw_cback );
282
283 /* make sure security callback is saved - if no callback, do not erase the previous one,
284 it could be an error recovery mechanism */
285 if ( p_data->enable.p_sec_cback != NULL ) {
286 bta_dm_cb.p_sec_cback = p_data->enable.p_sec_cback;
287 }
288 /* notify BTA DM is now active */
289 bta_dm_cb.is_bta_dm_active = TRUE;
290
291 /* send a message to BTA SYS */
292 if ((sys_enable_event = (tBTA_SYS_HW_MSG *) osi_malloc(sizeof(tBTA_SYS_HW_MSG))) != NULL) {
293 sys_enable_event->hdr.event = BTA_SYS_API_ENABLE_EVT;
294 sys_enable_event->hw_module = BTA_SYS_HW_BLUETOOTH;
295
296 bta_sys_sendmsg(sys_enable_event);
297 }
298 }
299
300 /*******************************************************************************
301 *
302 * Function bta_dm_init_cb
303 *
304 * Description Initializes the bta_dm_cb control block
305 *
306 *
307 * Returns void
308 *
309 ******************************************************************************/
bta_dm_init_cb(void)310 void bta_dm_init_cb(void)
311 {
312 memset(&bta_dm_cb, 0, sizeof(bta_dm_cb));
313 }
314
315 /*******************************************************************************
316 *
317 * Function bta_dm_deinit_cb
318 *
319 * Description De-initializes the bta_dm_cb control block
320 *
321 *
322 * Returns void
323 *
324 ******************************************************************************/
bta_dm_deinit_cb(void)325 void bta_dm_deinit_cb(void)
326 {
327 bta_sys_free_timer(&bta_dm_cb.disable_timer);
328 #if ( BTA_EIR_CANNED_UUID_LIST != TRUE )
329 bta_sys_free_timer(&bta_dm_cb.app_ready_timer);
330 #endif
331 #if BTM_SSR_INCLUDED == TRUE
332 for (size_t i = 0; i < BTA_DM_NUM_PM_TIMER; i++) {
333 for (size_t j = 0; j < BTA_DM_PM_MODE_TIMER_MAX; j++) {
334 bta_sys_free_timer(&bta_dm_cb.pm_timer[i].timer[j]);
335 }
336 }
337 #endif
338 memset(&bta_dm_cb, 0, sizeof(bta_dm_cb));
339 #if BTA_DYNAMIC_MEMORY
340 xSemaphoreGive(deinit_semaphore);
341 #endif /* #if BTA_DYNAMIC_MEMORY */
342 }
343
344 /*******************************************************************************
345 *
346 * Function bta_dm_eir_cfg_init
347 *
348 * Description Initializes the p_bta_dm_eir_cfg
349 *
350 *
351 * Returns void
352 *
353 ******************************************************************************/
bta_dm_eir_cfg_init(void)354 static void bta_dm_eir_cfg_init(void)
355 {
356 p_bta_dm_eir_cfg->bta_dm_eir_fec_required = BTM_EIR_DEFAULT_FEC_REQUIRED;
357 p_bta_dm_eir_cfg->bta_dm_eir_min_name_len = 50;
358
359 p_bta_dm_eir_cfg->bta_dm_eir_included_uuid = TRUE;
360 p_bta_dm_eir_cfg->bta_dm_eir_included_tx_power = FALSE;
361 p_bta_dm_eir_cfg->bta_dm_eir_inq_tx_power = 3;
362 p_bta_dm_eir_cfg->bta_dm_eir_flags = 0;
363
364 p_bta_dm_eir_cfg->bta_dm_eir_manufac_spec_len = 0;
365 p_bta_dm_eir_cfg->bta_dm_eir_manufac_spec = NULL;
366
367 p_bta_dm_eir_cfg->bta_dm_eir_url_len = 0;
368 p_bta_dm_eir_cfg->bta_dm_eir_url = NULL;
369 }
370
371 /*******************************************************************************
372 *
373 * Function bta_dm_eir_cfg_deinit
374 *
375 * Description De-initializes the p_bta_dm_eir_cfg
376 *
377 *
378 * Returns void
379 *
380 ******************************************************************************/
bta_dm_eir_cfg_deinit(void)381 static void bta_dm_eir_cfg_deinit(void)
382 {
383 p_bta_dm_eir_cfg->bta_dm_eir_manufac_spec_len = 0;
384 if (p_bta_dm_eir_cfg->bta_dm_eir_manufac_spec) {
385 osi_free(p_bta_dm_eir_cfg->bta_dm_eir_manufac_spec);
386 p_bta_dm_eir_cfg->bta_dm_eir_manufac_spec = NULL;
387 }
388
389 p_bta_dm_eir_cfg->bta_dm_eir_url_len = 0;
390 if (p_bta_dm_eir_cfg->bta_dm_eir_url) {
391 osi_free(p_bta_dm_eir_cfg->bta_dm_eir_url);
392 p_bta_dm_eir_cfg->bta_dm_eir_url = NULL;
393 }
394 }
395
396 /*******************************************************************************
397 **
398 ** Function bta_dm_sys_hw_cback
399 **
400 ** Description callback register to SYS to get HW status updates
401 **
402 **
403 ** Returns void
404 **
405 *******************************************************************************/
bta_dm_sys_hw_cback(tBTA_SYS_HW_EVT status)406 static void bta_dm_sys_hw_cback( tBTA_SYS_HW_EVT status )
407 {
408 DEV_CLASS dev_class;
409 tBTA_DM_SEC_CBACK *temp_cback;
410 #if BLE_INCLUDED == TRUE
411 UINT8 key_mask = 0;
412 BT_OCTET16 er;
413 tBTA_BLE_LOCAL_ID_KEYS id_key;
414 #endif
415
416 APPL_TRACE_DEBUG("%s with event: %i", __func__, status);
417
418 /* On H/W error evt, report to the registered DM application callback */
419 if (status == BTA_SYS_HW_ERROR_EVT) {
420 if ( bta_dm_cb.p_sec_cback != NULL ) {
421 bta_dm_cb.p_sec_cback(BTA_DM_HW_ERROR_EVT, NULL);
422 }
423 return;
424 }
425
426 if ( status == BTA_SYS_HW_OFF_EVT ) {
427 if ( bta_dm_cb.p_sec_cback != NULL ) {
428 bta_dm_cb.p_sec_cback(BTA_DM_DISABLE_EVT, NULL);
429 }
430
431 /* reinitialize the control block */
432 bta_dm_deinit_cb();
433
434 /* reinitialize the Extended Inquiry Response */
435 bta_dm_eir_cfg_deinit();
436
437 bta_sys_free_timer(&bta_dm_search_cb.search_timer);
438 #if ((defined BLE_INCLUDED) && (BLE_INCLUDED == TRUE))
439 #if ((defined BTA_GATT_INCLUDED) && (BTA_GATT_INCLUDED == TRUE) && SDP_INCLUDED == TRUE)
440 bta_sys_free_timer(&bta_dm_search_cb.gatt_close_timer);
441 #endif
442 #endif
443 memset(&bta_dm_search_cb, 0x00, sizeof(bta_dm_search_cb));
444
445 /* unregister from SYS */
446 bta_sys_hw_unregister( BTA_SYS_HW_BLUETOOTH );
447 /* notify BTA DM is now unactive */
448 bta_dm_cb.is_bta_dm_active = FALSE;
449 #if (defined BLE_INCLUDED && BLE_INCLUDED == TRUE)
450 #if (GATTC_INCLUDED == TRUE && GATTC_CACHE_NVS == TRUE)
451 /* clear the gattc cache address list */
452 bta_gattc_co_cache_addr_deinit();
453 #endif
454 #endif
455 } else if ( status == BTA_SYS_HW_ON_EVT ) {
456 /* FIXME: We should not unregister as the SYS shall invoke this callback on a H/W error.
457 * We need to revisit when this platform has more than one BLuetooth H/W chip */
458 //bta_sys_hw_unregister( BTA_SYS_HW_BLUETOOTH);
459
460 /* save security callback */
461 temp_cback = bta_dm_cb.p_sec_cback;
462 /* make sure the control block is properly initialized */
463 bta_dm_init_cb();
464
465 /* make sure the Extended Inquiry Response is properly initialized */
466 bta_dm_eir_cfg_init();
467
468 /* and retrieve the callback */
469 bta_dm_cb.p_sec_cback = temp_cback;
470 bta_dm_cb.is_bta_dm_active = TRUE;
471
472 bta_sys_free_timer(&bta_dm_search_cb.search_timer);
473 #if ((defined BLE_INCLUDED) && (BLE_INCLUDED == TRUE))
474 #if ((defined BTA_GATT_INCLUDED) && (BTA_GATT_INCLUDED == TRUE) && SDP_INCLUDED == TRUE)
475 bta_sys_free_timer(&bta_dm_search_cb.gatt_close_timer);
476 #endif
477 #endif
478 /* hw is ready, go on with BTA DM initialization */
479 memset(&bta_dm_search_cb, 0x00, sizeof(bta_dm_search_cb));
480 memset(&bta_dm_conn_srvcs, 0x00, sizeof(bta_dm_conn_srvcs));
481 memset(&bta_dm_di_cb, 0, sizeof(tBTA_DM_DI_CB));
482 memcpy(dev_class, p_bta_dm_cfg->dev_class, sizeof(dev_class));
483 #if CLASSIC_BT_INCLUDED
484 BTM_SetDeviceClass (dev_class);
485 #endif
486
487 #if (defined BLE_INCLUDED && BLE_INCLUDED == TRUE)
488 #if (GATTC_INCLUDED == TRUE && GATTC_CACHE_NVS == TRUE)
489 // load the gattc cache address list
490 bta_gattc_co_cache_addr_init();
491 #endif /* #if (GATTC_INCLUDED = TRUE) */
492 /* load BLE local information: ID keys, ER if available */
493 bta_dm_co_ble_load_local_keys(&key_mask, er, &id_key);
494
495 if (key_mask & BTA_BLE_LOCAL_KEY_TYPE_ER) {
496 BTM_BleLoadLocalKeys(BTA_BLE_LOCAL_KEY_TYPE_ER, (tBTM_BLE_LOCAL_KEYS *)&er);
497 }
498 if (key_mask & BTA_BLE_LOCAL_KEY_TYPE_ID) {
499 BTM_BleLoadLocalKeys(BTA_BLE_LOCAL_KEY_TYPE_ID, (tBTM_BLE_LOCAL_KEYS *)&id_key);
500 }
501 #if ((defined BTA_GATT_INCLUDED) && (BTA_GATT_INCLUDED == TRUE) && SDP_INCLUDED == TRUE)
502 bta_dm_search_cb.conn_id = BTA_GATT_INVALID_CONN_ID;
503 #endif
504 #endif
505 #if (SMP_INCLUDED == TRUE)
506 BTM_SecRegister((tBTM_APPL_INFO *)&bta_security);
507 #endif ///SMP_INCLUDED == TRUE
508 BTM_SetDefaultLinkSuperTout(p_bta_dm_cfg->link_timeout);
509 #if CLASSIC_BT_INCLUDED
510 BTM_WritePageTimeout(p_bta_dm_cfg->page_timeout);
511 bta_dm_cb.cur_policy = p_bta_dm_cfg->policy_settings;
512 BTM_SetDefaultLinkPolicy(bta_dm_cb.cur_policy);
513 #endif
514 BTM_RegBusyLevelNotif (bta_dm_bl_change_cback, NULL, BTM_BL_UPDATE_MASK | BTM_BL_ROLE_CHG_MASK);
515 BTM_RegAclLinkStatNotif (bta_dm_acl_link_stat_cback);
516
517 #if BLE_VND_INCLUDED == TRUE
518 BTM_BleReadControllerFeatures (bta_dm_ctrl_features_rd_cmpl_cback);
519 #endif
520
521 /* Earlier, we used to invoke BTM_ReadLocalAddr which was just copying the bd_addr
522 from the control block and invoking the callback which was sending the DM_ENABLE_EVT.
523 But then we have a few HCI commands being invoked above which were still in progress
524 when the ENABLE_EVT was sent. So modified this to fetch the local name which forces
525 the DM_ENABLE_EVT to be sent only after all the init steps are complete */
526 BTM_ReadLocalDeviceNameFromController((tBTM_CMPL_CB *)bta_dm_local_name_cback);
527
528 bta_sys_rm_register((tBTA_SYS_CONN_CBACK *)bta_dm_rm_cback);
529
530 #if (BTA_DM_PM_INCLUDED == TRUE)
531 /* initialize bluetooth low power manager */
532 bta_dm_init_pm();
533 #endif /* #if (BTA_DM_PM_INCLUDED == TRUE) */
534
535 bta_sys_policy_register((tBTA_SYS_CONN_CBACK *)bta_dm_policy_cback);
536
537 #if (BLE_INCLUDED == TRUE && BTA_GATT_INCLUDED == TRUE && SDP_INCLUDED == TRUE) && (GATTC_INCLUDED == TRUE)
538 bta_dm_gattc_register();
539 #endif
540
541 } else {
542 APPL_TRACE_DEBUG(" --- ignored event");
543 }
544
545 }
546
547
548 /*******************************************************************************
549 **
550 ** Function bta_dm_disable
551 **
552 ** Description Disables the BT device manager
553 **
554 **
555 ** Returns void
556 **
557 *******************************************************************************/
bta_dm_disable(tBTA_DM_MSG * p_data)558 void bta_dm_disable (tBTA_DM_MSG *p_data)
559 {
560 UNUSED(p_data);
561
562 /* Set l2cap idle timeout to 0 (so BTE immediately disconnects ACL link after last channel is closed) */
563 L2CA_SetIdleTimeoutByBdAddr((UINT8 *)BT_BD_ANY, 0, BT_TRANSPORT_BR_EDR);
564 L2CA_SetIdleTimeoutByBdAddr((UINT8 *)BT_BD_ANY, 0, BT_TRANSPORT_LE);
565
566 /* disable all active subsystems */
567 bta_sys_disable(BTA_SYS_HW_BLUETOOTH);
568 #if CLASSIC_BT_INCLUDED
569 BTM_SetDiscoverability(BTM_NON_DISCOVERABLE, 0, 0);
570 BTM_SetConnectability(BTM_NON_CONNECTABLE, 0, 0);
571 #endif // #if CLASSIC_BT_INCLUDED
572
573 #if (BTA_DM_PM_INCLUDED == TRUE)
574 bta_dm_disable_pm();
575 #endif /* #if (BTA_DM_PM_INCLUDED == TRUE) */
576
577 bta_dm_disable_search_and_disc();
578 bta_dm_cb.disabling = TRUE;
579
580 #if BLE_INCLUDED == TRUE
581 /* reset scan activity status*/
582 btm_cb.ble_ctr_cb.scan_activity = 0;
583
584 /* reset advertising activity status*/
585 btm_cb.ble_ctr_cb.inq_var.state = 0;
586 #endif
587
588 #if BLE_INCLUDED == TRUE && BTA_GATT_INCLUDED == TRUE
589 BTM_BleClearBgConnDev();
590 #endif
591
592 if (BTM_GetNumAclLinks() == 0) {
593 #if (defined(BTA_DISABLE_DELAY) && BTA_DISABLE_DELAY > 0)
594 /* If BTA_DISABLE_DELAY is defined and greater than zero, then delay the shutdown by
595 * BTA_DISABLE_DELAY milliseconds
596 */
597 APPL_TRACE_WARNING("%s BTA_DISABLE_DELAY set to %d ms",
598 __FUNCTION__, BTA_DISABLE_DELAY);
599 bta_sys_stop_timer(&bta_dm_cb.disable_timer);
600 bta_dm_cb.disable_timer.p_cback = (TIMER_CBACK *)&bta_dm_disable_conn_down_timer_cback;
601 bta_sys_start_timer(&bta_dm_cb.disable_timer, 0, BTA_DISABLE_DELAY);
602 #else
603 bta_dm_disable_conn_down_timer_cback(NULL);
604 #endif
605 } else {
606 bta_dm_cb.disable_timer.p_cback = (TIMER_CBACK *)&bta_dm_disable_timer_cback;
607 bta_dm_cb.disable_timer.param = 0;
608 bta_sys_start_timer(&bta_dm_cb.disable_timer, 0, 5000);
609 }
610
611 #if BLE_INCLUDED == TRUE && BLE_PRIVACY_SPT == TRUE
612 btm_ble_resolving_list_cleanup (); //by TH, because cmn_ble_vsc_cb.max_filter has something mistake as btm_ble_adv_filter_cleanup
613 #endif
614
615 #if BLE_INCLUDED == TRUE
616 // btm_ble_multi_adv_init is called when the host is enabled, so btm_ble_multi_adv_cleanup is called when the host is disabled.
617 btm_ble_multi_adv_cleanup();
618 #endif
619
620 }
621
622 /*******************************************************************************
623 **
624 ** Function bta_dm_disable_timer_cback
625 **
626 ** Description Called if the disable timer expires
627 ** Used to close ACL connections which are still active
628 **
629 **
630 **
631 ** Returns void
632 **
633 *******************************************************************************/
bta_dm_disable_timer_cback(TIMER_LIST_ENT * p_tle)634 static void bta_dm_disable_timer_cback (TIMER_LIST_ENT *p_tle)
635 {
636 UNUSED(p_tle);
637 UINT8 i;
638 tBT_TRANSPORT transport = BT_TRANSPORT_BR_EDR;
639 BOOLEAN trigger_disc = FALSE;
640
641
642 APPL_TRACE_EVENT(" bta_dm_disable_timer_cback trial %d ", p_tle->param);
643
644 if (BTM_GetNumAclLinks() && p_tle->param == 0) {
645 for (i = 0; i < bta_dm_cb.device_list.count; i++) {
646 #if (BLE_INCLUDED == TRUE)
647 transport = bta_dm_cb.device_list.peer_device[i].transport;
648 #endif
649 btm_remove_acl(bta_dm_cb.device_list.peer_device[i].peer_bdaddr, transport);
650 trigger_disc = TRUE;
651 }
652
653 /* Retrigger disable timer in case ACL disconnect failed, DISABLE_EVT still need
654 to be sent out to avoid the layer disable timeout */
655 if (trigger_disc) {
656 bta_dm_cb.disable_timer.p_cback = (TIMER_CBACK *)&bta_dm_disable_timer_cback;
657 bta_dm_cb.disable_timer.param = 1;
658 bta_sys_start_timer(&bta_dm_cb.disable_timer, 0, 1500);
659 }
660 } else {
661 bta_dm_cb.disabling = FALSE;
662
663 bta_sys_remove_uuid(UUID_SERVCLASS_PNP_INFORMATION);
664 bta_dm_cb.p_sec_cback(BTA_DM_DISABLE_EVT, NULL);
665 }
666 }
667
668
669
670
671 /*******************************************************************************
672 **
673 ** Function bta_dm_set_dev_name
674 **
675 ** Description Sets local device name
676 **
677 **
678 ** Returns void
679 **
680 *******************************************************************************/
bta_dm_set_dev_name(tBTA_DM_MSG * p_data)681 void bta_dm_set_dev_name (tBTA_DM_MSG *p_data)
682 {
683 BTM_SetLocalDeviceName((char *)p_data->set_name.name);
684 #if CLASSIC_BT_INCLUDED
685 bta_dm_set_eir ((char *)p_data->set_name.name);
686 #endif /// CLASSIC_BT_INCLUDED
687 }
688
689 /*******************************************************************************
690 **
691 ** Function bta_dm_get_dev_name
692 **
693 ** Description Gets local device name
694 **
695 **
696 ** Returns void
697 **
698 *******************************************************************************/
bta_dm_get_dev_name(tBTA_DM_MSG * p_data)699 void bta_dm_get_dev_name (tBTA_DM_MSG *p_data)
700 {
701 tBTM_STATUS status;
702 char *name = NULL;
703
704 status = BTM_ReadLocalDeviceName(&name);
705 if (p_data->get_name.p_cback) {
706 (*p_data->get_name.p_cback)(status, name);
707 }
708 }
709
bta_dm_send_vendor_hci(tBTA_DM_MSG * p_data)710 void bta_dm_send_vendor_hci(tBTA_DM_MSG *p_data)
711 {
712 BTM_VendorSpecificCommand(p_data->vendor_hci_cmd.opcode,
713 p_data->vendor_hci_cmd.param_len,
714 p_data->vendor_hci_cmd.p_param_buf,
715 p_data->vendor_hci_cmd.vendor_hci_cb);
716 }
717
718 /*******************************************************************************
719 **
720 ** Function bta_dm_set_afh_channels
721 **
722 ** Description Sets AFH channels
723 **
724 **
725 ** Returns void
726 **
727 *******************************************************************************/
bta_dm_set_afh_channels(tBTA_DM_MSG * p_data)728 void bta_dm_set_afh_channels (tBTA_DM_MSG *p_data)
729 {
730 #if CLASSIC_BT_INCLUDED
731 BTM_SetAfhChannels (p_data->set_afh_channels.channels, p_data->set_afh_channels.set_afh_cb);
732 #endif /// CLASSIC_BT_INCLUDED
733 }
734
735 #if (SDP_INCLUDED == TRUE)
736 /*******************************************************************************
737 **
738 ** Function bta_dm_read_remote_device_name
739 **
740 ** Description Initiate to get remote device name
741 **
742 ** Returns TRUE if started to get remote name
743 **
744 *******************************************************************************/
bta_dm_read_remote_device_name(BD_ADDR bd_addr,tBT_TRANSPORT transport)745 static BOOLEAN bta_dm_read_remote_device_name (BD_ADDR bd_addr, tBT_TRANSPORT transport)
746 {
747 tBTM_STATUS btm_status;
748
749 APPL_TRACE_DEBUG("bta_dm_read_remote_device_name");
750
751 bdcpy(bta_dm_search_cb.peer_bdaddr, bd_addr);
752 bta_dm_search_cb.peer_name[0] = '\0';
753
754 btm_status = BTM_ReadRemoteDeviceName (bta_dm_search_cb.peer_bdaddr,
755 (tBTM_CMPL_CB *) bta_dm_remname_cback,
756 transport);
757
758 if ( btm_status == BTM_CMD_STARTED ) {
759 APPL_TRACE_DEBUG("bta_dm_read_remote_device_name: BTM_ReadRemoteDeviceName is started");
760
761 return (TRUE);
762 } else if ( btm_status == BTM_BUSY ) {
763 APPL_TRACE_DEBUG("bta_dm_read_remote_device_name: BTM_ReadRemoteDeviceName is busy");
764
765 /* Remote name discovery is on going now so BTM cannot notify through "bta_dm_remname_cback" */
766 /* adding callback to get notified that current reading remote name done */
767 BTM_SecAddRmtNameNotifyCallback(&bta_dm_service_search_remname_cback);
768
769 return (TRUE);
770 } else {
771 APPL_TRACE_WARNING("bta_dm_read_remote_device_name: BTM_ReadRemoteDeviceName returns 0x%02X", btm_status);
772
773 return (FALSE);
774 }
775 }
776
777 /*******************************************************************************
778 **
779 ** Function bta_dm_read_rmt_name
780 **
781 ** Description Initiate to get remote device name
782 **
783 ** Returns TRUE if started to get remote name
784 **
785 *******************************************************************************/
bta_dm_read_rmt_name(tBTA_DM_MSG * p_data)786 void bta_dm_read_rmt_name(tBTA_DM_MSG *p_data)
787 {
788 APPL_TRACE_DEBUG("%s",__func__);
789 bdcpy(bta_dm_search_cb.peer_bdaddr, p_data->get_rmt_name.rmt_addr);
790 bta_dm_search_cb.peer_name[0] = '\0';
791
792 tBTM_STATUS btm_status = BTM_ReadRemoteDeviceName(bta_dm_search_cb.peer_bdaddr,
793 (tBTM_CMPL_CB *) p_data->get_rmt_name.rmt_name_cb,
794 bta_dm_search_cb.transport);
795
796 if (btm_status == BTM_CMD_STARTED) {
797 BTM_TRACE_DEBUG("%s: BTM_ReadRemoteDeviceName is started",__func__);
798 } else if (btm_status == BTM_BUSY) {
799 BTM_TRACE_DEBUG("%s: BTM_ReadRemoteDeviceName is busy",__func__);
800 } else {
801 BTM_TRACE_WARNING("%s: BTM_ReadRemoteDeviceName returns 0x%02X",__func__, btm_status);
802 }
803 }
804 #endif ///SDP_INCLUDED == TRUE
805
806 #if (CLASSIC_BT_INCLUDED == TRUE)
bta_dm_config_eir(tBTA_DM_MSG * p_data)807 void bta_dm_config_eir (tBTA_DM_MSG *p_data)
808 {
809 tBTA_DM_API_CONFIG_EIR *config_eir = &p_data->config_eir;
810
811 p_bta_dm_eir_cfg->bta_dm_eir_fec_required = config_eir->eir_fec_required;
812 p_bta_dm_eir_cfg->bta_dm_eir_included_name = config_eir->eir_included_name;
813 p_bta_dm_eir_cfg->bta_dm_eir_included_uuid = config_eir->eir_included_uuid;
814 p_bta_dm_eir_cfg->bta_dm_eir_included_tx_power = config_eir->eir_included_tx_power;
815 p_bta_dm_eir_cfg->bta_dm_eir_flags = config_eir->eir_flags;
816 p_bta_dm_eir_cfg->bta_dm_eir_manufac_spec_len = config_eir->eir_manufac_spec_len;
817 p_bta_dm_eir_cfg->bta_dm_eir_url_len = config_eir->eir_url_len;
818
819 if (p_bta_dm_eir_cfg->bta_dm_eir_manufac_spec) {
820 osi_free(p_bta_dm_eir_cfg->bta_dm_eir_manufac_spec);
821 p_bta_dm_eir_cfg->bta_dm_eir_manufac_spec = NULL;
822 }
823 if (config_eir->eir_manufac_spec_len > 0) {
824 p_bta_dm_eir_cfg->bta_dm_eir_manufac_spec = osi_malloc(config_eir->eir_manufac_spec_len);
825 if (p_bta_dm_eir_cfg->bta_dm_eir_manufac_spec) {
826 memcpy(p_bta_dm_eir_cfg->bta_dm_eir_manufac_spec, config_eir->eir_manufac_spec, config_eir->eir_manufac_spec_len);
827 } else {
828 APPL_TRACE_ERROR("%s, malloc failed.", __func__);
829 p_bta_dm_eir_cfg->bta_dm_eir_manufac_spec_len = 0;
830 }
831 }
832
833 if (p_bta_dm_eir_cfg->bta_dm_eir_url) {
834 osi_free(p_bta_dm_eir_cfg->bta_dm_eir_url);
835 p_bta_dm_eir_cfg->bta_dm_eir_url = NULL;
836 }
837 if (config_eir->eir_url_len > 0) {
838 p_bta_dm_eir_cfg->bta_dm_eir_url = osi_malloc(config_eir->eir_url_len);
839 if (p_bta_dm_eir_cfg->bta_dm_eir_url) {
840 memcpy(p_bta_dm_eir_cfg->bta_dm_eir_url, config_eir->eir_url, config_eir->eir_url_len);
841 } else {
842 APPL_TRACE_ERROR("%s, malloc failed.", __func__);
843 p_bta_dm_eir_cfg->bta_dm_eir_url_len = 0;
844 }
845 }
846
847 bta_dm_set_eir(NULL);
848 }
849
850 /*******************************************************************************
851 **
852 ** Function bta_dm_set_acl_pkt_types
853 **
854 ** Description Sets ACL packet types
855 **
856 **
857 ** Returns void
858 **
859 *******************************************************************************/
bta_dm_set_acl_pkt_types(tBTA_DM_MSG * p_data)860 void bta_dm_set_acl_pkt_types (tBTA_DM_MSG *p_data)
861 {
862 if (p_data->set_acl_pkt_types.set_acl_pkt_types_cb != NULL) {
863 BTM_SetAclPktTypes(p_data->set_acl_pkt_types.rmt_addr,
864 p_data->set_acl_pkt_types.pkt_types,
865 p_data->set_acl_pkt_types.set_acl_pkt_types_cb);
866 } else {
867 APPL_TRACE_ERROR("%s(), the callback function can't be NULL.", __func__);
868 }
869 }
870
871 #endif
872 /*******************************************************************************
873 **
874 ** Function bta_dm_ble_set_channels
875 **
876 ** Description Sets AFH channels
877 **
878 **
879 ** Returns void
880 **
881 *******************************************************************************/
bta_dm_ble_set_channels(tBTA_DM_MSG * p_data)882 void bta_dm_ble_set_channels (tBTA_DM_MSG *p_data)
883 {
884 #if (BLE_INCLUDED == TRUE)
885 BTM_BleSetChannels (p_data->ble_set_channels.channels, p_data->ble_set_channels.set_channels_cb);
886 #endif /// BLE_INCLUDED == TRUE
887 }
888
bta_dm_update_white_list(tBTA_DM_MSG * p_data)889 void bta_dm_update_white_list(tBTA_DM_MSG *p_data)
890 {
891 #if (BLE_INCLUDED == TRUE)
892 BTM_BleUpdateAdvWhitelist(p_data->white_list.add_remove, p_data->white_list.remote_addr, p_data->white_list.addr_type, p_data->white_list.update_wl_cb);
893 #endif ///BLE_INCLUDED == TRUE
894 }
895
bta_dm_clear_white_list(tBTA_DM_MSG * p_data)896 void bta_dm_clear_white_list(tBTA_DM_MSG *p_data)
897 {
898 #if (BLE_INCLUDED == TRUE)
899 BTM_BleClearWhitelist(p_data->white_list.update_wl_cb);
900 #endif
901 }
902
bta_dm_ble_read_adv_tx_power(tBTA_DM_MSG * p_data)903 void bta_dm_ble_read_adv_tx_power(tBTA_DM_MSG *p_data)
904 {
905 #if (BLE_INCLUDED == TRUE)
906 if (p_data->read_tx_power.read_tx_power_cb != NULL) {
907 BTM_BleReadAdvTxPower(p_data->read_tx_power.read_tx_power_cb);
908 } else {
909 APPL_TRACE_ERROR("%s(), the callback function can't be NULL.", __func__);
910 }
911 #endif ///BLE_INCLUDED == TRUE
912 }
913
bta_dm_read_rssi(tBTA_DM_MSG * p_data)914 void bta_dm_read_rssi(tBTA_DM_MSG *p_data)
915 {
916 if (p_data->rssi.read_rssi_cb != NULL) {
917 BTM_ReadRSSI(p_data->rssi.remote_addr, p_data->rssi.transport, p_data->rssi.read_rssi_cb);
918 } else {
919 APPL_TRACE_ERROR("%s(), the callback function can't be NULL.", __func__);
920 }
921 }
922
923 /*******************************************************************************
924 **
925 ** Function bta_dm_set_visibility
926 **
927 ** Description Sets discoverability, connectability and pairability
928 **
929 **
930 ** Returns void
931 **
932 *******************************************************************************/
bta_dm_set_visibility(tBTA_DM_MSG * p_data)933 void bta_dm_set_visibility(tBTA_DM_MSG *p_data)
934 {
935 UINT16 window, interval;
936 UINT16 disc_mode = BTM_ReadDiscoverability(&window, &interval);
937 UINT16 conn_mode = BTM_ReadConnectability(&window, &interval);
938 #if (BLE_INCLUDED == TRUE)
939 UINT16 le_disc_mode = BTM_BleReadDiscoverability();
940 UINT16 le_conn_mode = BTM_BleReadConnectability();
941 #endif ///BLE_INCLUDED == TRUE
942
943 /* set modes for Discoverability and connectability if not ignore */
944 if (p_data->set_visibility.disc_mode != (BTA_DM_IGNORE | BTA_DM_LE_IGNORE)) {
945 #if (BLE_INCLUDED == TRUE)
946 if ((p_data->set_visibility.disc_mode & BTA_DM_LE_IGNORE) == BTA_DM_LE_IGNORE) {
947 p_data->set_visibility.disc_mode =
948 ((p_data->set_visibility.disc_mode & ~BTA_DM_LE_IGNORE) | le_disc_mode);
949 }
950 #endif ///BLE_INCLUDED == TRUE
951
952 if ((p_data->set_visibility.disc_mode & BTA_DM_IGNORE) == BTA_DM_IGNORE) {
953 p_data->set_visibility.disc_mode =
954 ((p_data->set_visibility.disc_mode & ~BTA_DM_IGNORE) | disc_mode);
955 }
956
957 #if (CLASSIC_BT_INCLUDED == TRUE)
958 BTM_SetDiscoverability(p_data->set_visibility.disc_mode,
959 bta_dm_cb.inquiry_scan_window,
960 bta_dm_cb.inquiry_scan_interval);
961 #endif
962 }
963
964 if (p_data->set_visibility.conn_mode != (BTA_DM_IGNORE | BTA_DM_LE_IGNORE)) {
965 #if (BLE_INCLUDED == TRUE)
966 if ((p_data->set_visibility.conn_mode & BTA_DM_LE_IGNORE) == BTA_DM_LE_IGNORE) {
967 p_data->set_visibility.conn_mode =
968 ((p_data->set_visibility.conn_mode & ~BTA_DM_LE_IGNORE) | le_conn_mode);
969 }
970 #endif ///BLE_INCLUDED == TRUE
971
972 if ((p_data->set_visibility.conn_mode & BTA_DM_IGNORE) == BTA_DM_IGNORE) {
973 p_data->set_visibility.conn_mode =
974 ((p_data->set_visibility.conn_mode & ~BTA_DM_IGNORE) | conn_mode);
975 }
976
977 #if (CLASSIC_BT_INCLUDED == TRUE)
978 BTM_SetConnectability(p_data->set_visibility.conn_mode,
979 bta_dm_cb.page_scan_window,
980 bta_dm_cb.page_scan_interval);
981 #endif
982 }
983
984 /* Send False or True if not ignore */
985 if (p_data->set_visibility.pair_mode != BTA_DM_IGNORE ) {
986
987 if (p_data->set_visibility.pair_mode == BTA_DM_NON_PAIRABLE) {
988 bta_dm_cb.disable_pair_mode = TRUE;
989 } else {
990 bta_dm_cb.disable_pair_mode = FALSE;
991 }
992
993 }
994
995 /* Send False or True if not ignore */
996 if (p_data->set_visibility.conn_paired_only != BTA_DM_IGNORE) {
997
998 if (p_data->set_visibility.conn_paired_only == BTA_DM_CONN_ALL) {
999 bta_dm_cb.conn_paired_only = FALSE;
1000 } else {
1001 bta_dm_cb.conn_paired_only = TRUE;
1002 }
1003
1004 }
1005
1006 /* Change mode if either mode is not ignore */
1007 if (p_data->set_visibility.pair_mode != BTA_DM_IGNORE || p_data->set_visibility.conn_paired_only != BTA_DM_IGNORE) {
1008 BTM_SetPairableMode((BOOLEAN)(!(bta_dm_cb.disable_pair_mode)), bta_dm_cb.conn_paired_only);
1009 }
1010
1011 }
1012
1013 /*******************************************************************************
1014 **
1015 ** Function bta_dm_process_remove_device
1016 **
1017 ** Description Removes device, Disconnects ACL link if required.
1018 ****
1019 *******************************************************************************/
bta_dm_process_remove_device(BD_ADDR bd_addr,tBT_TRANSPORT transport)1020 static void bta_dm_process_remove_device(BD_ADDR bd_addr, tBT_TRANSPORT transport)
1021 {
1022 #if (BLE_INCLUDED == TRUE && GATTC_INCLUDED == TRUE)
1023 /* need to remove all pending background connection before unpair */
1024 BTA_GATTC_CancelOpen(0, bd_addr, FALSE);
1025 #endif
1026
1027 BTM_SecDeleteDevice(bd_addr, transport);
1028
1029 if (bta_dm_cb.p_sec_cback) {
1030 tBTA_DM_SEC sec_event;
1031 bdcpy(sec_event.link_down.bd_addr, bd_addr);
1032 sec_event.link_down.status = HCI_SUCCESS;
1033 if (transport == BT_TRANSPORT_LE){
1034 bta_dm_cb.p_sec_cback(BTA_DM_BLE_DEV_UNPAIRED_EVT, &sec_event);
1035 } else {
1036 bta_dm_cb.p_sec_cback(BTA_DM_DEV_UNPAIRED_EVT, &sec_event);
1037 }
1038
1039 }
1040 }
1041
1042 /*******************************************************************************
1043 **
1044 ** Function bta_dm_remove_device
1045 **
1046 ** Description Removes device, disconnects ACL link if required.
1047 ****
1048 *******************************************************************************/
bta_dm_remove_device(tBTA_DM_MSG * p_data)1049 void bta_dm_remove_device(tBTA_DM_MSG *p_data)
1050 {
1051 tBTA_DM_API_REMOVE_DEVICE *p_dev = &p_data->remove_dev;
1052 if (p_dev == NULL) {
1053 return;
1054 }
1055
1056 /* If ACL exists for the device in the remove_bond message*/
1057 BOOLEAN continue_delete_dev = FALSE;
1058 UINT8 transport = p_dev->transport;
1059
1060 if (BTM_IsAclConnectionUp(p_dev->bd_addr, transport)) {
1061 APPL_TRACE_DEBUG("%s: ACL Up count %d", __func__, bta_dm_cb.device_list.count);
1062 continue_delete_dev = FALSE;
1063
1064 /* Take the link down first, and mark the device for removal when disconnected */
1065 for (int i = 0; i < bta_dm_cb.device_list.count; i++) {
1066 if (!bdcmp(bta_dm_cb.device_list.peer_device[i].peer_bdaddr, p_dev->bd_addr)
1067 #if BLE_INCLUDED == TRUE
1068 && bta_dm_cb.device_list.peer_device[i].transport == transport
1069 #endif
1070 ) {
1071
1072 bta_dm_cb.device_list.peer_device[i].conn_state = BTA_DM_UNPAIRING;
1073 btm_remove_acl( p_dev->bd_addr, transport);
1074 APPL_TRACE_DEBUG("%s:transport = %d", __func__, transport);
1075 break;
1076 }
1077 }
1078 } else {
1079 continue_delete_dev = TRUE;
1080 }
1081
1082 /* Delete the device mentioned in the msg */
1083 if (continue_delete_dev) {
1084 bta_dm_process_remove_device(p_dev->bd_addr, transport);
1085 }
1086
1087 BTM_ClearInqDb (p_dev->bd_addr);
1088 }
1089
1090 /*******************************************************************************
1091 **
1092 ** Function bta_dm_add_device
1093 **
1094 ** Description This function adds a Link Key to an security database entry.
1095 ** It is normally called during host startup to restore all required information
1096 ** stored in the NVRAM.
1097 ****
1098 *******************************************************************************/
bta_dm_add_device(tBTA_DM_MSG * p_data)1099 void bta_dm_add_device (tBTA_DM_MSG *p_data)
1100 {
1101 tBTA_DM_API_ADD_DEVICE *p_dev = &p_data->add_dev;
1102 UINT8 *p_dc = NULL;
1103 UINT8 *p_lc = NULL;
1104 UINT32 trusted_services_mask[BTM_SEC_SERVICE_ARRAY_SIZE];
1105 UINT8 index = 0;
1106 UINT8 btm_mask_index = 0;
1107
1108 memset (trusted_services_mask, 0, sizeof(trusted_services_mask));
1109
1110 /* If not all zeros, the device class has been specified */
1111 if (p_dev->dc_known) {
1112 p_dc = (UINT8 *)p_dev->dc;
1113 }
1114
1115 if (p_dev->link_key_known) {
1116 p_lc = (UINT8 *)p_dev->link_key;
1117 }
1118
1119 if (p_dev->is_trusted) {
1120 /* convert BTA service mask to BTM mask */
1121 while (p_dev->tm && (index < BTA_MAX_SERVICE_ID)) {
1122 if (p_dev->tm & (UINT32)(1 << index)) {
1123
1124 btm_mask_index = bta_service_id_to_btm_srv_id_lkup_tbl[index] / BTM_SEC_ARRAY_BITS;
1125 trusted_services_mask[btm_mask_index] |= (UINT32)(1 << (bta_service_id_to_btm_srv_id_lkup_tbl[index] - (UINT32)(btm_mask_index * 32)));
1126
1127 p_dev->tm &= (UINT32)(~(1 << index));
1128
1129 }
1130 index++;
1131 }
1132 }
1133
1134 if (!BTM_SecAddDevice (p_dev->bd_addr, p_dc, p_dev->bd_name, p_dev->features,
1135 trusted_services_mask, p_lc, p_dev->key_type, p_dev->io_cap,
1136 p_dev->pin_length, p_dev->sc_support)) {
1137 APPL_TRACE_ERROR ("BTA_DM: Error adding device %08x%04x",
1138 (p_dev->bd_addr[0] << 24) + (p_dev->bd_addr[1] << 16) + (p_dev->bd_addr[2] << 8) + p_dev->bd_addr[3],
1139 (p_dev->bd_addr[4] << 8) + p_dev->bd_addr[5]);
1140 }
1141 }
1142
1143 /*******************************************************************************
1144 **
1145 ** Function bta_dm_close_acl
1146 **
1147 ** Description This function forces to close the connection to a remote device
1148 ** and optionally remove the device from security database if
1149 ** required.
1150 ****
1151 *******************************************************************************/
bta_dm_close_acl(tBTA_DM_MSG * p_data)1152 void bta_dm_close_acl(tBTA_DM_MSG *p_data)
1153 {
1154 tBTA_DM_API_REMOVE_ACL *p_remove_acl = &p_data->remove_acl;
1155 UINT8 index;
1156
1157 APPL_TRACE_DEBUG("bta_dm_close_acl");
1158
1159 if (BTM_IsAclConnectionUp(p_remove_acl->bd_addr, p_remove_acl->transport)) {
1160 for (index = 0; index < bta_dm_cb.device_list.count; index ++) {
1161 if (!bdcmp( bta_dm_cb.device_list.peer_device[index].peer_bdaddr, p_remove_acl->bd_addr)) {
1162 break;
1163 }
1164 }
1165 if (index != bta_dm_cb.device_list.count) {
1166 if (p_remove_acl->remove_dev) {
1167 bta_dm_cb.device_list.peer_device[index].remove_dev_pending = TRUE;
1168 }
1169 } else {
1170 APPL_TRACE_ERROR("unknown device, remove ACL failed");
1171 }
1172 /* Disconnect the ACL link */
1173 btm_remove_acl(p_remove_acl->bd_addr, p_remove_acl->transport);
1174 }
1175 /* if to remove the device from security database ? do it now */
1176 else if (p_remove_acl->remove_dev) {
1177 if (!BTM_SecDeleteDevice(p_remove_acl->bd_addr, p_remove_acl->transport)) {
1178 APPL_TRACE_ERROR("delete device from security database failed.");
1179 }
1180 #if (BLE_INCLUDED == TRUE && GATTC_INCLUDED == TRUE)
1181 /* need to remove all pending background connection if any */
1182 BTA_GATTC_CancelOpen(0, p_remove_acl->bd_addr, FALSE);
1183 #endif
1184 }
1185 /* otherwise, no action needed */
1186
1187 }
1188
1189 /*******************************************************************************
1190 **
1191 ** Function bta_dm_remove_all_acl
1192 **
1193 ** Description This function forces to close all the ACL links specified by link type
1194 ****
1195 *******************************************************************************/
bta_dm_remove_all_acl(tBTA_DM_MSG * p_data)1196 void bta_dm_remove_all_acl(tBTA_DM_MSG *p_data)
1197 {
1198 const tBTA_DM_LINK_TYPE link_type = p_data->remove_all_acl.link_type;
1199 tBT_TRANSPORT transport = BT_TRANSPORT_BR_EDR;
1200
1201 APPL_TRACE_DEBUG("%s link type = %d", __func__, link_type);
1202
1203 for (UINT8 i = 0; i < bta_dm_cb.device_list.count; i++) {
1204 BD_ADDR addr = {0};
1205 bdcpy(addr, bta_dm_cb.device_list.peer_device[i].peer_bdaddr);
1206 #if defined (BLE_INCLUDED) && (BLE_INCLUDED == TRUE)
1207 transport = bta_dm_cb.device_list.peer_device[i].transport;
1208 #endif
1209 if ((link_type == BTA_DM_LINK_TYPE_ALL) ||
1210 ((link_type == BTA_DM_LINK_TYPE_LE) && (transport == BT_TRANSPORT_LE)) ||
1211 ((link_type == BTA_DM_LINK_TYPE_BR_EDR) && (transport == BT_TRANSPORT_BR_EDR))) {
1212 /* Disconnect the ACL link */
1213 btm_remove_acl(addr, transport);
1214 }
1215 }
1216 }
1217
1218
1219 /*******************************************************************************
1220 **
1221 ** Function bta_dm_bond
1222 **
1223 ** Description Bonds with peer device
1224 **
1225 **
1226 ** Returns void
1227 **
1228 *******************************************************************************/
1229 #if (SMP_INCLUDED == TRUE)
bta_dm_bond(tBTA_DM_MSG * p_data)1230 void bta_dm_bond (tBTA_DM_MSG *p_data)
1231 {
1232 tBTM_STATUS status;
1233 tBTA_DM_SEC sec_event;
1234 char *p_name;
1235
1236 if (p_data->bond.transport == BTA_TRANSPORT_UNKNOWN) {
1237 status = BTM_SecBond ( p_data->bond.bd_addr, 0, NULL, 0 );
1238 } else {
1239 status = BTM_SecBondByTransport ( p_data->bond.bd_addr, p_data->bond.transport, 0, NULL, 0 );
1240 }
1241
1242
1243 if (bta_dm_cb.p_sec_cback && (status != BTM_CMD_STARTED)) {
1244
1245 memset(&sec_event, 0, sizeof(tBTA_DM_SEC));
1246 bdcpy(sec_event.auth_cmpl.bd_addr, p_data->bond.bd_addr);
1247 p_name = BTM_SecReadDevName(p_data->bond.bd_addr);
1248 if (p_name != NULL) {
1249 memcpy(sec_event.auth_cmpl.bd_name, p_name, (BD_NAME_LEN - 1));
1250 sec_event.auth_cmpl.bd_name[BD_NAME_LEN - 1] = 0;
1251 }
1252
1253 /* taken care of by memset [above]
1254 sec_event.auth_cmpl.key_present = FALSE;
1255 sec_event.auth_cmpl.success = FALSE;
1256 */
1257 sec_event.auth_cmpl.fail_reason = HCI_ERR_ILLEGAL_COMMAND;
1258 if (status == BTM_SUCCESS) {
1259 sec_event.auth_cmpl.success = TRUE;
1260 } else {
1261 /* delete this device entry from Sec Dev DB */
1262 bta_dm_remove_sec_dev_entry(p_data->bond.bd_addr);
1263 }
1264 bta_dm_cb.p_sec_cback(BTA_DM_AUTH_CMPL_EVT, &sec_event);
1265 }
1266
1267 }
1268
1269 /*******************************************************************************
1270 **
1271 ** Function bta_dm_bond_cancel
1272 **
1273 ** Description Cancels bonding with a peer device
1274 **
1275 **
1276 ** Returns void
1277 **
1278 *******************************************************************************/
bta_dm_bond_cancel(tBTA_DM_MSG * p_data)1279 void bta_dm_bond_cancel (tBTA_DM_MSG *p_data)
1280 {
1281 tBTM_STATUS status;
1282 tBTA_DM_SEC sec_event;
1283
1284 APPL_TRACE_EVENT(" bta_dm_bond_cancel ");
1285 status = BTM_SecBondCancel ( p_data->bond_cancel.bd_addr );
1286
1287 if (bta_dm_cb.p_sec_cback && (status != BTM_CMD_STARTED && status != BTM_SUCCESS)) {
1288 sec_event.bond_cancel_cmpl.result = BTA_FAILURE;
1289
1290 bta_dm_cb.p_sec_cback(BTA_DM_BOND_CANCEL_CMPL_EVT, &sec_event);
1291 }
1292
1293 }
1294
1295 /*******************************************************************************
1296 **
1297 ** Function bta_dm_set_pin_type
1298 **
1299 ** Description Set the pin type and fixed pin
1300 **
1301 **
1302 ** Returns void
1303 **
1304 *******************************************************************************/
bta_dm_set_pin_type(tBTA_DM_MSG * p_data)1305 void bta_dm_set_pin_type (tBTA_DM_MSG *p_data)
1306 {
1307 #if (CLASSIC_BT_INCLUDED == TRUE)
1308 BTM_SetPinType (p_data->set_pin_type.pin_type, p_data->set_pin_type.p_pin, p_data->set_pin_type.pin_len);
1309 #endif ///CLASSIC_BT_INCLUDED == TRUE
1310 }
1311
1312 /*******************************************************************************
1313 **
1314 ** Function bta_dm_pin_reply
1315 **
1316 ** Description Send the pin_reply to a request from BTM
1317 **
1318 **
1319 ** Returns void
1320 **
1321 *******************************************************************************/
bta_dm_pin_reply(tBTA_DM_MSG * p_data)1322 void bta_dm_pin_reply (tBTA_DM_MSG *p_data)
1323 {
1324 #if (CLASSIC_BT_INCLUDED == TRUE)
1325 UINT32 trusted_mask[BTM_SEC_SERVICE_ARRAY_SIZE];
1326 UINT32 *current_trusted_mask;
1327
1328 current_trusted_mask = BTM_ReadTrustedMask(p_data->pin_reply.bd_addr);
1329
1330 if (current_trusted_mask) {
1331 memcpy(trusted_mask, current_trusted_mask, sizeof(trusted_mask));
1332 } else {
1333 memset(trusted_mask, 0, sizeof(trusted_mask));
1334 }
1335
1336 if (p_data->pin_reply.accept) {
1337
1338 BTM_PINCodeReply(p_data->pin_reply.bd_addr, BTM_SUCCESS, p_data->pin_reply.pin_len, p_data->pin_reply.p_pin, trusted_mask );
1339 } else {
1340 BTM_PINCodeReply(p_data->pin_reply.bd_addr, BTM_NOT_AUTHORIZED, 0, NULL, trusted_mask );
1341 }
1342 #endif ///CLASSIC_BT_INCLUDED == TRUE
1343 }
1344 #endif ///SMP_INCLUDED == TRUE
1345
1346 /*******************************************************************************
1347 **
1348 ** Function bta_dm_policy_cback
1349 **
1350 ** Description process the link policy changes
1351 **
1352 ** Returns void
1353 **
1354 *******************************************************************************/
bta_dm_policy_cback(tBTA_SYS_CONN_STATUS status,UINT8 id,UINT8 app_id,BD_ADDR peer_addr)1355 static void bta_dm_policy_cback(tBTA_SYS_CONN_STATUS status, UINT8 id, UINT8 app_id, BD_ADDR peer_addr)
1356 {
1357 tBTA_DM_PEER_DEVICE *p_dev = NULL;
1358 UINT16 policy = app_id;
1359 UINT32 mask = (UINT32)(1 << id);
1360
1361 if (peer_addr) {
1362 p_dev = bta_dm_find_peer_device(peer_addr);
1363 }
1364
1365 APPL_TRACE_DEBUG(" bta_dm_policy_cback cmd:%d, policy:0x%x",
1366 status, policy);
1367 switch (status) {
1368 case BTA_SYS_PLCY_SET:
1369 if (!p_dev) {
1370 return;
1371 }
1372 /* restore the default link policy */
1373 p_dev->link_policy |= policy;
1374 BTM_SetLinkPolicy(p_dev->peer_bdaddr, &(p_dev->link_policy));
1375 break;
1376
1377 case BTA_SYS_PLCY_CLR:
1378 if (!p_dev) {
1379 return;
1380 }
1381 /* clear the policy from the default link policy */
1382 p_dev->link_policy &= (~policy);
1383 BTM_SetLinkPolicy(p_dev->peer_bdaddr, &(p_dev->link_policy));
1384
1385 #if (BTA_DM_PM_INCLUDED == TRUE)
1386 if (policy & (HCI_ENABLE_SNIFF_MODE | HCI_ENABLE_PARK_MODE)) {
1387 /* if clearing sniff/park, wake the link */
1388 bta_dm_pm_active(p_dev->peer_bdaddr);
1389 }
1390 #endif /* #if (BTA_DM_PM_INCLUDED == TRUE) */
1391 break;
1392
1393 case BTA_SYS_PLCY_DEF_SET:
1394 /* want to restore/set the role switch policy */
1395 bta_dm_cb.role_policy_mask &= ~mask;
1396 if (0 == bta_dm_cb.role_policy_mask) {
1397 /* if nobody wants to insist on the role */
1398 bta_dm_cb.cur_policy |= HCI_ENABLE_MASTER_SLAVE_SWITCH;
1399 BTM_SetDefaultLinkPolicy(bta_dm_cb.cur_policy);
1400 }
1401 break;
1402
1403 case BTA_SYS_PLCY_DEF_CLR:
1404 /* want to remove the role switch policy */
1405 bta_dm_cb.role_policy_mask |= mask;
1406 bta_dm_cb.cur_policy &= ~HCI_ENABLE_MASTER_SLAVE_SWITCH;
1407 BTM_SetDefaultLinkPolicy(bta_dm_cb.cur_policy);
1408 break;
1409 }
1410 }
1411
1412 /*******************************************************************************
1413 **
1414 ** Function bta_dm_confirm
1415 **
1416 ** Description Send the user confirm request reply in response to a
1417 ** request from BTM
1418 **
1419 ** Returns void
1420 **
1421 *******************************************************************************/
1422 #if (SMP_INCLUDED == TRUE)
bta_dm_confirm(tBTA_DM_MSG * p_data)1423 void bta_dm_confirm(tBTA_DM_MSG *p_data)
1424 {
1425 tBTM_STATUS res = BTM_NOT_AUTHORIZED;
1426
1427 if (p_data->confirm.accept == TRUE) {
1428 res = BTM_SUCCESS;
1429 }
1430 BTM_ConfirmReqReply(res, p_data->confirm.bd_addr);
1431 }
1432 #endif ///SMP_INCLUDED == TRUE
1433
1434 /*******************************************************************************
1435 **
1436 ** Function bta_dm_key_req
1437 **
1438 ** Description Send the user passkey request reply in response to a
1439 ** request from BTM
1440 **
1441 ** Returns void
1442 **
1443 *******************************************************************************/
1444 #if (SMP_INCLUDED == TRUE && BT_SSP_INCLUDED)
bta_dm_key_req(tBTA_DM_MSG * p_data)1445 void bta_dm_key_req(tBTA_DM_MSG *p_data)
1446 {
1447 tBTM_STATUS res = BTM_NOT_AUTHORIZED;
1448
1449 if (p_data->key_req.accept == TRUE) {
1450 res = BTM_SUCCESS;
1451 }
1452 BTM_PasskeyReqReply(res, p_data->key_req.bd_addr, p_data->key_req.passkey);
1453 }
1454 #endif ///SMP_INCLUDED == TRUE && BT_SSP_INCLUDED
1455
1456 /*******************************************************************************
1457 **
1458 ** Function bta_dm_loc_oob
1459 **
1460 ** Description Retrieve the OOB data from the local LM
1461 **
1462 ** Returns void
1463 **
1464 *******************************************************************************/
1465 #if (BTM_OOB_INCLUDED == TRUE && SMP_INCLUDED == TRUE)
bta_dm_loc_oob(tBTA_DM_MSG * p_data)1466 void bta_dm_loc_oob(tBTA_DM_MSG *p_data)
1467 {
1468 UNUSED(p_data);
1469 BTM_ReadLocalOobData();
1470 }
1471
1472 /*******************************************************************************
1473 **
1474 ** Function bta_dm_oob_reply
1475 **
1476 ** Description This function is called to provide the OOB data for
1477 ** SMP in response to BLE OOB request.
1478 **
1479 ** Returns void
1480 **
1481 *******************************************************************************/
bta_dm_oob_reply(tBTA_DM_MSG * p_data)1482 void bta_dm_oob_reply(tBTA_DM_MSG *p_data)
1483 {
1484 #if (BLE_INCLUDED)
1485 BTM_BleOobDataReply(p_data->oob_reply.bd_addr, BTM_SUCCESS, p_data->oob_reply.len, p_data->oob_reply.value);
1486 #endif
1487 }
1488
1489 /*******************************************************************************
1490 **
1491 ** Function bta_dm_sc_oob_reply
1492 **
1493 ** Description This function is called to provide the OOB data for
1494 ** SMP in response to BLE secure connection OOB request.
1495 **
1496 ** Returns void
1497 **
1498 *******************************************************************************/
bta_dm_sc_oob_reply(tBTA_DM_MSG * p_data)1499 void bta_dm_sc_oob_reply(tBTA_DM_MSG *p_data)
1500 {
1501 #if (BLE_INCLUDED)
1502 BTM_BleSecureConnectionOobDataReply(p_data->sc_oob_reply.bd_addr, p_data->sc_oob_reply.c, p_data->sc_oob_reply.r);
1503 #endif
1504 }
1505
1506 /*******************************************************************************
1507 **
1508 ** Function bta_dm_sc_create_oob_data
1509 **
1510 ** Description This function is called to create the OOB data for
1511 ** SMP when secure connection.
1512 **
1513 ** Returns void
1514 **
1515 *******************************************************************************/
bta_dm_sc_create_oob_data(tBTA_DM_MSG * p_data)1516 void bta_dm_sc_create_oob_data(tBTA_DM_MSG *p_data)
1517 {
1518 #if (BLE_INCLUDED)
1519 BTM_BleSecureConnectionCreateOobData();
1520 #endif
1521 }
1522
1523 /*******************************************************************************
1524 **
1525 ** Function bta_dm_ci_io_req_act
1526 **
1527 ** Description respond to the IO capabilities request from BTM
1528 **
1529 ** Returns void
1530 **
1531 *******************************************************************************/
bta_dm_ci_io_req_act(tBTA_DM_MSG * p_data)1532 void bta_dm_ci_io_req_act(tBTA_DM_MSG *p_data)
1533 {
1534 tBTM_AUTH_REQ auth_req = BTM_AUTH_AP_NO;
1535 if (p_data->ci_io_req.auth_req) {
1536 auth_req = BTM_AUTH_AP_YES;
1537 }
1538 BTM_IoCapRsp(p_data->ci_io_req.bd_addr, p_data->ci_io_req.io_cap,
1539 p_data->ci_io_req.oob_data, auth_req);
1540 }
1541
1542 /*******************************************************************************
1543 **
1544 ** Function bta_dm_ci_rmt_oob_act
1545 **
1546 ** Description respond to the OOB data request for the remote device from BTM
1547 **
1548 **
1549 ** Returns void
1550 **
1551 *******************************************************************************/
bta_dm_ci_rmt_oob_act(tBTA_DM_MSG * p_data)1552 void bta_dm_ci_rmt_oob_act(tBTA_DM_MSG *p_data)
1553 {
1554 tBTM_STATUS res = BTM_NOT_AUTHORIZED;
1555
1556 if (p_data->ci_rmt_oob.accept == TRUE) {
1557 res = BTM_SUCCESS;
1558 }
1559 BTM_RemoteOobDataReply(res, p_data->ci_rmt_oob.bd_addr,
1560 p_data->ci_rmt_oob.c, p_data->ci_rmt_oob.r );
1561 }
1562 #endif /* BTM_OOB_INCLUDED == TRUE && SMP_INCLUDED == TRUE */
1563
1564 /*******************************************************************************
1565 **
1566 ** Function bta_dm_search_start
1567 **
1568 ** Description Starts an inquiry
1569 **
1570 **
1571 ** Returns void
1572 **
1573 *******************************************************************************/
bta_dm_search_start(tBTA_DM_MSG * p_data)1574 void bta_dm_search_start (tBTA_DM_MSG *p_data)
1575 {
1576 tBTM_INQUIRY_CMPL result;
1577
1578 #if (BLE_INCLUDED == TRUE && BTA_GATT_INCLUDED == TRUE && SDP_INCLUDED == TRUE) && (GATTC_INCLUDED == TRUE)
1579 UINT16 len = (UINT16)(sizeof(tBT_UUID) * p_data->search.num_uuid);
1580 bta_dm_gattc_register();
1581 #endif
1582
1583 APPL_TRACE_DEBUG("%s avoid_scatter=%d", __func__, p_bta_dm_cfg->avoid_scatter);
1584
1585 if (p_bta_dm_cfg->avoid_scatter &&
1586 (p_data->search.rs_res == BTA_DM_RS_NONE) && bta_dm_check_av(BTA_DM_API_SEARCH_EVT)) {
1587 memcpy(&bta_dm_cb.search_msg, &p_data->search, sizeof(tBTA_DM_API_SEARCH));
1588 return;
1589 }
1590
1591 BTM_ClearInqDb(NULL);
1592 /* save search params */
1593 bta_dm_search_cb.p_search_cback = p_data->search.p_cback;
1594 bta_dm_search_cb.services = p_data->search.services;
1595
1596 #if (BLE_INCLUDED == TRUE && BTA_GATT_INCLUDED == TRUE && SDP_INCLUDED == TRUE) && (GATTC_INCLUDED == TRUE)
1597 utl_freebuf((void **)&bta_dm_search_cb.p_srvc_uuid);
1598
1599 if ((bta_dm_search_cb.num_uuid = p_data->search.num_uuid) != 0 &&
1600 p_data->search.p_uuid != NULL) {
1601 if ((bta_dm_search_cb.p_srvc_uuid = (tBT_UUID *)osi_malloc(len)) == NULL) {
1602 APPL_TRACE_ERROR("%s no resources", __func__);
1603
1604 result.status = BTA_FAILURE;
1605 result.num_resp = 0;
1606 bta_dm_inq_cmpl_cb ((void *)&result);
1607 return;
1608 }
1609
1610 memcpy(bta_dm_search_cb.p_srvc_uuid, p_data->search.p_uuid, len);
1611 }
1612 #endif
1613 result.status = BTM_StartInquiry( (tBTM_INQ_PARMS *)&p_data->search.inq_params,
1614 bta_dm_inq_results_cb,
1615 (tBTM_CMPL_CB *) bta_dm_inq_cmpl_cb);
1616
1617 APPL_TRACE_EVENT("%s status=%d", __func__, result.status);
1618 if (result.status != BTM_CMD_STARTED) {
1619 result.num_resp = 0;
1620 bta_dm_inq_cmpl_cb ((void *)&result);
1621 }
1622 }
1623
1624 /*******************************************************************************
1625 **
1626 ** Function bta_dm_search_cancel
1627 **
1628 ** Description Cancels an ongoing search for devices
1629 **
1630 **
1631 ** Returns void
1632 **
1633 *******************************************************************************/
bta_dm_search_cancel(tBTA_DM_MSG * p_data)1634 void bta_dm_search_cancel (tBTA_DM_MSG *p_data)
1635 {
1636 UNUSED(p_data);
1637 tBTA_DM_MSG *p_msg;
1638
1639 if (BTM_IsInquiryActive()) {
1640 if (BTM_CancelInquiry() != BTM_CMD_STARTED) {
1641 bta_dm_search_cancel_notify(NULL);
1642 p_msg = (tBTA_DM_MSG *) osi_malloc(sizeof(tBTA_DM_MSG));
1643 if (p_msg != NULL) {
1644 p_msg->hdr.event = BTA_DM_SEARCH_CMPL_EVT;
1645 p_msg->hdr.layer_specific = BTA_DM_API_DISCOVER_EVT;
1646 bta_sys_sendmsg(p_msg);
1647 }
1648 } else {
1649 /* flag a search cancel is pending */
1650 bta_dm_search_cb.cancel_pending = TRUE;
1651 }
1652 }
1653 /* If no Service Search going on then issue cancel remote name in case it is active */
1654 else if (!bta_dm_search_cb.name_discover_done) {
1655 BTM_CancelRemoteDeviceName();
1656
1657 if ((p_msg = (tBTA_DM_MSG *) osi_malloc(sizeof(tBTA_DM_MSG))) != NULL) {
1658 p_msg->hdr.event = BTA_DM_SEARCH_CMPL_EVT;
1659 p_msg->hdr.layer_specific = BTA_DM_API_DISCOVER_EVT;
1660 bta_sys_sendmsg(p_msg);
1661 }
1662
1663 } else {
1664 if ((p_msg = (tBTA_DM_MSG *) osi_malloc(sizeof(tBTA_DM_MSG))) != NULL) {
1665 p_msg->hdr.event = BTA_DM_INQUIRY_CMPL_EVT;
1666 p_msg->hdr.layer_specific = BTA_DM_API_DISCOVER_EVT;
1667 bta_sys_sendmsg(p_msg);
1668 }
1669 }
1670
1671 #if BLE_INCLUDED == TRUE && BTA_GATT_INCLUDED == TRUE && SDP_INCLUDED == TRUE && GATTC_INCLUDED == TRUE
1672 if (bta_dm_search_cb.gatt_disc_active) {
1673 bta_dm_cancel_gatt_discovery(bta_dm_search_cb.peer_bdaddr);
1674 }
1675 #endif
1676 }
1677
1678 /*******************************************************************************
1679 **
1680 ** Function bta_dm_discover
1681 **
1682 ** Description Discovers services on a remote device
1683 **
1684 **
1685 ** Returns void
1686 **
1687 *******************************************************************************/
1688 #if (SDP_INCLUDED == TRUE)
bta_dm_discover(tBTA_DM_MSG * p_data)1689 void bta_dm_discover (tBTA_DM_MSG *p_data)
1690 {
1691 #if BLE_INCLUDED == TRUE && BTA_GATT_INCLUDED == TRUE && GATTC_INCLUDED == TRUE
1692 UINT16 len = (UINT16)(sizeof(tBT_UUID) * p_data->discover.num_uuid);
1693 #endif
1694 APPL_TRACE_EVENT("%s services_to_search=0x%04X, sdp_search=%d", __func__,
1695 p_data->discover.services, p_data->discover.sdp_search);
1696
1697 /* save the search condition */
1698 bta_dm_search_cb.services = p_data->discover.services;
1699
1700 #if BLE_INCLUDED == TRUE && BTA_GATT_INCLUDED == TRUE && GATTC_INCLUDED == TRUE
1701 bta_dm_gattc_register();
1702 utl_freebuf((void **)&bta_dm_search_cb.p_srvc_uuid);
1703 if ((bta_dm_search_cb.num_uuid = p_data->discover.num_uuid) != 0 &&
1704 p_data->discover.p_uuid != NULL) {
1705 if ((bta_dm_search_cb.p_srvc_uuid = (tBT_UUID *)osi_malloc(len)) == NULL) {
1706 p_data->discover.p_cback(BTA_DM_DISC_CMPL_EVT, NULL);
1707 return;
1708 }
1709 memcpy(bta_dm_search_cb.p_srvc_uuid, p_data->discover.p_uuid, len);
1710 }
1711 bta_dm_search_cb.uuid_to_search = bta_dm_search_cb.num_uuid;
1712 #endif
1713
1714 bta_dm_search_cb.p_search_cback = p_data->discover.p_cback;
1715 bta_dm_search_cb.sdp_search = p_data->discover.sdp_search;
1716 bta_dm_search_cb.services_to_search = bta_dm_search_cb.services;
1717 bta_dm_search_cb.service_index = 0;
1718 bta_dm_search_cb.services_found = 0;
1719 bta_dm_search_cb.peer_name[0] = '\0';
1720 bta_dm_search_cb.sdp_search = p_data->discover.sdp_search;
1721 bta_dm_search_cb.p_btm_inq_info = BTM_InqDbRead (p_data->discover.bd_addr);
1722 bta_dm_search_cb.transport = p_data->discover.transport;
1723
1724 bta_dm_search_cb.name_discover_done = FALSE;
1725 memcpy(&bta_dm_search_cb.uuid, &p_data->discover.uuid, sizeof(tSDP_UUID));
1726 bta_dm_discover_device(p_data->discover.bd_addr);
1727 }
1728
1729 /*******************************************************************************
1730 **
1731 ** Function bta_dm_di_disc_cmpl
1732 **
1733 ** Description Sends event to application when DI discovery complete
1734 **
1735 ** Returns void
1736 **
1737 *******************************************************************************/
bta_dm_di_disc_cmpl(tBTA_DM_MSG * p_data)1738 void bta_dm_di_disc_cmpl(tBTA_DM_MSG *p_data)
1739 {
1740 tBTA_DM_DI_DISC_CMPL di_disc;
1741
1742 memset(&di_disc, 0, sizeof(tBTA_DM_DI_DISC_CMPL));
1743 bdcpy(di_disc.bd_addr, bta_dm_search_cb.peer_bdaddr);
1744
1745 if ((p_data->hdr.offset == SDP_SUCCESS)
1746 || (p_data->hdr.offset == SDP_DB_FULL)) {
1747 di_disc.num_record = SDP_GetNumDiRecords(bta_dm_di_cb.p_di_db);
1748 } else {
1749 di_disc.result = BTA_FAILURE;
1750 }
1751
1752 bta_dm_di_cb.p_di_db = NULL;
1753 bta_dm_search_cb.p_search_cback(BTA_DM_DI_DISC_CMPL_EVT, (tBTA_DM_SEARCH *) &di_disc);
1754 }
1755
1756 /*******************************************************************************
1757 **
1758 ** Function bta_dm_di_disc_callback
1759 **
1760 ** Description This function queries a remote device for DI information.
1761 **
1762 **
1763 ** Returns void
1764 **
1765 *******************************************************************************/
bta_dm_di_disc_callback(UINT16 result)1766 static void bta_dm_di_disc_callback(UINT16 result)
1767 {
1768 tBTA_DM_MSG *p_msg;
1769
1770 if ((p_msg = (tBTA_DM_MSG *) osi_malloc(sizeof(tBTA_DM_MSG))) != NULL) {
1771 p_msg->hdr.event = BTA_DM_SEARCH_CMPL_EVT;
1772 p_msg->hdr.layer_specific = BTA_DM_API_DI_DISCOVER_EVT;
1773 p_msg->hdr.offset = result;
1774 bta_sys_sendmsg(p_msg);
1775 }
1776 }
1777 #endif ///SDP_INCLUDED == TRUE
1778 /*******************************************************************************
1779 **
1780 ** Function bta_dm_disable_search_and_disc
1781 **
1782 ** Description Cancels an ongoing search or discovery for devices in case of
1783 ** a Bluetooth disable
1784 **
1785 **
1786 ** Returns void
1787 **
1788 *******************************************************************************/
bta_dm_disable_search_and_disc(void)1789 static void bta_dm_disable_search_and_disc (void)
1790 {
1791 #if (SDP_INCLUDED == TRUE)
1792 tBTA_DM_DI_DISC_CMPL di_disc;
1793 #endif ///SDP_INCLUDED == TRUE
1794 if (bta_dm_search_cb.state != BTA_DM_SEARCH_IDLE) {
1795 bta_dm_search_cancel(NULL);
1796 }
1797 #if (SDP_INCLUDED == TRUE)
1798 if (bta_dm_di_cb.p_di_db != NULL) {
1799 memset(&di_disc, 0, sizeof(tBTA_DM_DI_DISC_CMPL));
1800 bdcpy(di_disc.bd_addr, bta_dm_search_cb.peer_bdaddr);
1801 di_disc.result = BTA_FAILURE;
1802
1803 bta_dm_di_cb.p_di_db = NULL;
1804 bta_dm_search_cb.p_search_cback(BTA_DM_DI_DISC_CMPL_EVT, NULL);
1805 }
1806 #endif ///SDP_INCLUDED == TRUE
1807 }
1808
1809 /*******************************************************************************
1810 **
1811 ** Function bta_dm_di_disc
1812 **
1813 ** Description This function queries a remote device for DI information.
1814 **
1815 **
1816 ** Returns void
1817 **
1818 *******************************************************************************/
1819 #if (SDP_INCLUDED == TRUE)
bta_dm_di_disc(tBTA_DM_MSG * p_data)1820 void bta_dm_di_disc (tBTA_DM_MSG *p_data)
1821 {
1822 UINT16 result = BTA_FAILURE;
1823 tBTA_DM_MSG *p_msg;
1824
1825 bta_dm_search_cb.p_search_cback = p_data->di_disc.p_cback;
1826 bdcpy(bta_dm_search_cb.peer_bdaddr, p_data->di_disc.bd_addr);
1827 bta_dm_di_cb.p_di_db = p_data->di_disc.p_sdp_db;
1828
1829 if ((bta_dm_search_cb.p_sdp_db = (tSDP_DISCOVERY_DB *)osi_malloc(BTA_DM_SDP_DB_SIZE)) != NULL) {
1830 if ( SDP_DiDiscover(bta_dm_search_cb.peer_bdaddr, p_data->di_disc.p_sdp_db,
1831 p_data->di_disc.len, bta_dm_di_disc_callback) == SDP_SUCCESS) {
1832 result = BTA_SUCCESS;
1833 }
1834 } else {
1835 APPL_TRACE_ERROR("No buffer to start DI discovery");
1836 }
1837
1838 if ( result == BTA_FAILURE &&
1839 (p_msg = (tBTA_DM_MSG *) osi_malloc(sizeof(tBTA_DM_MSG))) != NULL) {
1840 p_msg->hdr.event = BTA_DM_SEARCH_CMPL_EVT;
1841 p_msg->hdr.layer_specific = BTA_DM_API_DI_DISCOVER_EVT;
1842 p_data->hdr.offset = result;
1843 bta_sys_sendmsg(p_msg);
1844 }
1845 }
1846 #endif ///SDP_INCLUDED == TRUE
1847
1848 /*******************************************************************************
1849 **
1850 ** Function bta_dm_inq_cmpl
1851 **
1852 ** Description Process the inquiry complete event from BTM
1853 **
1854 ** Returns void
1855 **
1856 *******************************************************************************/
bta_dm_inq_cmpl(tBTA_DM_MSG * p_data)1857 void bta_dm_inq_cmpl (tBTA_DM_MSG *p_data)
1858 {
1859 tBTA_DM_MSG *p_msg;
1860 tBTA_DM_SEARCH data;
1861
1862 APPL_TRACE_DEBUG("bta_dm_inq_cmpl");
1863
1864 data.inq_cmpl.num_resps = p_data->inq_cmpl.num;
1865 bta_dm_search_cb.p_search_cback(BTA_DM_INQ_CMPL_EVT, &data);
1866
1867 if ((bta_dm_search_cb.p_btm_inq_info = BTM_InqDbFirst()) != NULL) {
1868 /* start name and service discovery from the first device on inquiry result */
1869 bta_dm_search_cb.name_discover_done = FALSE;
1870 bta_dm_search_cb.peer_name[0] = 0;
1871 #if (SDP_INCLUDED == TRUE)
1872 bta_dm_discover_device(bta_dm_search_cb.p_btm_inq_info->results.remote_bd_addr);
1873 #endif ///SDP_INCLUDED == TRUE
1874 } else {
1875 /* no devices, search complete */
1876 bta_dm_search_cb.services = 0;
1877
1878 if ((p_msg = (tBTA_DM_MSG *) osi_malloc(sizeof(tBTA_DM_MSG))) != NULL) {
1879 p_msg->hdr.event = BTA_DM_SEARCH_CMPL_EVT;
1880 p_msg->hdr.layer_specific = BTA_DM_API_DISCOVER_EVT;
1881 bta_sys_sendmsg(p_msg);
1882 }
1883 }
1884 }
1885
1886 /*******************************************************************************
1887 **
1888 ** Function bta_dm_rmt_name
1889 **
1890 ** Description Process the remote name result from BTM
1891 **
1892 ** Returns void
1893 **
1894 *******************************************************************************/
bta_dm_rmt_name(tBTA_DM_MSG * p_data)1895 void bta_dm_rmt_name (tBTA_DM_MSG *p_data)
1896 {
1897 APPL_TRACE_DEBUG("bta_dm_rmt_name");
1898
1899 if ( p_data->rem_name.result.disc_res.bd_name[0] && bta_dm_search_cb.p_btm_inq_info) {
1900 bta_dm_search_cb.p_btm_inq_info->appl_knows_rem_name = TRUE;
1901 }
1902 #if (SDP_INCLUDED == TRUE)
1903 bta_dm_discover_device(bta_dm_search_cb.peer_bdaddr);
1904 #endif ///SDP_INCLUDED == TRUE
1905 }
1906
1907 /*******************************************************************************
1908 **
1909 ** Function bta_dm_disc_rmt_name
1910 **
1911 ** Description Process the remote name result from BTM when application
1912 ** wants to find the name for a bdaddr
1913 **
1914 ** Returns void
1915 **
1916 *******************************************************************************/
bta_dm_disc_rmt_name(tBTA_DM_MSG * p_data)1917 void bta_dm_disc_rmt_name (tBTA_DM_MSG *p_data)
1918 {
1919 tBTM_INQ_INFO *p_btm_inq_info;
1920
1921 APPL_TRACE_DEBUG("bta_dm_disc_rmt_name");
1922
1923 p_btm_inq_info = BTM_InqDbRead (p_data->rem_name.result.disc_res.bd_addr);
1924 if ( p_btm_inq_info ) {
1925 if ( p_data->rem_name.result.disc_res.bd_name[0] ) {
1926 p_btm_inq_info->appl_knows_rem_name = TRUE;
1927 }
1928 }
1929 #if (SDP_INCLUDED == TRUE)
1930 bta_dm_discover_device(p_data->rem_name.result.disc_res.bd_addr);
1931 #endif ///SDP_INCLUDED == TRUE
1932 }
1933
1934 /*******************************************************************************
1935 **
1936 ** Function bta_dm_sdp_result
1937 **
1938 ** Description Process the discovery result from sdp
1939 **
1940 ** Returns void
1941 **
1942 *******************************************************************************/
1943 #if (SDP_INCLUDED == TRUE)
bta_dm_sdp_result(tBTA_DM_MSG * p_data)1944 void bta_dm_sdp_result (tBTA_DM_MSG *p_data)
1945 {
1946 tSDP_DISC_REC *p_sdp_rec = NULL;
1947 tBTA_DM_MSG *p_msg;
1948 BOOLEAN scn_found = FALSE;
1949 UINT16 service = 0xFFFF;
1950 tSDP_PROTOCOL_ELEM pe;
1951
1952 #if BLE_INCLUDED == TRUE && BTA_GATT_INCLUDED == TRUE
1953 tBT_UUID *p_uuid = bta_dm_search_cb.p_srvc_uuid;
1954 tBTA_DM_SEARCH result;
1955 tBT_UUID service_uuid;
1956 #endif
1957
1958 UINT32 num_uuids = 0;
1959 UINT8 uuid_list[32][MAX_UUID_SIZE]; // assuming a max of 32 services
1960
1961 if ((p_data->sdp_event.sdp_result == SDP_SUCCESS)
1962 || (p_data->sdp_event.sdp_result == SDP_NO_RECS_MATCH)
1963 || (p_data->sdp_event.sdp_result == SDP_DB_FULL)) {
1964 APPL_TRACE_DEBUG("sdp_result::0x%x", p_data->sdp_event.sdp_result);
1965 do {
1966 p_sdp_rec = NULL;
1967 if ( bta_dm_search_cb.service_index == (BTA_USER_SERVICE_ID + 1) ) {
1968 p_sdp_rec = SDP_FindServiceUUIDInDb(bta_dm_search_cb.p_sdp_db, &bta_dm_search_cb.uuid, p_sdp_rec);
1969 if (p_sdp_rec && SDP_FindProtocolListElemInRec(p_sdp_rec, UUID_PROTOCOL_RFCOMM, &pe)) {
1970 bta_dm_search_cb.peer_scn = (UINT8) pe.params[0];
1971 scn_found = TRUE;
1972 }
1973 } else {
1974 service = bta_service_id_to_uuid_lkup_tbl[bta_dm_search_cb.service_index - 1];
1975 p_sdp_rec = SDP_FindServiceInDb(bta_dm_search_cb.p_sdp_db, service, p_sdp_rec);
1976 }
1977 #if BLE_INCLUDED == TRUE && BTA_GATT_INCLUDED == TRUE
1978 /* finished with BR/EDR services, now we check the result for GATT based service UUID */
1979 if (bta_dm_search_cb.service_index == BTA_MAX_SERVICE_ID) {
1980 if (bta_dm_search_cb.uuid_to_search != 0 && p_uuid != NULL) {
1981 p_uuid += (bta_dm_search_cb.num_uuid - bta_dm_search_cb.uuid_to_search);
1982 /* only support 16 bits UUID for now */
1983 service = p_uuid->uu.uuid16;
1984 }
1985 /* all GATT based services */
1986 do {
1987 /* find a service record, report it */
1988 p_sdp_rec = SDP_FindServiceInDb(bta_dm_search_cb.p_sdp_db,
1989 0, p_sdp_rec);
1990 if (p_sdp_rec) {
1991 if (SDP_FindServiceUUIDInRec(p_sdp_rec, &service_uuid)) {
1992 /* send result back to app now, one by one */
1993 bdcpy (result.disc_ble_res.bd_addr, bta_dm_search_cb.peer_bdaddr);
1994 BCM_STRNCPY_S((char *)result.disc_ble_res.bd_name, bta_dm_get_remname(), BD_NAME_LEN);
1995 result.disc_ble_res.bd_name[BD_NAME_LEN] = '\0';
1996 result.disc_ble_res.service.len = service_uuid.len;
1997 result.disc_ble_res.service.uu.uuid16 = service_uuid.uu.uuid16;
1998
1999 bta_dm_search_cb.p_search_cback(BTA_DM_DISC_BLE_RES_EVT, &result);
2000 }
2001 }
2002
2003 if (bta_dm_search_cb.uuid_to_search > 0) {
2004 break;
2005 }
2006
2007 } while (p_sdp_rec);
2008 } else
2009 #endif
2010 {
2011 /* SDP_DB_FULL means some records with the
2012 required attributes were received */
2013 if (((p_data->sdp_event.sdp_result == SDP_DB_FULL) &&
2014 bta_dm_search_cb.services != BTA_ALL_SERVICE_MASK) ||
2015 (p_sdp_rec != NULL)) {
2016 if (service != UUID_SERVCLASS_PNP_INFORMATION && service != 0) {
2017 UINT16 tmp_svc = 0xFFFF;
2018 bta_dm_search_cb.services_found |=
2019 (tBTA_SERVICE_MASK)(BTA_SERVICE_ID_TO_SERVICE_MASK(bta_dm_search_cb.service_index - 1));
2020 tmp_svc = bta_service_id_to_uuid_lkup_tbl[bta_dm_search_cb.service_index - 1];
2021 /* Add to the list of UUIDs */
2022 sdpu_uuid16_to_uuid128(tmp_svc, uuid_list[num_uuids]);
2023 num_uuids++;
2024 }
2025 }
2026 }
2027
2028 if (bta_dm_search_cb.services == BTA_ALL_SERVICE_MASK &&
2029 bta_dm_search_cb.services_to_search == 0) {
2030 #if BLE_INCLUDED == TRUE && BTA_GATT_INCLUDED == TRUE
2031 if ( bta_dm_search_cb.service_index == BTA_BLE_SERVICE_ID &&
2032 bta_dm_search_cb.uuid_to_search > 0) {
2033 bta_dm_search_cb.uuid_to_search --;
2034 }
2035
2036 if (bta_dm_search_cb.uuid_to_search == 0 ||
2037 bta_dm_search_cb.service_index != BTA_BLE_SERVICE_ID)
2038 #endif
2039 bta_dm_search_cb.service_index++;
2040 } else { /* regular one service per search or PNP search */
2041 break;
2042 }
2043 } while (bta_dm_search_cb.service_index <= BTA_MAX_SERVICE_ID);
2044
2045 APPL_TRACE_DEBUG("%s services_found = %04x", __FUNCTION__,
2046 bta_dm_search_cb.services_found);
2047
2048 /* Collect the 128-bit services here and put them into the list */
2049 if (bta_dm_search_cb.services == BTA_ALL_SERVICE_MASK) {
2050 p_sdp_rec = NULL;
2051 do {
2052 tBT_UUID temp_uuid;
2053 /* find a service record, report it */
2054 p_sdp_rec = SDP_FindServiceInDb_128bit(bta_dm_search_cb.p_sdp_db, p_sdp_rec);
2055 if (p_sdp_rec) {
2056 if (SDP_FindServiceUUIDInRec_128bit(p_sdp_rec, &temp_uuid)) {
2057 memcpy(uuid_list[num_uuids], temp_uuid.uu.uuid128, MAX_UUID_SIZE);
2058 num_uuids++;
2059 }
2060 }
2061 } while (p_sdp_rec);
2062 }
2063 /* if there are more services to search for */
2064 if (bta_dm_search_cb.services_to_search) {
2065 /* Free up the p_sdp_db before checking the next one */
2066 bta_dm_free_sdp_db(NULL);
2067 bta_dm_find_services(bta_dm_search_cb.peer_bdaddr);
2068 } else {
2069 /* callbacks */
2070 /* start next bd_addr if necessary */
2071
2072 BTM_SecDeleteRmtNameNotifyCallback(&bta_dm_service_search_remname_cback);
2073
2074
2075 if ((p_msg = (tBTA_DM_MSG *) osi_malloc(sizeof(tBTA_DM_MSG))) != NULL) {
2076 p_msg->hdr.event = BTA_DM_DISCOVERY_RESULT_EVT;
2077 p_msg->disc_result.result.disc_res.result = BTA_SUCCESS;
2078 p_msg->disc_result.result.disc_res.p_raw_data = NULL;
2079 p_msg->disc_result.result.disc_res.raw_data_size = 0;
2080 p_msg->disc_result.result.disc_res.num_uuids = num_uuids;
2081 p_msg->disc_result.result.disc_res.p_uuid_list = NULL;
2082 if (num_uuids > 0) {
2083 p_msg->disc_result.result.disc_res.p_uuid_list = (UINT8 *)osi_malloc(num_uuids * MAX_UUID_SIZE);
2084 if (p_msg->disc_result.result.disc_res.p_uuid_list) {
2085 memcpy(p_msg->disc_result.result.disc_res.p_uuid_list, uuid_list,
2086 num_uuids * MAX_UUID_SIZE);
2087 } else {
2088 p_msg->disc_result.result.disc_res.num_uuids = 0;
2089 APPL_TRACE_ERROR("%s: Unable to allocate memory for uuid_list", __func__);
2090 }
2091 }
2092 //copy the raw_data to the discovery result structure
2093 //
2094
2095 if ( bta_dm_search_cb.p_sdp_db != NULL && bta_dm_search_cb.p_sdp_db->raw_used != 0 &&
2096 bta_dm_search_cb.p_sdp_db->raw_data != NULL) {
2097 APPL_TRACE_DEBUG(
2098 "%s raw_data used = 0x%x raw_data_ptr = %p", __func__,
2099 bta_dm_search_cb.p_sdp_db->raw_used,
2100 bta_dm_search_cb.p_sdp_db->raw_data);
2101
2102 p_msg->disc_result.result.disc_res.p_raw_data = osi_malloc(bta_dm_search_cb.p_sdp_db->raw_used);
2103 if ( NULL != p_msg->disc_result.result.disc_res.p_raw_data ) {
2104 memcpy( p_msg->disc_result.result.disc_res.p_raw_data,
2105 bta_dm_search_cb.p_sdp_db->raw_data,
2106 bta_dm_search_cb.p_sdp_db->raw_used );
2107
2108 p_msg->disc_result.result.disc_res.raw_data_size =
2109 bta_dm_search_cb.p_sdp_db->raw_used;
2110
2111 } else {
2112 APPL_TRACE_DEBUG("%s Alloc failed to allocate %d bytes !!", __func__,
2113 bta_dm_search_cb.p_sdp_db->raw_used);
2114 }
2115
2116 bta_dm_search_cb.p_sdp_db->raw_data = NULL; //no need to free this - it is a global assigned.
2117 bta_dm_search_cb.p_sdp_db->raw_used = 0;
2118 bta_dm_search_cb.p_sdp_db->raw_size = 0;
2119 } else {
2120 APPL_TRACE_DEBUG("%s raw data size is 0 or raw_data is null!!", __func__);
2121 }
2122 /* Done with p_sdp_db. Free it */
2123 bta_dm_free_sdp_db(NULL);
2124 p_msg->disc_result.result.disc_res.services = bta_dm_search_cb.services_found;
2125
2126 //Piggy back the SCN over result field
2127 if ( scn_found ) {
2128 p_msg->disc_result.result.disc_res.result = (3 + bta_dm_search_cb.peer_scn);
2129 p_msg->disc_result.result.disc_res.services |= BTA_USER_SERVICE_MASK;
2130
2131 APPL_TRACE_EVENT(" Piggy back the SCN over result field SCN=%d", bta_dm_search_cb.peer_scn);
2132
2133 }
2134 bdcpy (p_msg->disc_result.result.disc_res.bd_addr, bta_dm_search_cb.peer_bdaddr);
2135 BCM_STRNCPY_S((char *)p_msg->disc_result.result.disc_res.bd_name, bta_dm_get_remname(), BD_NAME_LEN);
2136 p_msg->disc_result.result.disc_res.bd_name[BD_NAME_LEN] = '\0';
2137
2138 bta_sys_sendmsg(p_msg);
2139 }
2140 }
2141 } else {
2142 /* conn failed. No need for timer */
2143 if (p_data->sdp_event.sdp_result == SDP_CONN_FAILED || p_data->sdp_event.sdp_result == SDP_CONN_REJECTED
2144 || p_data->sdp_event.sdp_result == SDP_SECURITY_ERR) {
2145 bta_dm_search_cb.wait_disc = FALSE;
2146 }
2147
2148 /* not able to connect go to next device */
2149 osi_free(bta_dm_search_cb.p_sdp_db);
2150 bta_dm_search_cb.p_sdp_db = NULL;
2151
2152 BTM_SecDeleteRmtNameNotifyCallback(&bta_dm_service_search_remname_cback);
2153
2154 if ((p_msg = (tBTA_DM_MSG *) osi_malloc(sizeof(tBTA_DM_MSG))) != NULL) {
2155 p_msg->hdr.event = BTA_DM_DISCOVERY_RESULT_EVT;
2156 p_msg->disc_result.result.disc_res.result = BTA_FAILURE;
2157 p_msg->disc_result.result.disc_res.services = bta_dm_search_cb.services_found;
2158 bdcpy (p_msg->disc_result.result.disc_res.bd_addr, bta_dm_search_cb.peer_bdaddr);
2159 BCM_STRNCPY_S((char *)p_msg->disc_result.result.disc_res.bd_name, bta_dm_get_remname(), BD_NAME_LEN);
2160 p_msg->disc_result.result.disc_res.bd_name[BD_NAME_LEN] = '\0';
2161
2162 bta_sys_sendmsg(p_msg);
2163 }
2164 }
2165 }
2166 #endif ///SDP_INCLUDE == TRUE
2167
2168 /*******************************************************************************
2169 **
2170 ** Function bta_dm_search_cmpl
2171 **
2172 ** Description Sends event to application
2173 **
2174 ** Returns void
2175 **
2176 *******************************************************************************/
bta_dm_search_cmpl(tBTA_DM_MSG * p_data)2177 void bta_dm_search_cmpl (tBTA_DM_MSG *p_data)
2178 {
2179 APPL_TRACE_EVENT("%s", __func__);
2180
2181 #if (BLE_INCLUDED == TRUE && BTA_GATT_INCLUDED == TRUE && SDP_INCLUDED == TRUE)
2182 utl_freebuf((void **)&bta_dm_search_cb.p_srvc_uuid);
2183 #endif
2184
2185 if (p_data->hdr.layer_specific == BTA_DM_API_DI_DISCOVER_EVT) {
2186 #if (SDP_INCLUDED == TRUE)
2187 bta_dm_di_disc_cmpl(p_data);
2188 #endif ///SDP_INCLUDED == TRUE
2189 } else {
2190 bta_dm_search_cb.p_search_cback(BTA_DM_DISC_CMPL_EVT, NULL);
2191 }
2192 }
2193
2194 /*******************************************************************************
2195 **
2196 ** Function bta_dm_disc_result
2197 **
2198 ** Description Service discovery result when discovering services on a device
2199 **
2200 ** Returns void
2201 **
2202 *******************************************************************************/
bta_dm_disc_result(tBTA_DM_MSG * p_data)2203 void bta_dm_disc_result (tBTA_DM_MSG *p_data)
2204 {
2205 APPL_TRACE_EVENT("%s", __func__);
2206
2207 #if BLE_INCLUDED == TRUE && BTA_GATT_INCLUDED == TRUE
2208 /* if any BR/EDR service discovery has been done, report the event */
2209 if ((bta_dm_search_cb.services & ((BTA_ALL_SERVICE_MASK | BTA_USER_SERVICE_MASK ) & ~BTA_BLE_SERVICE_MASK))) {
2210 bta_dm_search_cb.p_search_cback(BTA_DM_DISC_RES_EVT, &p_data->disc_result.result);
2211 }
2212 #else
2213 bta_dm_search_cb.p_search_cback(BTA_DM_DISC_RES_EVT, &p_data->disc_result.result);
2214 #endif
2215 tBTA_DM_MSG *p_msg = (tBTA_DM_MSG *) osi_malloc(sizeof(tBTA_DM_MSG));
2216
2217 /* send a message to change state */
2218 if (p_msg != NULL) {
2219 p_msg->hdr.event = BTA_DM_SEARCH_CMPL_EVT;
2220 p_msg->hdr.layer_specific = BTA_DM_API_DISCOVER_EVT;
2221 bta_sys_sendmsg(p_msg);
2222 }
2223 }
2224
2225 /*******************************************************************************
2226 **
2227 ** Function bta_dm_search_result
2228 **
2229 ** Description Service discovery result while searching for devices
2230 **
2231 ** Returns void
2232 **
2233 *******************************************************************************/
bta_dm_search_result(tBTA_DM_MSG * p_data)2234 void bta_dm_search_result (tBTA_DM_MSG *p_data)
2235 {
2236 APPL_TRACE_DEBUG("%s searching:0x%04x, result:0x%04x", __func__,
2237 bta_dm_search_cb.services,
2238 p_data->disc_result.result.disc_res.services);
2239
2240 /* call back if application wants name discovery or found services that application is searching */
2241 if (( !bta_dm_search_cb.services )
2242 || (( bta_dm_search_cb.services ) && ( p_data->disc_result.result.disc_res.services ))) {
2243 bta_dm_search_cb.p_search_cback(BTA_DM_DISC_RES_EVT, &p_data->disc_result.result);
2244 }
2245
2246 /* if searching did not initiate to create link */
2247 if (!bta_dm_search_cb.wait_disc ) {
2248 /* if service searching is done with EIR, don't search next device */
2249 if ( bta_dm_search_cb.p_btm_inq_info ) {
2250 bta_dm_discover_next_device();
2251 }
2252 } else {
2253 /* wait until link is disconnected or timeout */
2254 bta_dm_search_cb.sdp_results = TRUE;
2255 bta_dm_search_cb.search_timer.p_cback = (TIMER_CBACK *)&bta_dm_search_timer_cback;
2256 bta_sys_start_timer(&bta_dm_search_cb.search_timer, 0, 1000 * (L2CAP_LINK_INACTIVITY_TOUT + 1) );
2257 }
2258
2259 }
2260
2261 /*******************************************************************************
2262 **
2263 ** Function bta_dm_search_timer_cback
2264 **
2265 ** Description Called when ACL disconnect time is over
2266 **
2267 **
2268 ** Returns void
2269 **
2270 *******************************************************************************/
bta_dm_search_timer_cback(TIMER_LIST_ENT * p_tle)2271 static void bta_dm_search_timer_cback (TIMER_LIST_ENT *p_tle)
2272 {
2273 UNUSED(p_tle);
2274
2275 APPL_TRACE_EVENT("%s", __func__);
2276 bta_dm_search_cb.wait_disc = FALSE;
2277
2278 /* proceed with next device */
2279 bta_dm_discover_next_device();
2280
2281 }
2282
2283
2284 /*******************************************************************************
2285 **
2286 ** Function bta_dm_free_sdp_db
2287 **
2288 ** Description Frees SDP data base
2289 **
2290 ** Returns void
2291 **
2292 *******************************************************************************/
2293 #if (SDP_INCLUDED == TRUE)
bta_dm_free_sdp_db(tBTA_DM_MSG * p_data)2294 void bta_dm_free_sdp_db (tBTA_DM_MSG *p_data)
2295 {
2296 UNUSED(p_data);
2297 if (bta_dm_search_cb.p_sdp_db) {
2298 osi_free(bta_dm_search_cb.p_sdp_db);
2299 bta_dm_search_cb.p_sdp_db = NULL;
2300 }
2301 }
2302 #endif ///SDP_INCLUDED == TRUE
2303
2304 /*******************************************************************************
2305 **
2306 ** Function bta_dm_queue_search
2307 **
2308 ** Description Queues search command while search is being cancelled
2309 **
2310 ** Returns void
2311 **
2312 *******************************************************************************/
bta_dm_queue_search(tBTA_DM_MSG * p_data)2313 void bta_dm_queue_search (tBTA_DM_MSG *p_data)
2314 {
2315 if (bta_dm_search_cb.p_search_queue) {
2316 osi_free(bta_dm_search_cb.p_search_queue);
2317 }
2318
2319 bta_dm_search_cb.p_search_queue = (tBTA_DM_MSG *)osi_malloc(sizeof(tBTA_DM_API_SEARCH));
2320 memcpy(bta_dm_search_cb.p_search_queue, p_data, sizeof(tBTA_DM_API_SEARCH));
2321
2322 }
2323
2324 /*******************************************************************************
2325 **
2326 ** Function bta_dm_queue_disc
2327 **
2328 ** Description Queues discovery command while search is being cancelled
2329 **
2330 ** Returns void
2331 **
2332 *******************************************************************************/
2333 #if (SDP_INCLUDED == TRUE)
bta_dm_queue_disc(tBTA_DM_MSG * p_data)2334 void bta_dm_queue_disc (tBTA_DM_MSG *p_data)
2335 {
2336 if (bta_dm_search_cb.p_search_queue) {
2337 osi_free(bta_dm_search_cb.p_search_queue);
2338 }
2339
2340 bta_dm_search_cb.p_search_queue = (tBTA_DM_MSG *)osi_malloc(sizeof(tBTA_DM_API_DISCOVER));
2341 memcpy(bta_dm_search_cb.p_search_queue, p_data, sizeof(tBTA_DM_API_DISCOVER));
2342 }
2343 #endif ///SDP_INCLUDED == TRUE
2344
2345 /*******************************************************************************
2346 **
2347 ** Function bta_dm_search_clear_queue
2348 **
2349 ** Description Clears the queue if API search cancel is called
2350 **
2351 ** Returns void
2352 **
2353 *******************************************************************************/
bta_dm_search_clear_queue(tBTA_DM_MSG * p_data)2354 void bta_dm_search_clear_queue (tBTA_DM_MSG *p_data)
2355 {
2356 UNUSED(p_data);
2357 if (bta_dm_search_cb.p_search_queue) {
2358 osi_free(bta_dm_search_cb.p_search_queue);
2359 bta_dm_search_cb.p_search_queue = NULL;
2360 }
2361 }
2362
2363 /*******************************************************************************
2364 **
2365 ** Function bta_dm_search_cancel_cmpl
2366 **
2367 ** Description Search cancel is complete
2368 **
2369 ** Returns void
2370 **
2371 *******************************************************************************/
bta_dm_search_cancel_cmpl(tBTA_DM_MSG * p_data)2372 void bta_dm_search_cancel_cmpl (tBTA_DM_MSG *p_data)
2373 {
2374 UNUSED(p_data);
2375 if (bta_dm_search_cb.p_search_queue) {
2376 bta_sys_sendmsg(bta_dm_search_cb.p_search_queue);
2377 bta_dm_search_cb.p_search_queue = NULL;
2378 }
2379
2380 }
2381
2382 /*******************************************************************************
2383 **
2384 ** Function bta_dm_search_cancel_transac_cmpl
2385 **
2386 ** Description Current Service Discovery or remote name procedure is
2387 ** completed after search cancellation
2388 **
2389 ** Returns void
2390 **
2391 *******************************************************************************/
2392 #if (SDP_INCLUDED == TRUE)
bta_dm_search_cancel_transac_cmpl(tBTA_DM_MSG * p_data)2393 void bta_dm_search_cancel_transac_cmpl(tBTA_DM_MSG *p_data)
2394 {
2395 UNUSED(p_data);
2396 if (bta_dm_search_cb.p_sdp_db) {
2397 osi_free(bta_dm_search_cb.p_sdp_db);
2398 bta_dm_search_cb.p_sdp_db = NULL;
2399 }
2400
2401 bta_dm_search_cancel_notify(NULL);
2402 }
2403 #endif ///SDP_INCLUDED == TRUE
2404
2405
2406 /*******************************************************************************
2407 **
2408 ** Function bta_dm_search_cancel_notify
2409 **
2410 ** Description Notify application that search has been cancelled
2411 **
2412 ** Returns void
2413 **
2414 *******************************************************************************/
bta_dm_search_cancel_notify(tBTA_DM_MSG * p_data)2415 void bta_dm_search_cancel_notify (tBTA_DM_MSG *p_data)
2416 {
2417 UNUSED(p_data);
2418 if (bta_dm_search_cb.p_search_cback) {
2419 bta_dm_search_cb.p_search_cback(BTA_DM_SEARCH_CANCEL_CMPL_EVT, NULL);
2420 }
2421 if (!bta_dm_search_cb.name_discover_done) {
2422 BTM_CancelRemoteDeviceName();
2423 }
2424 #if (BLE_INCLUDED == TRUE) && (BTA_GATT_INCLUDED == TRUE) && (SDP_INCLUDED == TRUE) && (GATTC_INCLUDED) == TRUE
2425 if (bta_dm_search_cb.gatt_disc_active) {
2426 bta_dm_cancel_gatt_discovery(bta_dm_search_cb.peer_bdaddr);
2427 }
2428 #endif
2429
2430 }
2431
2432 /*******************************************************************************
2433 **
2434 ** Function bta_dm_find_services
2435 **
2436 ** Description Starts discovery on a device
2437 **
2438 ** Returns void
2439 **
2440 *******************************************************************************/
2441 #if (SDP_INCLUDED == TRUE)
bta_dm_find_services(BD_ADDR bd_addr)2442 static void bta_dm_find_services ( BD_ADDR bd_addr)
2443 {
2444 tSDP_UUID uuid;
2445 tBTA_DM_MSG *p_msg;
2446
2447 memset (&uuid, 0, sizeof(tSDP_UUID));
2448
2449 while (bta_dm_search_cb.service_index < BTA_MAX_SERVICE_ID) {
2450 tBTA_SERVICE_MASK this_service_mask = (tBTA_SERVICE_MASK)(BTA_SERVICE_ID_TO_SERVICE_MASK(bta_dm_search_cb.service_index));
2451 if ( bta_dm_search_cb.services_to_search & this_service_mask) {
2452 if ((bta_dm_search_cb.p_sdp_db = (tSDP_DISCOVERY_DB *)osi_malloc(BTA_DM_SDP_DB_SIZE)) != NULL) {
2453 APPL_TRACE_DEBUG("bta_dm_search_cb.services = %04x***********", bta_dm_search_cb.services);
2454 /* try to search all services by search based on L2CAP UUID */
2455 if (bta_dm_search_cb.services == BTA_ALL_SERVICE_MASK ) {
2456 APPL_TRACE_DEBUG("%s services_to_search=%08x", __func__, bta_dm_search_cb.services_to_search);
2457 if (bta_dm_search_cb.services_to_search & BTA_RES_SERVICE_MASK) {
2458 uuid.uu.uuid16 = bta_service_id_to_uuid_lkup_tbl[0];
2459 bta_dm_search_cb.services_to_search &= ~BTA_RES_SERVICE_MASK;
2460 } else {
2461 uuid.uu.uuid16 = UUID_PROTOCOL_L2CAP;
2462 bta_dm_search_cb.services_to_search = 0;
2463 }
2464 } else {
2465 #if BLE_INCLUDED == TRUE && BTA_GATT_INCLUDED == TRUE
2466 /* for LE only profile */
2467 if (this_service_mask == BTA_BLE_SERVICE_MASK) {
2468 if (bta_dm_search_cb.uuid_to_search > 0 && bta_dm_search_cb.p_srvc_uuid) {
2469 memcpy(&uuid,
2470 (const void *)(bta_dm_search_cb.p_srvc_uuid + \
2471 bta_dm_search_cb.num_uuid - bta_dm_search_cb.uuid_to_search),
2472 sizeof(tBT_UUID));
2473
2474 bta_dm_search_cb.uuid_to_search -- ;
2475 } else {
2476 uuid.uu.uuid16 = bta_service_id_to_uuid_lkup_tbl[bta_dm_search_cb.service_index];
2477 }
2478
2479 /* last one? clear the BLE service bit if all discovery has been done */
2480 if (bta_dm_search_cb.uuid_to_search == 0) {
2481 bta_dm_search_cb.services_to_search &=
2482 (tBTA_SERVICE_MASK)(~(BTA_SERVICE_ID_TO_SERVICE_MASK(bta_dm_search_cb.service_index)));
2483 }
2484
2485 } else
2486 #endif
2487 {
2488 /* remove the service from services to be searched */
2489 bta_dm_search_cb.services_to_search &=
2490 (tBTA_SERVICE_MASK)(~(BTA_SERVICE_ID_TO_SERVICE_MASK(bta_dm_search_cb.service_index)));
2491 uuid.uu.uuid16 = bta_service_id_to_uuid_lkup_tbl[bta_dm_search_cb.service_index];
2492 }
2493 }
2494
2495 if (uuid.len == 0) {
2496 uuid.len = LEN_UUID_16;
2497 }
2498
2499 if (this_service_mask == BTA_USER_SERVICE_MASK) {
2500 memcpy(&uuid, &bta_dm_search_cb.uuid, sizeof(tSDP_UUID));
2501 }
2502
2503 APPL_TRACE_DEBUG("%s search UUID = %04x", __func__, uuid.uu.uuid16);
2504 SDP_InitDiscoveryDb (bta_dm_search_cb.p_sdp_db, BTA_DM_SDP_DB_SIZE, 1, &uuid, 0, NULL);
2505
2506 memset(g_disc_raw_data_buf, 0, MAX_DISC_RAW_DATA_BUF);
2507 bta_dm_search_cb.p_sdp_db->raw_data = g_disc_raw_data_buf;
2508
2509 bta_dm_search_cb.p_sdp_db->raw_size = MAX_DISC_RAW_DATA_BUF;
2510
2511 if (!SDP_ServiceSearchAttributeRequest (bd_addr, bta_dm_search_cb.p_sdp_db, &bta_dm_sdp_callback)) {
2512 /* if discovery not successful with this device
2513 proceed to next one */
2514 osi_free(bta_dm_search_cb.p_sdp_db);
2515 bta_dm_search_cb.p_sdp_db = NULL;
2516 bta_dm_search_cb.service_index = BTA_MAX_SERVICE_ID;
2517
2518 } else {
2519 #if BLE_INCLUDED == TRUE && BTA_GATT_INCLUDED == TRUE
2520 if ((this_service_mask == BTA_BLE_SERVICE_MASK &&
2521 bta_dm_search_cb.uuid_to_search == 0) ||
2522 this_service_mask != BTA_BLE_SERVICE_MASK)
2523 #endif
2524 bta_dm_search_cb.service_index++;
2525 return;
2526 }
2527 } else {
2528 APPL_TRACE_ERROR("#### Failed to allocate SDP DB buffer! ####");
2529 }
2530 }
2531
2532 bta_dm_search_cb.service_index++;
2533 }
2534
2535 /* no more services to be discovered */
2536 if (bta_dm_search_cb.service_index >= BTA_MAX_SERVICE_ID) {
2537 if ((p_msg = (tBTA_DM_MSG *) osi_malloc(sizeof(tBTA_DM_MSG))) != NULL) {
2538 p_msg->hdr.event = BTA_DM_DISCOVERY_RESULT_EVT;
2539 p_msg->disc_result.result.disc_res.services = bta_dm_search_cb.services_found;
2540 bdcpy (p_msg->disc_result.result.disc_res.bd_addr, bta_dm_search_cb.peer_bdaddr);
2541 BCM_STRNCPY_S((char *)p_msg->disc_result.result.disc_res.bd_name,bta_dm_get_remname(), BD_NAME_LEN);
2542 p_msg->disc_result.result.disc_res.bd_name[BD_NAME_LEN] = '\0';
2543
2544 bta_sys_sendmsg(p_msg);
2545 }
2546 }
2547 }
2548 #endif ///SDP_INCLUDED == TRUE
2549
2550 /*******************************************************************************
2551 **
2552 ** Function bta_dm_discover_next_device
2553 **
2554 ** Description Starts discovery on the next device in Inquiry data base
2555 **
2556 ** Returns void
2557 **
2558 *******************************************************************************/
bta_dm_discover_next_device(void)2559 static void bta_dm_discover_next_device(void)
2560 {
2561
2562 tBTA_DM_MSG *p_msg;
2563
2564 APPL_TRACE_DEBUG("bta_dm_discover_next_device");
2565
2566 /* searching next device on inquiry result */
2567 if ((bta_dm_search_cb.p_btm_inq_info = BTM_InqDbNext(bta_dm_search_cb.p_btm_inq_info)) != NULL) {
2568 bta_dm_search_cb.name_discover_done = FALSE;
2569 bta_dm_search_cb.peer_name[0] = 0;
2570 #if (SDP_INCLUDED == TRUE)
2571 bta_dm_discover_device(bta_dm_search_cb.p_btm_inq_info->results.remote_bd_addr);
2572 #endif ///SDP_INCLUDED == TRUE
2573 } else {
2574 /* no devices, search complete */
2575 bta_dm_search_cb.services = 0;
2576
2577 if ((p_msg = (tBTA_DM_MSG *) osi_malloc(sizeof(tBTA_DM_MSG))) != NULL) {
2578 p_msg->hdr.event = BTA_DM_SEARCH_CMPL_EVT;
2579 p_msg->hdr.layer_specific = BTA_DM_API_DISCOVER_EVT;
2580 bta_sys_sendmsg(p_msg);
2581 }
2582 }
2583 }
2584
2585 /*******************************************************************************
2586 **
2587 ** Function bta_dm_discover_device
2588 **
2589 ** Description Starts name and service discovery on the device
2590 **
2591 ** Returns void
2592 **
2593 *******************************************************************************/
2594 #if (SDP_INCLUDED == TRUE)
bta_dm_discover_device(BD_ADDR remote_bd_addr)2595 static void bta_dm_discover_device(BD_ADDR remote_bd_addr)
2596 {
2597 tBTA_DM_MSG *p_msg;
2598 tBT_TRANSPORT transport = BT_TRANSPORT_BR_EDR;
2599
2600 #if BLE_INCLUDED == TRUE
2601 if (bta_dm_search_cb.transport == BTA_TRANSPORT_UNKNOWN) {
2602 tBT_DEVICE_TYPE dev_type;
2603 tBLE_ADDR_TYPE addr_type;
2604
2605 BTM_ReadDevInfo(remote_bd_addr, &dev_type, &addr_type);
2606 if (dev_type == BT_DEVICE_TYPE_BLE || addr_type == BLE_ADDR_RANDOM) {
2607 transport = BT_TRANSPORT_LE;
2608 }
2609 } else {
2610 transport = bta_dm_search_cb.transport;
2611 }
2612 #endif
2613
2614 /* Reset transport state for next discovery */
2615 bta_dm_search_cb.transport = BTA_TRANSPORT_UNKNOWN;
2616
2617 APPL_TRACE_DEBUG("%s BDA:0x%02X%02X%02X%02X%02X%02X", __func__,
2618 remote_bd_addr[0], remote_bd_addr[1],
2619 remote_bd_addr[2], remote_bd_addr[3],
2620 remote_bd_addr[4], remote_bd_addr[5]);
2621
2622 bdcpy(bta_dm_search_cb.peer_bdaddr, remote_bd_addr);
2623
2624 APPL_TRACE_DEBUG("%s name_discover_done = %d p_btm_inq_info %p state = %d, transport=%d",
2625 __func__,
2626 bta_dm_search_cb.name_discover_done,
2627 bta_dm_search_cb.p_btm_inq_info,
2628 bta_dm_search_cb.state,
2629 transport);
2630
2631 if (bta_dm_search_cb.p_btm_inq_info) {
2632 APPL_TRACE_DEBUG("%s appl_knows_rem_name %d", __func__,
2633 bta_dm_search_cb.p_btm_inq_info->appl_knows_rem_name);
2634 }
2635
2636 if ((bta_dm_search_cb.p_btm_inq_info)
2637 && (bta_dm_search_cb.p_btm_inq_info->results.device_type == BT_DEVICE_TYPE_BLE)
2638 && (bta_dm_search_cb.state == BTA_DM_SEARCH_ACTIVE)) {
2639 /* Do not perform RNR for LE devices at inquiry complete*/
2640 bta_dm_search_cb.name_discover_done = TRUE;
2641 }
2642
2643 /* if name discovery is not done and application needs remote name */
2644 if ((!bta_dm_search_cb.name_discover_done)
2645 && (( bta_dm_search_cb.p_btm_inq_info == NULL )
2646 || (bta_dm_search_cb.p_btm_inq_info && (!bta_dm_search_cb.p_btm_inq_info->appl_knows_rem_name)))) {
2647 if (bta_dm_read_remote_device_name(bta_dm_search_cb.peer_bdaddr, transport) == TRUE) {
2648 return;
2649 }
2650
2651 /* starting name discovery failed */
2652 bta_dm_search_cb.name_discover_done = TRUE;
2653 }
2654
2655 /* if application wants to discover service */
2656 if ( bta_dm_search_cb.services ) {
2657 /* initialize variables */
2658 bta_dm_search_cb.service_index = 0;
2659 bta_dm_search_cb.services_found = 0;
2660 bta_dm_search_cb.services_to_search = bta_dm_search_cb.services;
2661 #if BLE_INCLUDED == TRUE && BTA_GATT_INCLUDED == TRUE && SDP_INCLUDED == TRUE
2662 bta_dm_search_cb.uuid_to_search = bta_dm_search_cb.num_uuid;
2663 #endif
2664 if ((bta_dm_search_cb.p_btm_inq_info != NULL) &&
2665 bta_dm_search_cb.services != BTA_USER_SERVICE_MASK
2666 && (bta_dm_search_cb.sdp_search == FALSE)) {
2667 /* check if EIR provides the information of supported services */
2668 bta_dm_eir_search_services( &bta_dm_search_cb.p_btm_inq_info->results,
2669 &bta_dm_search_cb.services_to_search,
2670 &bta_dm_search_cb.services_found );
2671 }
2672
2673 /* if searching with EIR is not completed */
2674 if (bta_dm_search_cb.services_to_search) {
2675 /* check whether connection already exists to the device
2676 if connection exists, we don't have to wait for ACL
2677 link to go down to start search on next device */
2678 if (BTM_IsAclConnectionUp(bta_dm_search_cb.peer_bdaddr, BT_TRANSPORT_BR_EDR)) {
2679 bta_dm_search_cb.wait_disc = FALSE;
2680 } else {
2681 bta_dm_search_cb.wait_disc = TRUE;
2682 }
2683
2684 #if (BLE_INCLUDED == TRUE && (defined BTA_GATT_INCLUDED) && (BTA_GATT_INCLUDED == TRUE) && SDP_INCLUDED == TRUE) && (GATTC_INCLUDED == TRUE)
2685 if ( bta_dm_search_cb.p_btm_inq_info ) {
2686 APPL_TRACE_DEBUG("%s p_btm_inq_info %p results.device_type 0x%x services_to_search 0x%x",
2687 __func__,
2688 bta_dm_search_cb.p_btm_inq_info,
2689 bta_dm_search_cb.p_btm_inq_info->results.device_type,
2690 bta_dm_search_cb.services_to_search);
2691 }
2692
2693 if (transport == BT_TRANSPORT_LE) {
2694 if (bta_dm_search_cb.services_to_search & BTA_BLE_SERVICE_MASK) {
2695 //set the raw data buffer here
2696 memset(g_disc_raw_data_buf, 0, MAX_DISC_RAW_DATA_BUF);
2697 bta_dm_search_cb.p_ble_rawdata = g_disc_raw_data_buf;
2698
2699 bta_dm_search_cb.ble_raw_size = MAX_DISC_RAW_DATA_BUF;
2700 bta_dm_search_cb.ble_raw_used = 0;
2701
2702 /* start GATT for service discovery */
2703 btm_dm_start_gatt_discovery(bta_dm_search_cb.peer_bdaddr);
2704 return;
2705 }
2706 } else
2707 #endif
2708 {
2709 bta_dm_search_cb.sdp_results = FALSE;
2710 bta_dm_find_services(bta_dm_search_cb.peer_bdaddr);
2711 return;
2712 }
2713 }
2714 }
2715
2716 /* name discovery and service discovery are done for this device */
2717 if ((p_msg = (tBTA_DM_MSG *) osi_malloc(sizeof(tBTA_DM_MSG))) != NULL) {
2718 p_msg->hdr.event = BTA_DM_DISCOVERY_RESULT_EVT;
2719 /* initialize the data structure - includes p_raw_data and raw_data_size */
2720 memset(&(p_msg->disc_result.result), 0, sizeof(tBTA_DM_DISC_RES));
2721 p_msg->disc_result.result.disc_res.result = BTA_SUCCESS;
2722 p_msg->disc_result.result.disc_res.services = bta_dm_search_cb.services_found;
2723 bdcpy (p_msg->disc_result.result.disc_res.bd_addr, bta_dm_search_cb.peer_bdaddr);
2724 BCM_STRNCPY_S((char *)p_msg->disc_result.result.disc_res.bd_name, bta_dm_get_remname(), BD_NAME_LEN);
2725 p_msg->disc_result.result.disc_res.bd_name[BD_NAME_LEN] = '\0';
2726
2727 bta_sys_sendmsg(p_msg);
2728 }
2729 }
2730
2731 /*******************************************************************************
2732 **
2733 ** Function bta_dm_sdp_callback
2734 **
2735 ** Description Callback from sdp with discovery status
2736 **
2737 ** Returns void
2738 **
2739 *******************************************************************************/
bta_dm_sdp_callback(UINT16 sdp_status)2740 static void bta_dm_sdp_callback (UINT16 sdp_status)
2741 {
2742
2743 tBTA_DM_SDP_RESULT *p_msg;
2744
2745 if ((p_msg = (tBTA_DM_SDP_RESULT *) osi_malloc(sizeof(tBTA_DM_SDP_RESULT))) != NULL) {
2746 p_msg->hdr.event = BTA_DM_SDP_RESULT_EVT;
2747 p_msg->sdp_result = sdp_status;
2748 bta_sys_sendmsg(p_msg);
2749
2750 }
2751 }
2752 #endif ///SDP_INCLUDED == TRUE
2753 /*******************************************************************************
2754 **
2755 ** Function bta_dm_inq_results_cb
2756 **
2757 ** Description Inquiry results callback from BTM
2758 **
2759 ** Returns void
2760 **
2761 *******************************************************************************/
bta_dm_inq_results_cb(tBTM_INQ_RESULTS * p_inq,UINT8 * p_eir)2762 static void bta_dm_inq_results_cb (tBTM_INQ_RESULTS *p_inq, UINT8 *p_eir)
2763 {
2764
2765 tBTA_DM_SEARCH result;
2766 tBTM_INQ_INFO *p_inq_info;
2767 UINT16 service_class;
2768
2769 bdcpy(result.inq_res.bd_addr, p_inq->remote_bd_addr);
2770 memcpy(result.inq_res.dev_class, p_inq->dev_class, DEV_CLASS_LEN);
2771 BTM_COD_SERVICE_CLASS(service_class, p_inq->dev_class);
2772 result.inq_res.is_limited = (service_class & BTM_COD_SERVICE_LMTD_DISCOVER) ? TRUE : FALSE;
2773 result.inq_res.rssi = p_inq->rssi;
2774
2775 #if (BLE_INCLUDED == TRUE)
2776 result.inq_res.ble_addr_type = p_inq->ble_addr_type;
2777 result.inq_res.inq_result_type = p_inq->inq_result_type;
2778 result.inq_res.device_type = p_inq->device_type;
2779 result.inq_res.flag = p_inq->flag;
2780 #endif
2781
2782 /* application will parse EIR to find out remote device name */
2783 result.inq_res.p_eir = p_eir;
2784
2785 if ((p_inq_info = BTM_InqDbRead(p_inq->remote_bd_addr)) != NULL) {
2786 /* initialize remt_name_not_required to FALSE so that we get the name by default */
2787 result.inq_res.remt_name_not_required = FALSE;
2788
2789 }
2790
2791 if (bta_dm_search_cb.p_search_cback) {
2792 bta_dm_search_cb.p_search_cback(BTA_DM_INQ_RES_EVT, &result);
2793 }
2794
2795 if (p_inq_info) {
2796 /* application indicates if it knows the remote name, inside the callback
2797 copy that to the inquiry data base*/
2798 if (result.inq_res.remt_name_not_required) {
2799 p_inq_info->appl_knows_rem_name = TRUE;
2800 }
2801
2802 }
2803
2804
2805 }
2806
2807
2808 /*******************************************************************************
2809 **
2810 ** Function bta_dm_inq_cmpl_cb
2811 **
2812 ** Description Inquiry complete callback from BTM
2813 **
2814 ** Returns void
2815 **
2816 *******************************************************************************/
bta_dm_inq_cmpl_cb(void * p_result)2817 static void bta_dm_inq_cmpl_cb (void *p_result)
2818 {
2819 tBTA_DM_MSG *p_msg;
2820
2821 if (bta_dm_search_cb.cancel_pending == FALSE) {
2822 APPL_TRACE_DEBUG("%s", __FUNCTION__);
2823 p_msg = (tBTA_DM_MSG *) osi_malloc(sizeof(tBTA_DM_MSG));
2824 if (p_msg != NULL) {
2825 p_msg->inq_cmpl.hdr.event = BTA_DM_INQUIRY_CMPL_EVT;
2826 p_msg->inq_cmpl.num = ((tBTM_INQUIRY_CMPL *)p_result)->num_resp;
2827 bta_sys_sendmsg(p_msg);
2828 }
2829 } else {
2830 bta_dm_search_cb.cancel_pending = FALSE;
2831 bta_dm_search_cancel_notify(NULL);
2832
2833 p_msg = (tBTA_DM_MSG *) osi_malloc(sizeof(tBTA_DM_MSG));
2834 if (p_msg != NULL) {
2835 p_msg->hdr.event = BTA_DM_SEARCH_CMPL_EVT;
2836 p_msg->hdr.layer_specific = BTA_DM_API_DISCOVER_EVT;
2837 bta_sys_sendmsg(p_msg);
2838 }
2839 }
2840 }
2841
2842 /*******************************************************************************
2843 **
2844 ** Function bta_dm_service_search_remname_cback
2845 **
2846 ** Description Remote name call back from BTM during service discovery
2847 **
2848 ** Returns void
2849 **
2850 *******************************************************************************/
bta_dm_service_search_remname_cback(BD_ADDR bd_addr,DEV_CLASS dc,BD_NAME bd_name)2851 static void bta_dm_service_search_remname_cback (BD_ADDR bd_addr, DEV_CLASS dc, BD_NAME bd_name)
2852 {
2853 tBTM_REMOTE_DEV_NAME rem_name;
2854 tBTM_STATUS btm_status;
2855 UNUSED(dc);
2856
2857 APPL_TRACE_DEBUG("bta_dm_service_search_remname_cback name=<%s>", bd_name);
2858
2859 /* if this is what we are looking for */
2860 if (!bdcmp( bta_dm_search_cb.peer_bdaddr, bd_addr)) {
2861 rem_name.length = strlen((char *)bd_name);
2862 if (rem_name.length > BD_NAME_LEN) {
2863 rem_name.length = BD_NAME_LEN;
2864 }
2865 BCM_STRNCPY_S((char *)rem_name.remote_bd_name, (char *)bd_name, BD_NAME_LEN);
2866 rem_name.remote_bd_name[BD_NAME_LEN] = '\0';
2867 rem_name.status = BTM_SUCCESS;
2868
2869 bta_dm_remname_cback(&rem_name);
2870 } else {
2871 /* get name of device */
2872 btm_status = BTM_ReadRemoteDeviceName (bta_dm_search_cb.peer_bdaddr,
2873 (tBTM_CMPL_CB *) bta_dm_remname_cback,
2874 BT_TRANSPORT_BR_EDR);
2875 if ( btm_status == BTM_BUSY ) {
2876 /* wait for next chance(notification of remote name discovery done) */
2877 APPL_TRACE_DEBUG("bta_dm_service_search_remname_cback: BTM_ReadRemoteDeviceName is busy");
2878 } else if ( btm_status != BTM_CMD_STARTED ) {
2879 /* if failed to start getting remote name then continue */
2880 APPL_TRACE_WARNING("bta_dm_service_search_remname_cback: BTM_ReadRemoteDeviceName returns 0x%02X", btm_status);
2881
2882 rem_name.length = 0;
2883 rem_name.remote_bd_name[0] = '\0';
2884 rem_name.status = btm_status;
2885 bta_dm_remname_cback(&rem_name);
2886 }
2887 }
2888 }
2889
2890
2891 /*******************************************************************************
2892 **
2893 ** Function bta_dm_remname_cback
2894 **
2895 ** Description Remote name complete call back from BTM
2896 **
2897 ** Returns void
2898 **
2899 *******************************************************************************/
bta_dm_remname_cback(tBTM_REMOTE_DEV_NAME * p_remote_name)2900 static void bta_dm_remname_cback (tBTM_REMOTE_DEV_NAME *p_remote_name)
2901 {
2902 tBTA_DM_REM_NAME *p_msg;
2903
2904 APPL_TRACE_DEBUG("bta_dm_remname_cback len = %d name=<%s>", p_remote_name->length,
2905 p_remote_name->remote_bd_name);
2906 /* remote name discovery is done but it could be failed */
2907 bta_dm_search_cb.name_discover_done = TRUE;
2908 BCM_STRNCPY_S((char *)bta_dm_search_cb.peer_name, (char *)p_remote_name->remote_bd_name, BD_NAME_LEN);
2909 bta_dm_search_cb.peer_name[BD_NAME_LEN] = '\0';
2910
2911 BTM_SecDeleteRmtNameNotifyCallback(&bta_dm_service_search_remname_cback);
2912
2913 #if BLE_INCLUDED == TRUE && GATTS_INCLUDED == TRUE
2914 if (bta_dm_search_cb.transport == BT_TRANSPORT_LE ) {
2915 GAP_BleReadPeerPrefConnParams (bta_dm_search_cb.peer_bdaddr);
2916 }
2917 #endif
2918
2919 if ((p_msg = (tBTA_DM_REM_NAME *) osi_malloc(sizeof(tBTA_DM_REM_NAME))) != NULL) {
2920 bdcpy (p_msg->result.disc_res.bd_addr, bta_dm_search_cb.peer_bdaddr);
2921 BCM_STRNCPY_S((char *)p_msg->result.disc_res.bd_name, (char *)p_remote_name->remote_bd_name, BD_NAME_LEN);
2922 p_msg->result.disc_res.bd_name[BD_NAME_LEN] = '\0';
2923
2924 p_msg->hdr.event = BTA_DM_REMT_NAME_EVT;
2925 bta_sys_sendmsg(p_msg);
2926 }
2927 }
2928
2929 /*******************************************************************************
2930 **
2931 ** Function bta_dm_authorize_cback
2932 **
2933 ** Description cback requesting authorization
2934 **
2935 ** Returns void
2936 **
2937 *******************************************************************************/
2938 #if (SMP_INCLUDED == TRUE)
bta_dm_authorize_cback(BD_ADDR bd_addr,DEV_CLASS dev_class,BD_NAME bd_name,UINT8 * service_name,UINT8 service_id,BOOLEAN is_originator)2939 static UINT8 bta_dm_authorize_cback (BD_ADDR bd_addr, DEV_CLASS dev_class, BD_NAME bd_name,
2940 UINT8 *service_name, UINT8 service_id, BOOLEAN is_originator)
2941 {
2942 tBTA_DM_SEC sec_event;
2943 UINT8 index = 1;
2944 UNUSED(service_name);
2945 UNUSED(is_originator);
2946
2947 bdcpy(sec_event.authorize.bd_addr, bd_addr);
2948 memcpy(sec_event.authorize.dev_class, dev_class, DEV_CLASS_LEN);
2949
2950 BCM_STRNCPY_S((char *)sec_event.authorize.bd_name, (char *)bd_name, BD_NAME_LEN);
2951 sec_event.authorize.bd_name[BD_NAME_LEN] = '\0';
2952
2953 #if ( defined(BTA_JV_INCLUDED) && BTA_JV_INCLUDED == TRUE )
2954 sec_event.authorize.service = service_id;
2955 #endif
2956
2957 while (index < BTA_MAX_SERVICE_ID) {
2958 /* get the BTA service id corresponding to BTM id */
2959 if (bta_service_id_to_btm_srv_id_lkup_tbl[index] == service_id) {
2960 sec_event.authorize.service = index;
2961 break;
2962 }
2963 index++;
2964 }
2965
2966
2967 /* if supported service callback otherwise not authorized */
2968 if (bta_dm_cb.p_sec_cback && (index < BTA_MAX_SERVICE_ID
2969 #if ( defined(BTA_JV_INCLUDED) && BTA_JV_INCLUDED == TRUE )
2970 /* pass through JV service ID */
2971 || (service_id >= BTA_FIRST_JV_SERVICE_ID && service_id <= BTA_LAST_JV_SERVICE_ID)
2972 #endif
2973 )) {
2974 bta_dm_cb.p_sec_cback(BTA_DM_AUTHORIZE_EVT, &sec_event);
2975 return BTM_CMD_STARTED;
2976 } else {
2977 return BTM_NOT_AUTHORIZED;
2978 }
2979 }
2980
2981
2982 #if (CLASSIC_BT_INCLUDED == TRUE)
2983 #if (BT_SSP_INCLUDED == TRUE)
2984 /*******************************************************************************
2985 **
2986 ** Function bta_dm_pinname_cback
2987 **
2988 ** Description Callback requesting pin_key
2989 **
2990 ** Returns void
2991 **
2992 *******************************************************************************/
bta_dm_pinname_cback(void * p_data)2993 static void bta_dm_pinname_cback (void *p_data)
2994 {
2995 tBTM_REMOTE_DEV_NAME *p_result = (tBTM_REMOTE_DEV_NAME *)p_data;
2996 tBTA_DM_SEC sec_event;
2997 tBTA_DM_SEC_EVT event = bta_dm_cb.pin_evt;
2998
2999 if (BTA_DM_SP_CFM_REQ_EVT == event) {
3000 /* Retrieved saved device class and bd_addr */
3001 bdcpy(sec_event.cfm_req.bd_addr, bta_dm_cb.pin_bd_addr);
3002 BTA_COPY_DEVICE_CLASS(sec_event.cfm_req.dev_class, bta_dm_cb.pin_dev_class);
3003
3004 if (p_result && p_result->status == BTM_SUCCESS) {
3005 BCM_STRNCPY_S((char *)sec_event.cfm_req.bd_name, (char *)p_result->remote_bd_name, BD_NAME_LEN);
3006 sec_event.cfm_req.bd_name[BD_NAME_LEN] = '\0';
3007 } else { /* No name found */
3008 sec_event.cfm_req.bd_name[0] = '\0';
3009 }
3010
3011 sec_event.cfm_req.num_val = bta_dm_cb.num_val; /* get PIN code numeric number */
3012
3013 /* 1 additional event data fields for this event */
3014 sec_event.cfm_req.just_works = bta_dm_cb.just_works;
3015 } else {
3016 /* Retrieved saved device class and bd_addr */
3017 bdcpy(sec_event.pin_req.bd_addr, bta_dm_cb.pin_bd_addr);
3018 BTA_COPY_DEVICE_CLASS(sec_event.pin_req.dev_class, bta_dm_cb.pin_dev_class);
3019
3020 if (p_result && p_result->status == BTM_SUCCESS) {
3021 BCM_STRNCPY_S((char *)sec_event.pin_req.bd_name, (char *)p_result->remote_bd_name, BD_NAME_LEN);
3022 sec_event.pin_req.bd_name[BD_NAME_LEN] = '\0';
3023 } else { /* No name found */
3024 sec_event.pin_req.bd_name[0] = '\0';
3025 }
3026
3027 event = bta_dm_cb.pin_evt;
3028 sec_event.key_notif.passkey = bta_dm_cb.num_val; /* get PIN code numeric number */
3029 }
3030
3031 if ( bta_dm_cb.p_sec_cback ) {
3032 bta_dm_cb.p_sec_cback(event, &sec_event);
3033 }
3034 }
3035 #endif /// BT_SSP_INCLUDED == TRUE
3036
3037 /*******************************************************************************
3038 **
3039 ** Function bta_dm_pin_cback
3040 **
3041 ** Description Callback requesting pin_key
3042 **
3043 ** Returns void
3044 **
3045 *******************************************************************************/
bta_dm_pin_cback(BD_ADDR bd_addr,DEV_CLASS dev_class,BD_NAME bd_name,BOOLEAN min_16_digit)3046 static UINT8 bta_dm_pin_cback (BD_ADDR bd_addr, DEV_CLASS dev_class, BD_NAME bd_name,
3047 BOOLEAN min_16_digit)
3048 {
3049 tBTA_DM_SEC sec_event;
3050
3051 if (!bta_dm_cb.p_sec_cback) {
3052 return BTM_NOT_AUTHORIZED;
3053 }
3054
3055 bdcpy(sec_event.pin_req.bd_addr, bd_addr);
3056 BTA_COPY_DEVICE_CLASS(sec_event.pin_req.dev_class, dev_class);
3057 BCM_STRNCPY_S((char *)sec_event.pin_req.bd_name, (char *)bd_name, BD_NAME_LEN);
3058 sec_event.pin_req.bd_name[BD_NAME_LEN] = '\0';
3059 sec_event.pin_req.min_16_digit = min_16_digit;
3060
3061 bta_dm_cb.p_sec_cback(BTA_DM_PIN_REQ_EVT, &sec_event);
3062 return BTM_CMD_STARTED;
3063 }
3064 #endif ///CLASSIC_BT_INCLUDED == TRUE
3065
3066 /*******************************************************************************
3067 **
3068 ** Function bta_dm_new_link_key_cback
3069 **
3070 ** Description Callback from BTM to notify new link key
3071 **
3072 ** Returns void
3073 **
3074 *******************************************************************************/
bta_dm_new_link_key_cback(BD_ADDR bd_addr,DEV_CLASS dev_class,BD_NAME bd_name,LINK_KEY key,UINT8 key_type,BOOLEAN sc_support)3075 static UINT8 bta_dm_new_link_key_cback(BD_ADDR bd_addr, DEV_CLASS dev_class,
3076 BD_NAME bd_name, LINK_KEY key, UINT8 key_type,
3077 BOOLEAN sc_support)
3078 {
3079 tBTA_DM_SEC sec_event;
3080 tBTA_DM_AUTH_CMPL *p_auth_cmpl;
3081 UINT8 event;
3082 UNUSED(dev_class);
3083
3084 memset (&sec_event, 0, sizeof(tBTA_DM_SEC));
3085
3086 /* Not AMP Key type */
3087 if (key_type != HCI_LKEY_TYPE_AMP_WIFI && key_type != HCI_LKEY_TYPE_AMP_UWB) {
3088 event = BTA_DM_AUTH_CMPL_EVT;
3089 p_auth_cmpl = &sec_event.auth_cmpl;
3090
3091 bdcpy(p_auth_cmpl->bd_addr, bd_addr);
3092
3093 memcpy(p_auth_cmpl->bd_name, bd_name, (BD_NAME_LEN - 1));
3094 p_auth_cmpl->bd_name[BD_NAME_LEN - 1] = 0;
3095
3096 p_auth_cmpl->key_present = TRUE;
3097 p_auth_cmpl->key_type = key_type;
3098 p_auth_cmpl->success = TRUE;
3099 p_auth_cmpl->sc_support = sc_support;
3100
3101 memcpy(p_auth_cmpl->key, key, LINK_KEY_LEN);
3102 sec_event.auth_cmpl.fail_reason = HCI_SUCCESS;
3103
3104 #if BLE_INCLUDED == TRUE
3105 // Report the BR link key based on the BR/EDR address and type
3106 BTM_ReadDevInfo(bd_addr, &sec_event.auth_cmpl.dev_type, &sec_event.auth_cmpl.addr_type);
3107 #endif
3108 if (bta_dm_cb.p_sec_cback) {
3109 bta_dm_cb.p_sec_cback(event, &sec_event);
3110 }
3111 } else {
3112 APPL_TRACE_WARNING("%s() Received AMP Key", __func__);
3113 }
3114
3115 return BTM_CMD_STARTED;
3116 }
3117
3118
3119 /*******************************************************************************
3120 **
3121 ** Function bta_dm_authentication_complete_cback
3122 **
3123 ** Description Authentication complete callback from BTM
3124 **
3125 ** Returns void
3126 **
3127 *******************************************************************************/
bta_dm_authentication_complete_cback(BD_ADDR bd_addr,DEV_CLASS dev_class,BD_NAME bd_name,int result)3128 static UINT8 bta_dm_authentication_complete_cback(BD_ADDR bd_addr, DEV_CLASS dev_class, BD_NAME bd_name, int result)
3129 {
3130 tBTA_DM_SEC sec_event;
3131 UNUSED(dev_class);
3132
3133 if (result != BTM_SUCCESS) {
3134 memset(&sec_event, 0, sizeof(tBTA_DM_SEC));
3135 bdcpy(sec_event.auth_cmpl.bd_addr, bd_addr);
3136
3137 memcpy(sec_event.auth_cmpl.bd_name, bd_name, (BD_NAME_LEN - 1));
3138 sec_event.auth_cmpl.bd_name[BD_NAME_LEN - 1] = 0;
3139
3140 #if BLE_INCLUDED == TRUE
3141 // Report the BR link key based on the BR/EDR address and type
3142 BTM_ReadDevInfo(bd_addr, &sec_event.auth_cmpl.dev_type, &sec_event.auth_cmpl.addr_type);
3143 #endif
3144 sec_event.auth_cmpl.fail_reason = (UINT8)result;
3145
3146 if (bta_dm_cb.p_sec_cback) {
3147 bta_dm_cb.p_sec_cback(BTA_DM_AUTH_CMPL_EVT, &sec_event);
3148 }
3149
3150 if (bta_dm_remove_sec_dev_entry(bd_addr)) {
3151 return BTM_SEC_DEV_REC_REMOVED;
3152 }
3153 }
3154
3155 return BTM_SUCCESS;
3156 }
3157
3158 #if (BT_SSP_INCLUDED == TRUE)
3159 /*******************************************************************************
3160 **
3161 ** Function bta_dm_sp_cback
3162 **
3163 ** Description simple pairing callback from BTM
3164 **
3165 ** Returns void
3166 **
3167 *******************************************************************************/
bta_dm_sp_cback(tBTM_SP_EVT event,tBTM_SP_EVT_DATA * p_data)3168 static UINT8 bta_dm_sp_cback (tBTM_SP_EVT event, tBTM_SP_EVT_DATA *p_data)
3169 {
3170 tBTM_STATUS status = BTM_CMD_STARTED;
3171 tBTA_DM_SEC sec_event;
3172 tBTA_DM_SEC_EVT pin_evt = BTA_DM_SP_KEY_NOTIF_EVT;
3173
3174 APPL_TRACE_EVENT("bta_dm_sp_cback: %d", event);
3175 if (!bta_dm_cb.p_sec_cback) {
3176 return BTM_NOT_AUTHORIZED;
3177 }
3178
3179 /* TODO_SP */
3180 switch (event) {
3181 case BTM_SP_IO_REQ_EVT:
3182 #if (BT_SSP_INCLUDED == TRUE)
3183 /* translate auth_req */
3184 bta_dm_co_io_req(p_data->io_req.bd_addr, &p_data->io_req.io_cap,
3185 &p_data->io_req.oob_data, &p_data->io_req.auth_req, p_data->io_req.is_orig);
3186 #endif
3187 #if BTM_OOB_INCLUDED == FALSE
3188 status = BTM_SUCCESS;
3189 #endif
3190
3191 APPL_TRACE_EVENT("io mitm: %d oob_data:%d", p_data->io_req.auth_req, p_data->io_req.oob_data);
3192 break;
3193 case BTM_SP_IO_RSP_EVT:
3194 #if (BT_SSP_INCLUDED == TRUE)
3195 bta_dm_co_io_rsp(p_data->io_rsp.bd_addr, p_data->io_rsp.io_cap,
3196 p_data->io_rsp.oob_data, p_data->io_rsp.auth_req );
3197 #endif
3198 break;
3199
3200 case BTM_SP_CFM_REQ_EVT:
3201 pin_evt = BTA_DM_SP_CFM_REQ_EVT;
3202 bta_dm_cb.just_works = sec_event.cfm_req.just_works = p_data->cfm_req.just_works;
3203 sec_event.cfm_req.loc_auth_req = p_data->cfm_req.loc_auth_req;
3204 sec_event.cfm_req.rmt_auth_req = p_data->cfm_req.rmt_auth_req;
3205 sec_event.cfm_req.loc_io_caps = p_data->cfm_req.loc_io_caps;
3206 sec_event.cfm_req.rmt_io_caps = p_data->cfm_req.rmt_io_caps;
3207
3208 /* continue to next case */
3209 #if (BT_SSP_INCLUDED == TRUE)
3210 /* Passkey entry mode, mobile device with output capability is very
3211 unlikely to receive key request, so skip this event */
3212 case BTM_SP_KEY_REQ_EVT:
3213 case BTM_SP_KEY_NOTIF_EVT:
3214 #endif
3215 if (BTM_SP_CFM_REQ_EVT == event) {
3216 /* Due to the switch case falling through below to BTM_SP_KEY_NOTIF_EVT,
3217 call remote name request using values from cfm_req */
3218 if (p_data->cfm_req.bd_name[0] == 0) {
3219 bta_dm_cb.pin_evt = pin_evt;
3220 bdcpy(bta_dm_cb.pin_bd_addr, p_data->cfm_req.bd_addr);
3221 BTA_COPY_DEVICE_CLASS(bta_dm_cb.pin_dev_class, p_data->cfm_req.dev_class);
3222 if ((BTM_ReadRemoteDeviceName(p_data->cfm_req.bd_addr, bta_dm_pinname_cback,
3223 BT_TRANSPORT_BR_EDR)) == BTM_CMD_STARTED) {
3224 return BTM_CMD_STARTED;
3225 }
3226 APPL_TRACE_WARNING(" bta_dm_sp_cback() -> Failed to start Remote Name Request ");
3227 } else {
3228 /* Due to the switch case falling through below to BTM_SP_KEY_NOTIF_EVT,
3229 copy these values into key_notif from cfm_req */
3230 bdcpy(sec_event.key_notif.bd_addr, p_data->cfm_req.bd_addr);
3231 BTA_COPY_DEVICE_CLASS(sec_event.key_notif.dev_class, p_data->cfm_req.dev_class);
3232 BCM_STRNCPY_S((char *)sec_event.key_notif.bd_name, (char *)p_data->cfm_req.bd_name, BD_NAME_LEN);
3233 sec_event.key_notif.bd_name[BD_NAME_LEN] = '\0';
3234 }
3235 }
3236
3237 bta_dm_cb.num_val = sec_event.key_notif.passkey = p_data->key_notif.passkey;
3238 if (BTM_SP_KEY_NOTIF_EVT == event) {
3239 /* If the device name is not known, save bdaddr and devclass
3240 and initiate a name request with values from key_notif */
3241 if (p_data->key_notif.bd_name[0] == 0) {
3242 bta_dm_cb.pin_evt = pin_evt;
3243 bdcpy(bta_dm_cb.pin_bd_addr, p_data->key_notif.bd_addr);
3244 BTA_COPY_DEVICE_CLASS(bta_dm_cb.pin_dev_class, p_data->key_notif.dev_class);
3245 if ((BTM_ReadRemoteDeviceName(p_data->key_notif.bd_addr, bta_dm_pinname_cback,
3246 BT_TRANSPORT_BR_EDR)) == BTM_CMD_STARTED) {
3247 return BTM_CMD_STARTED;
3248 }
3249 APPL_TRACE_WARNING(" bta_dm_sp_cback() -> Failed to start Remote Name Request ");
3250 } else {
3251 bdcpy(sec_event.key_notif.bd_addr, p_data->key_notif.bd_addr);
3252 BTA_COPY_DEVICE_CLASS(sec_event.key_notif.dev_class, p_data->key_notif.dev_class);
3253 BCM_STRNCPY_S((char *)sec_event.key_notif.bd_name, (char *)p_data->key_notif.bd_name, BD_NAME_LEN);
3254 sec_event.key_notif.bd_name[BD_NAME_LEN] = '\0';
3255 }
3256 }
3257
3258 if (BTM_SP_KEY_REQ_EVT == event) {
3259 pin_evt = BTA_DM_SP_KEY_REQ_EVT;
3260 /* If the device name is not known, save bdaddr and devclass
3261 and initiate a name request with values from key_notif */
3262 if (p_data->key_notif.bd_name[0] == 0) {
3263 bta_dm_cb.pin_evt = pin_evt;
3264 bdcpy(bta_dm_cb.pin_bd_addr, p_data->key_notif.bd_addr);
3265 BTA_COPY_DEVICE_CLASS(bta_dm_cb.pin_dev_class, p_data->key_notif.dev_class);
3266 if ((BTM_ReadRemoteDeviceName(p_data->key_notif.bd_addr, bta_dm_pinname_cback,
3267 BT_TRANSPORT_BR_EDR)) == BTM_CMD_STARTED) {
3268 return BTM_CMD_STARTED;
3269 }
3270 APPL_TRACE_WARNING(" bta_dm_sp_cback() -> Failed to start Remote Name Request ");
3271 } else {
3272 bdcpy(sec_event.key_notif.bd_addr, p_data->key_notif.bd_addr);
3273 BTA_COPY_DEVICE_CLASS(sec_event.key_notif.dev_class, p_data->key_notif.dev_class);
3274 BCM_STRNCPY_S((char *)sec_event.key_notif.bd_name,(char *)p_data->key_notif.bd_name, BD_NAME_LEN);
3275 sec_event.key_notif.bd_name[BD_NAME_LEN] = '\0';
3276 }
3277 }
3278 bta_dm_cb.p_sec_cback(pin_evt, &sec_event);
3279
3280 break;
3281
3282 #if BTM_OOB_INCLUDED == TRUE
3283 case BTM_SP_LOC_OOB_EVT:
3284 bta_dm_co_loc_oob((BOOLEAN)(p_data->loc_oob.status == BTM_SUCCESS),
3285 p_data->loc_oob.c, p_data->loc_oob.r);
3286 break;
3287
3288 case BTM_SP_RMT_OOB_EVT:
3289 /* If the device name is not known, save bdaddr and devclass and initiate a name request */
3290 if (p_data->rmt_oob.bd_name[0] == 0) {
3291 bta_dm_cb.pin_evt = BTA_DM_SP_RMT_OOB_EVT;
3292 bdcpy(bta_dm_cb.pin_bd_addr, p_data->rmt_oob.bd_addr);
3293 BTA_COPY_DEVICE_CLASS(bta_dm_cb.pin_dev_class, p_data->rmt_oob.dev_class);
3294 if ((BTM_ReadRemoteDeviceName(p_data->rmt_oob.bd_addr, bta_dm_pinname_cback,
3295 BT_TRANSPORT_BR_EDR)) == BTM_CMD_STARTED) {
3296 return BTM_CMD_STARTED;
3297 }
3298 APPL_TRACE_WARNING(" bta_dm_sp_cback() -> Failed to start Remote Name Request ");
3299 }
3300
3301 bdcpy(sec_event.rmt_oob.bd_addr, p_data->rmt_oob.bd_addr);
3302 BTA_COPY_DEVICE_CLASS(sec_event.rmt_oob.dev_class, p_data->rmt_oob.dev_class);
3303 BCM_STRNCPY_S((char *)sec_event.rmt_oob.bd_name, (char *)p_data->rmt_oob.bd_name, BD_NAME_LEN);
3304 sec_event.rmt_oob.bd_name[BD_NAME_LEN] = '\0';
3305
3306 bta_dm_cb.p_sec_cback(BTA_DM_SP_RMT_OOB_EVT, &sec_event);
3307
3308 bta_dm_co_rmt_oob(p_data->rmt_oob.bd_addr);
3309 break;
3310 #endif
3311 case BTM_SP_COMPLT_EVT:
3312 /* do not report this event - handled by link_key_callback or auth_complete_callback */
3313 break;
3314
3315 case BTM_SP_KEYPRESS_EVT:
3316 memcpy(&sec_event.key_press, &p_data->key_press, sizeof(tBTM_SP_KEYPRESS));
3317 bta_dm_cb.p_sec_cback(BTA_DM_SP_KEYPRESS_EVT, &sec_event);
3318 break;
3319
3320 case BTM_SP_UPGRADE_EVT:
3321 bta_dm_co_lk_upgrade(p_data->upgrade.bd_addr, &p_data->upgrade.upgrade );
3322 break;
3323
3324 default:
3325 status = BTM_NOT_AUTHORIZED;
3326 break;
3327 }
3328 APPL_TRACE_EVENT("dm status: %d", status);
3329 return status;
3330 }
3331 #endif /* (BT_SSP_INCLUDED == TRUE) */
3332
3333 #endif ///SMP_INCLUDED == TRUE
3334
3335
3336 /*******************************************************************************
3337 **
3338 ** Function bta_dm_local_name_cback
3339 **
3340 ** Description Callback from btm after local name is read
3341 **
3342 **
3343 ** Returns void
3344 **
3345 *******************************************************************************/
bta_dm_local_name_cback(const BD_ADDR bd_addr)3346 static void bta_dm_local_name_cback(const BD_ADDR bd_addr)
3347 {
3348 tBTA_DM_SEC sec_event;
3349 UNUSED(bd_addr);
3350
3351 sec_event.enable.status = BTA_SUCCESS;
3352
3353 if (bta_dm_cb.p_sec_cback) {
3354 bta_dm_cb.p_sec_cback(BTA_DM_ENABLE_EVT, &sec_event);
3355 }
3356
3357 }
3358
3359 /*******************************************************************************
3360 **
3361 ** Function bta_dm_bl_change_cback
3362 **
3363 ** Description Callback from btm when acl connection goes up or down
3364 **
3365 **
3366 ** Returns void
3367 **
3368 *******************************************************************************/
bta_dm_bl_change_cback(tBTM_BL_EVENT_DATA * p_data)3369 static void bta_dm_bl_change_cback (tBTM_BL_EVENT_DATA *p_data)
3370 {
3371 tBTA_DM_ACL_CHANGE *p_msg;
3372
3373 if ((p_msg = (tBTA_DM_ACL_CHANGE *) osi_malloc(sizeof(tBTA_DM_ACL_CHANGE))) != NULL) {
3374 p_msg->event = p_data->event;
3375 p_msg->is_new = FALSE;
3376
3377 switch (p_msg->event) {
3378 case BTM_BL_CONN_EVT:
3379 p_msg->sc_downgrade = p_data->conn.sc_downgrade;
3380 p_msg->is_new = TRUE;
3381 bdcpy(p_msg->bd_addr, p_data->conn.p_bda);
3382 #if BLE_INCLUDED == TRUE
3383 p_msg->transport = p_data->conn.transport;
3384 p_msg->handle = p_data->conn.handle;
3385 #endif
3386 break;
3387 case BTM_BL_DISCN_EVT:
3388 bdcpy(p_msg->bd_addr, p_data->discn.p_bda);
3389 #if BLE_INCLUDED == TRUE
3390 p_msg->transport = p_data->discn.transport;
3391 p_msg->handle = p_data->discn.handle;
3392 #endif
3393 break;
3394 case BTM_BL_UPDATE_EVT:
3395 p_msg->busy_level = p_data->update.busy_level;
3396 p_msg->busy_level_flags = p_data->update.busy_level_flags;
3397 break;
3398 case BTM_BL_ROLE_CHG_EVT:
3399 p_msg->new_role = p_data->role_chg.new_role;
3400 p_msg->hci_status = p_data->role_chg.hci_status;
3401 bdcpy(p_msg->bd_addr, p_data->role_chg.p_bda);
3402 break;
3403 case BTM_BL_COLLISION_EVT:
3404 bdcpy(p_msg->bd_addr, p_data->conn.p_bda);
3405 break;
3406 }
3407
3408 p_msg->hdr.event = BTA_DM_ACL_CHANGE_EVT;
3409 bta_sys_sendmsg(p_msg);
3410
3411 }
3412
3413 }
3414
3415 /*******************************************************************************
3416 **
3417 ** Function bta_dm_acl_link_stat_cback
3418 **
3419 ** Description Callback from btm to report acl link status
3420 **
3421 ** Returns void
3422 **
3423 *******************************************************************************/
bta_dm_acl_link_stat_cback(tBTM_ACL_LINK_STAT_EVENT_DATA * p_data)3424 static void bta_dm_acl_link_stat_cback(tBTM_ACL_LINK_STAT_EVENT_DATA *p_data)
3425 {
3426 tBTA_DM_SEC sec_event;
3427 memset(&sec_event, 0, sizeof(tBTA_DM_SEC));
3428 sec_event.acl_link_stat.event = p_data->event;
3429
3430 switch (sec_event.acl_link_stat.event) {
3431 case BTA_ACL_LINK_STAT_CONN_CMPL: {
3432 sec_event.acl_link_stat.link_act.conn_cmpl.status = p_data->link_act.conn_cmpl.status;
3433 sec_event.acl_link_stat.link_act.conn_cmpl.handle = p_data->link_act.conn_cmpl.handle;
3434 bdcpy(sec_event.acl_link_stat.link_act.conn_cmpl.bd_addr, p_data->link_act.conn_cmpl.bd_addr);
3435 break;
3436 }
3437 case BTA_ACL_LINK_STAT_DISCONN_CMPL: {
3438 sec_event.acl_link_stat.link_act.disconn_cmpl.reason = p_data->link_act.disconn_cmpl.reason;
3439 sec_event.acl_link_stat.link_act.disconn_cmpl.handle = p_data->link_act.disconn_cmpl.handle;
3440 bdcpy(sec_event.acl_link_stat.link_act.disconn_cmpl.bd_addr, p_data->link_act.disconn_cmpl.bd_addr);
3441 break;
3442 }
3443 default: {
3444 APPL_TRACE_WARNING("bta_dm_acl_link_stat: invalid event %d", sec_event.acl_link_stat.event);
3445 return;
3446 }
3447 }
3448
3449 if (bta_dm_cb.p_sec_cback) {
3450 (*bta_dm_cb.p_sec_cback)(BTA_DM_ACL_LINK_STAT_EVT, &sec_event);
3451 }
3452 }
3453
3454 /*******************************************************************************
3455 **
3456 ** Function bta_dm_rs_cback
3457 **
3458 ** Description Receives the role switch complete event
3459 **
3460 ** Returns
3461 **
3462 *******************************************************************************/
bta_dm_rs_cback(tBTM_ROLE_SWITCH_CMPL * p1)3463 static void bta_dm_rs_cback (tBTM_ROLE_SWITCH_CMPL *p1)
3464 {
3465 UNUSED(p1);
3466 APPL_TRACE_WARNING("bta_dm_rs_cback:%d", bta_dm_cb.rs_event);
3467 if (bta_dm_cb.rs_event == BTA_DM_API_SEARCH_EVT) {
3468 bta_dm_cb.search_msg.rs_res = BTA_DM_RS_OK; /* do not care about the result for now */
3469 bta_dm_cb.rs_event = 0;
3470 bta_dm_search_start((tBTA_DM_MSG *)&bta_dm_cb.search_msg);
3471 }
3472 }
3473
3474 /*******************************************************************************
3475 **
3476 ** Function bta_dm_check_av
3477 **
3478 ** Description This function checks if AV is active
3479 ** if yes, make sure the AV link is master
3480 **
3481 ** Returns BOOLEAN - TRUE, if switch is in progress
3482 **
3483 *******************************************************************************/
bta_dm_check_av(UINT16 event)3484 static BOOLEAN bta_dm_check_av(UINT16 event)
3485 {
3486 BOOLEAN avoid_roleswitch = FALSE;
3487 BOOLEAN switching = FALSE;
3488 UINT8 i;
3489 tBTA_DM_PEER_DEVICE *p_dev;
3490
3491 #if defined(BTA_DM_AVOID_A2DP_ROLESWITCH_ON_INQUIRY) && (BTA_DM_AVOID_A2DP_ROLESWITCH_ON_INQUIRY == TRUE)
3492
3493 /* avoid role switch upon inquiry if a2dp is actively streaming as it
3494 introduces an audioglitch due to FW scheduling delays (unavoidable) */
3495 if (event == BTA_DM_API_SEARCH_EVT) {
3496 avoid_roleswitch = TRUE;
3497 }
3498 #endif
3499
3500 APPL_TRACE_EVENT("bta_dm_check_av:%d", bta_dm_cb.cur_av_count);
3501 if (bta_dm_cb.cur_av_count) {
3502 for (i = 0; i < bta_dm_cb.device_list.count; i++) {
3503 p_dev = &bta_dm_cb.device_list.peer_device[i];
3504 APPL_TRACE_WARNING("[%d]: state:%d, info:x%x, avoid_rs %d",
3505 i, p_dev->conn_state, p_dev->info, avoid_roleswitch);
3506 if ((p_dev->conn_state == BTA_DM_CONNECTED) && (p_dev->info & BTA_DM_DI_AV_ACTIVE) &&
3507 (avoid_roleswitch == FALSE)) {
3508 /* make master and take away the role switch policy */
3509 if (BTM_CMD_STARTED == BTM_SwitchRole (p_dev->peer_bdaddr, HCI_ROLE_MASTER, (tBTM_CMPL_CB *)bta_dm_rs_cback)) {
3510 /* the role switch command is actually sent */
3511 bta_dm_cb.rs_event = event;
3512 switching = TRUE;
3513 }
3514 /* else either already master or can not switch for some reasons */
3515 bta_dm_policy_cback(BTA_SYS_PLCY_CLR, 0, HCI_ENABLE_MASTER_SLAVE_SWITCH, p_dev->peer_bdaddr);
3516 break;
3517 }
3518 }
3519 }
3520 return switching;
3521 }
3522
3523 /*******************************************************************************
3524 **
3525 ** Function bta_dm_acl_change
3526 **
3527 ** Description Process BTA_DM_ACL_CHANGE_EVT
3528 **
3529 **
3530 ** Returns void
3531 **
3532 *******************************************************************************/
bta_dm_acl_change(tBTA_DM_MSG * p_data)3533 void bta_dm_acl_change(tBTA_DM_MSG *p_data)
3534 {
3535
3536 UINT8 i;
3537 UINT8 *p;
3538 tBTA_DM_SEC conn;
3539 BOOLEAN is_new = p_data->acl_change.is_new;
3540 BD_ADDR_PTR p_bda = p_data->acl_change.bd_addr;
3541 BOOLEAN need_policy_change = FALSE;
3542 BOOLEAN issue_unpair_cb = FALSE;
3543
3544 tBTA_DM_PEER_DEVICE *p_dev;
3545 memset(&conn, 0, sizeof(tBTA_DM_SEC));
3546
3547 switch (p_data->acl_change.event) {
3548 case BTM_BL_UPDATE_EVT: /* busy level update */
3549 if ( bta_dm_cb.p_sec_cback ) {
3550 conn.busy_level.level = p_data->acl_change.busy_level;
3551 conn.busy_level.level_flags = p_data->acl_change.busy_level_flags;
3552 bta_dm_cb.p_sec_cback(BTA_DM_BUSY_LEVEL_EVT, &conn);
3553 }
3554 return;
3555
3556 case BTM_BL_ROLE_CHG_EVT: /* role change event */
3557 p_dev = bta_dm_find_peer_device(p_bda);
3558 if (p_dev) {
3559 APPL_TRACE_DEBUG("bta_dm_acl_change role chg info:x%x new_role:%d dev count:%d",
3560 p_dev->info, p_data->acl_change.new_role, bta_dm_cb.device_list.count);
3561 if (p_dev->info & BTA_DM_DI_AV_ACTIVE) {
3562 /* there's AV activity on this link */
3563 if (p_data->acl_change.new_role == HCI_ROLE_SLAVE && bta_dm_cb.device_list.count > 1
3564 && p_data->acl_change.hci_status == HCI_SUCCESS) {
3565 /* more than one connections and the AV connection is role switched to slave
3566 * switch it back to master and remove the switch policy */
3567 BTM_SwitchRole(p_bda, BTM_ROLE_MASTER, NULL);
3568 need_policy_change = TRUE;
3569 } else if (p_bta_dm_cfg->avoid_scatter && (p_data->acl_change.new_role == HCI_ROLE_MASTER)) {
3570 /* if the link updated to be master include AV activities, remove the switch policy */
3571 need_policy_change = TRUE;
3572 }
3573
3574 if (need_policy_change) {
3575 bta_dm_policy_cback(BTA_SYS_PLCY_CLR, 0, HCI_ENABLE_MASTER_SLAVE_SWITCH, p_dev->peer_bdaddr);
3576 }
3577 } else {
3578 /* there's AV no activity on this link and role switch happened
3579 * check if AV is active
3580 * if so, make sure the AV link is master */
3581 bta_dm_check_av(0);
3582 }
3583 bta_sys_notify_role_chg(p_data->acl_change.bd_addr, p_data->acl_change.new_role, p_data->acl_change.hci_status);
3584 bdcpy(conn.role_chg.bd_addr, p_bda);
3585 conn.role_chg.new_role = (UINT8) p_data->acl_change.new_role;
3586 if ( bta_dm_cb.p_sec_cback ) {
3587 bta_dm_cb.p_sec_cback(BTA_DM_ROLE_CHG_EVT, (tBTA_DM_SEC *)&conn);
3588 }
3589 }
3590 return;
3591 }
3592
3593 /* Collision report from Stack: Notify profiles */
3594 if (p_data->acl_change.event == BTM_BL_COLLISION_EVT) {
3595 bta_sys_notify_collision (p_bda);
3596 return;
3597 }
3598
3599 if (is_new) {
3600 for (i = 0; i < bta_dm_cb.device_list.count; i++) {
3601 if (!bdcmp( bta_dm_cb.device_list.peer_device[i].peer_bdaddr, p_bda)
3602 #if BLE_INCLUDED == TRUE
3603 && bta_dm_cb.device_list.peer_device[i].conn_handle == p_data->acl_change.handle
3604 #endif
3605 ) {
3606 break;
3607 }
3608
3609 }
3610
3611 if (i == bta_dm_cb.device_list.count) {
3612 if (bta_dm_cb.device_list.count < BTA_DM_NUM_PEER_DEVICE) {
3613 bdcpy(bta_dm_cb.device_list.peer_device[bta_dm_cb.device_list.count].peer_bdaddr, p_bda);
3614 bta_dm_cb.device_list.peer_device[bta_dm_cb.device_list.count].link_policy = bta_dm_cb.cur_policy;
3615 bta_dm_cb.device_list.count++;
3616 #if BLE_INCLUDED == TRUE
3617 bta_dm_cb.device_list.peer_device[i].conn_handle = p_data->acl_change.handle;
3618 if (p_data->acl_change.transport == BT_TRANSPORT_LE) {
3619 bta_dm_cb.device_list.le_count++;
3620 }
3621 #endif
3622 } else {
3623 APPL_TRACE_ERROR("%s max active connection reached, no resources", __func__);
3624 return;
3625 }
3626 }
3627
3628 bta_dm_cb.device_list.peer_device[i].conn_state = BTA_DM_CONNECTED;
3629 bta_dm_cb.device_list.peer_device[i].pref_role = BTA_ANY_ROLE;
3630 bdcpy(conn.link_up.bd_addr, p_bda);
3631 bta_dm_cb.device_list.peer_device[i].info = BTA_DM_DI_NONE;
3632 #if BLE_INCLUDED == TRUE
3633 conn.link_up.link_type = p_data->acl_change.transport;
3634 bta_dm_cb.device_list.peer_device[i].transport = p_data->acl_change.transport;
3635 #endif
3636
3637 if (((NULL != (p = BTM_ReadLocalFeatures ())) && HCI_SNIFF_SUB_RATE_SUPPORTED(p)) &&
3638 ((NULL != (p = BTM_ReadRemoteFeatures (p_bda))) && HCI_SNIFF_SUB_RATE_SUPPORTED(p))) {
3639 /* both local and remote devices support SSR */
3640 bta_dm_cb.device_list.peer_device[i].info = BTA_DM_DI_USE_SSR;
3641 }
3642 APPL_TRACE_DEBUG("%s info: 0x%x", __func__, bta_dm_cb.device_list.peer_device[i].info);
3643
3644 if (bta_dm_cb.p_sec_cback) {
3645 conn.link_up.sc_downgrade = p_data->acl_change.sc_downgrade;
3646 bta_dm_cb.p_sec_cback(BTA_DM_LINK_UP_EVT, (tBTA_DM_SEC *)&conn);
3647 }
3648 } else {
3649 for (i = 0; i < bta_dm_cb.device_list.count; i++) {
3650 if (bdcmp( bta_dm_cb.device_list.peer_device[i].peer_bdaddr, p_bda)
3651 #if BLE_INCLUDED == TRUE
3652 || bta_dm_cb.device_list.peer_device[i].transport != p_data->acl_change.transport
3653 #endif
3654 ) {
3655 continue;
3656 }
3657
3658 if ( bta_dm_cb.device_list.peer_device[i].conn_state == BTA_DM_UNPAIRING ) {
3659 if (BTM_SecDeleteDevice(bta_dm_cb.device_list.peer_device[i].peer_bdaddr, bta_dm_cb.device_list.peer_device[i].transport)) {
3660 issue_unpair_cb = TRUE;
3661 }
3662
3663 APPL_TRACE_DEBUG("%s: Unpairing: issue unpair CB = %d ", __FUNCTION__, issue_unpair_cb);
3664 }
3665
3666 conn.link_down.is_removed = bta_dm_cb.device_list.peer_device[i].remove_dev_pending;
3667
3668 for (; i < bta_dm_cb.device_list.count ; i++) {
3669 memcpy(&bta_dm_cb.device_list.peer_device[i], &bta_dm_cb.device_list.peer_device[i + 1], sizeof(bta_dm_cb.device_list.peer_device[i]));
3670 }
3671 break;
3672 }
3673 if (bta_dm_cb.device_list.count) {
3674 bta_dm_cb.device_list.count--;
3675 }
3676 #if BLE_INCLUDED == TRUE
3677 if ((p_data->acl_change.transport == BT_TRANSPORT_LE) &&
3678 (bta_dm_cb.device_list.le_count)) {
3679 bta_dm_cb.device_list.le_count--;
3680 }
3681 conn.link_down.link_type = p_data->acl_change.transport;
3682 #endif
3683
3684 if (bta_dm_search_cb.wait_disc && !bdcmp(bta_dm_search_cb.peer_bdaddr, p_bda)) {
3685 bta_dm_search_cb.wait_disc = FALSE;
3686
3687 if (bta_dm_search_cb.sdp_results) {
3688 APPL_TRACE_EVENT(" timer stopped ");
3689 bta_sys_stop_timer(&bta_dm_search_cb.search_timer);
3690 bta_dm_discover_next_device();
3691 }
3692
3693 }
3694
3695 if (bta_dm_cb.disabling) {
3696 if (!BTM_GetNumAclLinks()) {
3697 bta_sys_stop_timer(&bta_dm_cb.disable_timer);
3698 bta_dm_cb.disable_timer.p_cback = (TIMER_CBACK *)&bta_dm_disable_conn_down_timer_cback;
3699 /*
3700 * Start a timer to make sure that the profiles
3701 * get the disconnect event.
3702 */
3703 bta_sys_start_timer(&bta_dm_cb.disable_timer, 0, 1000);
3704 }
3705 }
3706 if (conn.link_down.is_removed) {
3707 BTM_SecDeleteDevice(p_bda, p_data->acl_change.transport);
3708 #if (BLE_INCLUDED == TRUE && GATTC_INCLUDED == TRUE)
3709 /* need to remove all pending background connection */
3710 BTA_GATTC_CancelOpen(0, p_bda, FALSE);
3711 #endif
3712 }
3713
3714 bdcpy(conn.link_down.bd_addr, p_bda);
3715 conn.link_down.reason = (UINT8) btm_get_acl_disc_reason_code();
3716 if ( bta_dm_cb.p_sec_cback ) {
3717 bta_dm_cb.p_sec_cback(BTA_DM_LINK_DOWN_EVT, &conn);
3718 if ( issue_unpair_cb ) {
3719 if (p_data->acl_change.transport == BT_TRANSPORT_LE) {
3720 bta_dm_cb.p_sec_cback(BTA_DM_BLE_DEV_UNPAIRED_EVT, &conn);
3721 } else {
3722 bta_dm_cb.p_sec_cback(BTA_DM_DEV_UNPAIRED_EVT, &conn);
3723 }
3724 }
3725 }
3726 }
3727
3728 bta_dm_adjust_roles(TRUE);
3729 }
3730
3731 /*******************************************************************************
3732 **
3733 ** Function bta_dm_disable_conn_down_timer_cback
3734 **
3735 ** Description Sends disable event to application
3736 **
3737 **
3738 ** Returns void
3739 **
3740 *******************************************************************************/
bta_dm_disable_conn_down_timer_cback(TIMER_LIST_ENT * p_tle)3741 static void bta_dm_disable_conn_down_timer_cback (TIMER_LIST_ENT *p_tle)
3742 {
3743 UNUSED(p_tle);
3744 tBTA_SYS_HW_MSG *sys_enable_event;
3745
3746 #if (BTA_DM_PM_INCLUDED == TRUE)
3747 /* disable the power management module */
3748 bta_dm_disable_pm();
3749 #endif /* #if (BTA_DM_PM_INCLUDED == TRUE) */
3750
3751 /* register our callback to SYS HW manager */
3752 bta_sys_hw_register( BTA_SYS_HW_BLUETOOTH, bta_dm_sys_hw_cback );
3753
3754 /* send a message to BTA SYS */
3755 if ((sys_enable_event = (tBTA_SYS_HW_MSG *) osi_malloc(sizeof(tBTA_SYS_HW_MSG))) != NULL) {
3756 sys_enable_event->hdr.event = BTA_SYS_API_DISABLE_EVT;
3757 sys_enable_event->hw_module = BTA_SYS_HW_BLUETOOTH;
3758 bta_sys_sendmsg(sys_enable_event);
3759 }
3760
3761 bta_dm_cb.disabling = FALSE;
3762
3763 }
3764
3765 /*******************************************************************************
3766 **
3767 ** Function bta_dm_rm_cback
3768 **
3769 ** Description Role management callback from sys
3770 **
3771 **
3772 ** Returns void
3773 **
3774 *******************************************************************************/
bta_dm_rm_cback(tBTA_SYS_CONN_STATUS status,UINT8 id,UINT8 app_id,BD_ADDR peer_addr)3775 static void bta_dm_rm_cback(tBTA_SYS_CONN_STATUS status, UINT8 id, UINT8 app_id, BD_ADDR peer_addr)
3776 {
3777 UINT8 j;
3778 tBTA_PREF_ROLES role;
3779 tBTA_DM_PEER_DEVICE *p_dev;
3780
3781 p_dev = bta_dm_find_peer_device(peer_addr);
3782 if ( status == BTA_SYS_CONN_OPEN) {
3783 if (p_dev) {
3784 /* Do not set to connected if we are in the middle of unpairing. When AV stream is
3785 * started it fakes out a SYS_CONN_OPEN to potentially trigger a role switch command.
3786 * But this should not be done if we are in the middle of unpairing.
3787 */
3788 if (p_dev->conn_state != BTA_DM_UNPAIRING) {
3789 p_dev->conn_state = BTA_DM_CONNECTED;
3790 }
3791
3792 for (j = 1; j <= p_bta_dm_rm_cfg[0].app_id; j++) {
3793 if (((p_bta_dm_rm_cfg[j].app_id == app_id) || (p_bta_dm_rm_cfg[j].app_id == BTA_ALL_APP_ID))
3794 && (p_bta_dm_rm_cfg[j].id == id)) {
3795 role = p_bta_dm_rm_cfg[j].cfg;
3796
3797 if (role > p_dev->pref_role ) {
3798 p_dev->pref_role = role;
3799 }
3800 break;
3801 }
3802 }
3803 }
3804 }
3805
3806 if ((BTA_ID_AV == id) || (BTA_ID_AVK == id)) {
3807 if ( status == BTA_SYS_CONN_BUSY) {
3808 if (p_dev) {
3809 p_dev->info |= BTA_DM_DI_AV_ACTIVE;
3810 }
3811 /* AV calls bta_sys_conn_open with the A2DP stream count as app_id */
3812 if (BTA_ID_AV == id) {
3813 bta_dm_cb.cur_av_count = bta_dm_get_av_count();
3814 }
3815 } else if ( status == BTA_SYS_CONN_IDLE) {
3816 if (p_dev) {
3817 p_dev->info &= ~BTA_DM_DI_AV_ACTIVE;
3818 }
3819
3820 /* get cur_av_count from connected services */
3821 if (BTA_ID_AV == id) {
3822 bta_dm_cb.cur_av_count = bta_dm_get_av_count();
3823 }
3824 }
3825 APPL_TRACE_EVENT("bta_dm_rm_cback:%d, status:%d", bta_dm_cb.cur_av_count, status);
3826 }
3827
3828 /* Don't adjust roles for each busy/idle state transition to avoid
3829 excessive switch requests when individual profile busy/idle status
3830 changes */
3831 if ((status != BTA_SYS_CONN_BUSY) && (status != BTA_SYS_CONN_IDLE)) {
3832 bta_dm_adjust_roles(FALSE);
3833 }
3834 }
3835
3836 /*******************************************************************************
3837 **
3838 ** Function bta_dm_delay_role_switch_cback
3839 **
3840 ** Description Callback from btm to delay a role switch
3841 **
3842 ** Returns void
3843 **
3844 *******************************************************************************/
bta_dm_delay_role_switch_cback(TIMER_LIST_ENT * p_tle)3845 static void bta_dm_delay_role_switch_cback(TIMER_LIST_ENT *p_tle)
3846 {
3847 UNUSED(p_tle);
3848 APPL_TRACE_EVENT("bta_dm_delay_role_switch_cback: initiating Delayed RS");
3849 bta_dm_adjust_roles (FALSE);
3850 }
3851
3852 /*******************************************************************************
3853 **
3854 ** Function bta_dm_remove_sec_dev_entry
3855 **
3856 ** Description Removes device entry from Security device DB if ACL connection with
3857 ** remtoe device does not exist, else schedule for dev entry removal upon
3858 ACL close
3859 **
3860 ** Returns TRUE if device entry is removed from Security device DB, FALSE otherwise
3861 **
3862 *******************************************************************************/
3863 #if (SMP_INCLUDED == TRUE)
bta_dm_remove_sec_dev_entry(BD_ADDR remote_bd_addr)3864 static BOOLEAN bta_dm_remove_sec_dev_entry(BD_ADDR remote_bd_addr)
3865 {
3866 BOOLEAN is_device_deleted = FALSE;
3867 UINT16 index = 0;
3868 if ( BTM_IsAclConnectionUp(remote_bd_addr, BT_TRANSPORT_LE) ||
3869 BTM_IsAclConnectionUp(remote_bd_addr, BT_TRANSPORT_BR_EDR)) {
3870 APPL_TRACE_DEBUG("%s ACL is not down. Schedule for Dev Removal when ACL closes",
3871 __FUNCTION__);
3872 BTM_SecClearSecurityFlags (remote_bd_addr);
3873 for (index = 0; index < bta_dm_cb.device_list.count; index ++) {
3874 if (!bdcmp( bta_dm_cb.device_list.peer_device[index].peer_bdaddr, remote_bd_addr)) {
3875 break;
3876 }
3877 }
3878 if (index != bta_dm_cb.device_list.count) {
3879 bta_dm_cb.device_list.peer_device[index].remove_dev_pending = TRUE;
3880 } else {
3881 APPL_TRACE_ERROR(" %s Device does not exist in DB", __FUNCTION__);
3882 }
3883 } else {
3884 is_device_deleted = BTM_SecDeleteDevice (remote_bd_addr, bta_dm_cb.device_list.peer_device[index].transport);
3885 #if (BLE_INCLUDED == TRUE && GATTC_INCLUDED == TRUE)
3886 /* need to remove all pending background connection */
3887 BTA_GATTC_CancelOpen(0, remote_bd_addr, FALSE);
3888 #endif
3889 }
3890 return is_device_deleted;
3891 }
3892 #endif ///SMP_INCLUDED == TRUE
3893
3894
3895 /*******************************************************************************
3896 **
3897 ** Function bta_dm_adjust_roles
3898 **
3899 ** Description Adjust roles
3900 **
3901 **
3902 ** Returns void
3903 **
3904 *******************************************************************************/
bta_dm_adjust_roles(BOOLEAN delay_role_switch)3905 static void bta_dm_adjust_roles(BOOLEAN delay_role_switch)
3906 {
3907
3908 UINT8 i;
3909 BOOLEAN set_master_role = FALSE;
3910 #if BLE_INCLUDED == TRUE
3911 UINT8 br_count = bta_dm_cb.device_list.count - bta_dm_cb.device_list.le_count;
3912 #else
3913 UINT8 br_count = bta_dm_cb.device_list.count;
3914 #endif
3915 if (br_count) {
3916
3917 /* the configuration is no scatternet
3918 * or AV connection exists and there are more than one ACL link */
3919 if ( (p_bta_dm_rm_cfg[0].cfg == BTA_DM_NO_SCATTERNET) ||
3920 (bta_dm_cb.cur_av_count && br_count > 1) ) {
3921
3922 L2CA_SetDesireRole (HCI_ROLE_MASTER);
3923 set_master_role = TRUE;
3924
3925 }
3926
3927 for (i = 0; i < bta_dm_cb.device_list.count; i++) {
3928 if (bta_dm_cb.device_list.peer_device[i].conn_state == BTA_DM_CONNECTED
3929 #if BLE_INCLUDED == TRUE
3930 && bta_dm_cb.device_list.peer_device[i].transport == BT_TRANSPORT_BR_EDR
3931 #endif
3932 ) {
3933 if (!set_master_role && (bta_dm_cb.device_list.peer_device[i].pref_role != BTA_ANY_ROLE)
3934 && (p_bta_dm_rm_cfg[0].cfg == BTA_DM_PARTIAL_SCATTERNET)) {
3935 L2CA_SetDesireRole (HCI_ROLE_MASTER);
3936 set_master_role = TRUE;
3937 }
3938
3939 if ((bta_dm_cb.device_list.peer_device[i].pref_role == BTA_MASTER_ROLE_ONLY)
3940 || (br_count > 1)) {
3941
3942 /* Initiating immediate role switch with certain remote devices
3943 has caused issues due to role switch colliding with link encryption setup and
3944 causing encryption (and in turn the link) to fail . These device . Firmware
3945 versions are stored in a blacklist and role switch with these devices are
3946 delayed to avoid the collision with link encryption setup */
3947
3948 if (bta_dm_cb.device_list.peer_device[i].pref_role != BTA_SLAVE_ROLE_ONLY &&
3949 delay_role_switch == FALSE) {
3950 BTM_SwitchRole (bta_dm_cb.device_list.peer_device[i].peer_bdaddr,
3951 HCI_ROLE_MASTER, NULL);
3952 } else {
3953 bta_dm_cb.switch_delay_timer[i].p_cback =
3954 (TIMER_CBACK *)&bta_dm_delay_role_switch_cback;
3955 /* Start the timer if not active */
3956 if (!bta_sys_timer_is_active(&bta_dm_cb.switch_delay_timer[i])) {
3957 bta_sys_start_timer(&bta_dm_cb.switch_delay_timer[i], 0, 500);
3958 }
3959 }
3960 }
3961
3962 }
3963 }
3964
3965
3966 if (!set_master_role) {
3967
3968 L2CA_SetDesireRole (L2CAP_DESIRED_LINK_ROLE);
3969
3970 }
3971
3972 } else {
3973 L2CA_SetDesireRole (L2CAP_DESIRED_LINK_ROLE);
3974 }
3975
3976
3977 }
3978
3979 /*******************************************************************************
3980 **
3981 ** Function bta_dm_get_remname
3982 **
3983 ** Description Returns a pointer to the remote name stored in the DM control
3984 ** block if it exists, or from the BTM memory.
3985 **
3986 ** Returns char * - Pointer to the remote device name
3987 *******************************************************************************/
3988 #if (SDP_INCLUDED == TRUE || SMP_INCLUDED == TRUE)
bta_dm_get_remname(void)3989 static char *bta_dm_get_remname(void)
3990 {
3991 char *p_name = (char *)bta_dm_search_cb.peer_name;
3992 char *p_temp;
3993
3994 /* If the name isn't already stored, try retrieving from BTM */
3995 if (*p_name == '\0') {
3996 if ((p_temp = BTM_SecReadDevName(bta_dm_search_cb.peer_bdaddr)) != NULL) {
3997 p_name = p_temp;
3998 }
3999 }
4000 return p_name;
4001 }
4002 #endif ///SDP_INCLUDED == TRUE || SMP_INCLUDED == TRUE
4003
4004 /*******************************************************************************
4005 **
4006 ** Function bta_dm_bond_cancel_complete_cback
4007 **
4008 ** Description Authentication complete callback from BTM
4009 **
4010 ** Returns void
4011 **
4012 *******************************************************************************/
4013 #if (SMP_INCLUDED == TRUE)
bta_dm_bond_cancel_complete_cback(tBTM_STATUS result)4014 static void bta_dm_bond_cancel_complete_cback(tBTM_STATUS result)
4015 {
4016
4017 tBTA_DM_SEC sec_event;
4018
4019 if (result == BTM_SUCCESS) {
4020 sec_event.bond_cancel_cmpl.result = BTA_SUCCESS;
4021 } else {
4022 sec_event.bond_cancel_cmpl.result = BTA_FAILURE;
4023 }
4024
4025 if (bta_dm_cb.p_sec_cback) {
4026 bta_dm_cb.p_sec_cback(BTA_DM_BOND_CANCEL_CMPL_EVT, &sec_event);
4027 }
4028 }
4029 #endif ///SMP_INCLUDED == TRUE
4030
4031 /*******************************************************************************
4032 **
4033 ** Function bta_dm_set_eir
4034 **
4035 ** Description This function creates EIR tagged data and writes it to controller.
4036 **
4037 ** Returns None
4038 **
4039 *******************************************************************************/
4040 #if (CLASSIC_BT_INCLUDED == TRUE)
bta_dm_set_eir(char * local_name)4041 static void bta_dm_set_eir (char *local_name)
4042 {
4043 BT_HDR *p_buf;
4044 UINT8 *p;
4045 UINT8 *p_length;
4046 #if (BTA_EIR_CANNED_UUID_LIST != TRUE)
4047 UINT8 *p_type;
4048 UINT8 max_num_uuid;
4049 #if (BTA_EIR_SERVER_NUM_CUSTOM_UUID > 0)
4050 UINT8 custom_uuid_idx;
4051 #endif // BTA_EIR_SERVER_NUM_CUSTOM_UUID
4052 #endif // BTA_EIR_CANNED_UUID_LIST
4053
4054 UINT8 free_eir_length;
4055 if (p_bta_dm_eir_cfg->bta_dm_eir_fec_required) {
4056 free_eir_length = HCI_DM5_PACKET_SIZE;
4057 } else {
4058 free_eir_length = HCI_EXT_INQ_RESPONSE_LEN;
4059 }
4060
4061 UINT8 num_uuid;
4062 UINT8 data_type;
4063 UINT8 local_name_len;
4064
4065 UINT8 eir_type[BTM_EIR_TYPE_MAX_NUM];
4066 UINT8 eir_type_num = 0;
4067
4068 tBTA_STATUS status = BTA_SUCCESS;
4069
4070 /* wait until complete to disable */
4071 if (bta_dm_cb.disable_timer.in_use) {
4072 if (p_bta_dm_eir_cfg->config_eir_callback) {
4073 p_bta_dm_eir_cfg->config_eir_callback(BTA_WRONG_MODE, eir_type_num , eir_type);
4074 }
4075 return;
4076 }
4077
4078 #if ( BTA_EIR_CANNED_UUID_LIST != TRUE )
4079 /* wait until App is ready */
4080 if (bta_dm_cb.app_ready_timer.in_use) {
4081 if (p_bta_dm_eir_cfg->config_eir_callback) {
4082 p_bta_dm_eir_cfg->config_eir_callback(BTA_WRONG_MODE, eir_type_num , eir_type);
4083 }
4084 return;
4085 }
4086 #endif // BTA_EIR_CANNED_UUID_LIST
4087
4088 if (p_bta_dm_eir_cfg->bta_dm_eir_included_name) {
4089 /* if local name is not provided, get it from controller */
4090 if ( local_name == NULL ) {
4091 if ( BTM_ReadLocalDeviceName( &local_name ) != BTM_SUCCESS ) {
4092 APPL_TRACE_ERROR("Fail to read local device name for EIR");
4093 }
4094 }
4095 } else {
4096 local_name = NULL;
4097 }
4098
4099
4100 /* Allocate a buffer to hold HCI command */
4101 if ((p_buf = (BT_HDR *)osi_malloc(BTM_CMD_BUF_SIZE)) == NULL) {
4102 APPL_TRACE_ERROR("bta_dm_set_eir couldn't allocate buffer");
4103 if (p_bta_dm_eir_cfg->config_eir_callback) {
4104 p_bta_dm_eir_cfg->config_eir_callback(BTA_NO_RESOURCES, eir_type_num , eir_type);
4105 }
4106 return;
4107 }
4108 p = (UINT8 *)p_buf + BTM_HCI_EIR_OFFSET;
4109
4110 memset(p, 0x00, HCI_EXT_INQ_RESPONSE_LEN );
4111
4112 APPL_TRACE_DEBUG("BTA is generating EIR");
4113
4114 if ( local_name ) {
4115 local_name_len = strlen( local_name );
4116 } else {
4117 local_name_len = 0;
4118 }
4119
4120 data_type = BTM_EIR_COMPLETE_LOCAL_NAME_TYPE;
4121 /* if local name is longer than minimum length of shortened name */
4122 /* check whether it needs to be shortened or not */
4123 if ( local_name_len > p_bta_dm_eir_cfg->bta_dm_eir_min_name_len ) {
4124 /* get number of UUID 16-bit list */
4125 #if (BTA_EIR_CANNED_UUID_LIST == TRUE)
4126 num_uuid = p_bta_dm_eir_cfg->bta_dm_eir_uuid16_len / LEN_UUID_16;
4127 #else // BTA_EIR_CANNED_UUID_LIST
4128 max_num_uuid = (free_eir_length - 2) / LEN_UUID_16;
4129 data_type = BTM_GetEirSupportedServices( bta_dm_cb.eir_uuid, &p,
4130 max_num_uuid, &num_uuid );
4131 p = (UINT8 *)p_buf + BTM_HCI_EIR_OFFSET; /* reset p */
4132 #endif // BTA_EIR_CANNED_UUID_LIST
4133
4134 /* if UUID doesn't fit remaining space, shorten local name */
4135 if ( local_name_len > (free_eir_length - 4 - num_uuid * LEN_UUID_16)) {
4136 APPL_TRACE_WARNING("BTA EIR: local name is shortened");
4137 local_name_len = p_bta_dm_eir_cfg->bta_dm_eir_min_name_len;
4138 data_type = BTM_EIR_SHORTENED_LOCAL_NAME_TYPE;
4139 } else {
4140 data_type = BTM_EIR_COMPLETE_LOCAL_NAME_TYPE;
4141 }
4142 }
4143
4144
4145
4146 if (local_name != NULL) {
4147 UINT8_TO_STREAM(p, local_name_len + 1);
4148 UINT8_TO_STREAM(p, data_type);
4149 eir_type[eir_type_num++] = data_type;
4150 memcpy(p, local_name, local_name_len);
4151 p += local_name_len;
4152 free_eir_length -= local_name_len + 2;
4153 }
4154
4155 /* if UUIDs are provided in configuration */
4156 if (p_bta_dm_eir_cfg->bta_dm_eir_included_uuid) {
4157 #if (BTA_EIR_CANNED_UUID_LIST == TRUE)
4158 /* if UUID list is provided as static data in configuration */
4159 if (( p_bta_dm_eir_cfg->bta_dm_eir_uuid16_len > 0 )
4160 && (p_bta_dm_eir_cfg->bta_dm_eir_uuid16)) {
4161 if ( free_eir_length > LEN_UUID_16 + 2) {
4162 free_eir_length -= 2;
4163
4164 if ( free_eir_length >= p_bta_dm_eir_cfg->bta_dm_eir_uuid16_len) {
4165 num_uuid = p_bta_dm_eir_cfg->bta_dm_eir_uuid16_len / LEN_UUID_16;
4166 data_type = BTM_EIR_COMPLETE_16BITS_UUID_TYPE;
4167 } else { /* not enough room for all UUIDs */
4168 APPL_TRACE_WARNING("BTA EIR: UUID 16-bit list is truncated");
4169 num_uuid = free_eir_length / LEN_UUID_16;
4170 data_type = BTM_EIR_MORE_16BITS_UUID_TYPE;
4171 }
4172 UINT8_TO_STREAM(p, num_uuid * LEN_UUID_16 + 1);
4173 UINT8_TO_STREAM(p, data_type);
4174 eir_type[eir_type_num++] = data_type;
4175 memcpy(p, p_bta_dm_eir_cfg->bta_dm_eir_uuid16, num_uuid * LEN_UUID_16 );
4176 p += num_uuid * LEN_UUID_16;
4177 free_eir_length -= num_uuid * LEN_UUID_16;
4178 } else {
4179 status = BTA_EIR_TOO_LARGE;
4180 }
4181 }
4182 #else /* (BTA_EIR_CANNED_UUID_LIST == TRUE) */
4183 /* if UUID list is dynamic */
4184 if ( free_eir_length >= 2) {
4185 p_length = p++;
4186 p_type = p++;
4187 num_uuid = 0;
4188
4189 max_num_uuid = (free_eir_length - 2) / LEN_UUID_16;
4190 data_type = BTM_GetEirSupportedServices( bta_dm_cb.eir_uuid, &p, max_num_uuid, &num_uuid );
4191
4192 if ( data_type == BTM_EIR_MORE_16BITS_UUID_TYPE ) {
4193 APPL_TRACE_WARNING("BTA EIR: UUID 16-bit list is truncated");
4194 }
4195 #if (BTA_EIR_SERVER_NUM_CUSTOM_UUID > 0)
4196 else {
4197 for (custom_uuid_idx = 0; custom_uuid_idx < BTA_EIR_SERVER_NUM_CUSTOM_UUID; custom_uuid_idx++) {
4198 if (bta_dm_cb.custom_uuid[custom_uuid_idx].len == LEN_UUID_16) {
4199 if ( num_uuid < max_num_uuid ) {
4200 UINT16_TO_STREAM(p, bta_dm_cb.custom_uuid[custom_uuid_idx].uu.uuid16);
4201 num_uuid++;
4202 } else {
4203 data_type = BTM_EIR_MORE_16BITS_UUID_TYPE;
4204 APPL_TRACE_WARNING("BTA EIR: UUID 16-bit list is truncated");
4205 break;
4206 }
4207 }
4208 }
4209 }
4210 #endif /* (BTA_EIR_SERVER_NUM_CUSTOM_UUID > 0) */
4211
4212 UINT8_TO_STREAM(p_length, num_uuid * LEN_UUID_16 + 1);
4213 UINT8_TO_STREAM(p_type, data_type);
4214 eir_type[eir_type_num++] = data_type;
4215 free_eir_length -= num_uuid * LEN_UUID_16 + 2;
4216 } else {
4217 status = BTA_EIR_TOO_LARGE;
4218 }
4219 #endif /* (BTA_EIR_CANNED_UUID_LIST == TRUE) */
4220
4221 #if ( BTA_EIR_CANNED_UUID_LIST != TRUE )&&(BTA_EIR_SERVER_NUM_CUSTOM_UUID > 0)
4222 /* Adding 32-bit UUID list */
4223 if ( free_eir_length >= 2) {
4224 p_length = p++;
4225 p_type = p++;
4226 num_uuid = 0;
4227 data_type = BTM_EIR_COMPLETE_32BITS_UUID_TYPE;
4228
4229 max_num_uuid = (free_eir_length - 2) / LEN_UUID_32;
4230
4231 for (custom_uuid_idx = 0; custom_uuid_idx < BTA_EIR_SERVER_NUM_CUSTOM_UUID; custom_uuid_idx++) {
4232 if (bta_dm_cb.custom_uuid[custom_uuid_idx].len == LEN_UUID_32) {
4233 if ( num_uuid < max_num_uuid ) {
4234 UINT32_TO_STREAM(p, bta_dm_cb.custom_uuid[custom_uuid_idx].uu.uuid32);
4235 num_uuid++;
4236 } else {
4237 data_type = BTM_EIR_MORE_32BITS_UUID_TYPE;
4238 APPL_TRACE_WARNING("BTA EIR: UUID 32-bit list is truncated");
4239 break;
4240 }
4241 }
4242 }
4243
4244 UINT8_TO_STREAM(p_length, num_uuid * LEN_UUID_32 + 1);
4245 UINT8_TO_STREAM(p_type, data_type);
4246 eir_type[eir_type_num++] = data_type;
4247 free_eir_length -= num_uuid * LEN_UUID_32 + 2;
4248 } else {
4249 status = BTA_EIR_TOO_LARGE;
4250 }
4251
4252 /* Adding 128-bit UUID list */
4253 if ( free_eir_length >= 2) {
4254 p_length = p++;
4255 p_type = p++;
4256 num_uuid = 0;
4257 data_type = BTM_EIR_COMPLETE_128BITS_UUID_TYPE;
4258
4259 max_num_uuid = (free_eir_length - 2) / LEN_UUID_128;
4260
4261 for (custom_uuid_idx = 0; custom_uuid_idx < BTA_EIR_SERVER_NUM_CUSTOM_UUID; custom_uuid_idx++) {
4262 if (bta_dm_cb.custom_uuid[custom_uuid_idx].len == LEN_UUID_128) {
4263 if ( num_uuid < max_num_uuid ) {
4264 ARRAY_TO_STREAM(p, bta_dm_cb.custom_uuid[custom_uuid_idx].uu.uuid128, LEN_UUID_128);
4265 num_uuid++;
4266 } else {
4267 data_type = BTM_EIR_MORE_128BITS_UUID_TYPE;
4268 APPL_TRACE_WARNING("BTA EIR: UUID 128-bit list is truncated");
4269 break;
4270 }
4271 }
4272 }
4273
4274 UINT8_TO_STREAM(p_length, num_uuid * LEN_UUID_128 + 1);
4275 UINT8_TO_STREAM(p_type, data_type);
4276 eir_type[eir_type_num++] = data_type;
4277 free_eir_length -= num_uuid * LEN_UUID_128 + 2;
4278 }
4279 else {
4280 status = BTA_EIR_TOO_LARGE;
4281 }
4282 #endif /* ( BTA_EIR_CANNED_UUID_LIST != TRUE )&&(BTA_EIR_SERVER_NUM_CUSTOM_UUID > 0) */
4283 }
4284
4285 /* if Flags are provided in configuration */
4286 if ( p_bta_dm_eir_cfg->bta_dm_eir_flags != 0 ) {
4287 if ( free_eir_length >= 3 ) {
4288 UINT8_TO_STREAM(p, 2);
4289 UINT8_TO_STREAM(p, BTM_EIR_FLAGS_TYPE);
4290 eir_type[eir_type_num++] = BTM_EIR_FLAGS_TYPE;
4291 UINT8_TO_STREAM(p, p_bta_dm_eir_cfg->bta_dm_eir_flags);
4292 free_eir_length -= 3;
4293 } else {
4294 status = BTA_EIR_TOO_LARGE;
4295 }
4296 }
4297
4298 /* if Manufacturer Specific are provided in configuration */
4299 if (( p_bta_dm_eir_cfg->bta_dm_eir_manufac_spec_len > 0 )
4300 && ( p_bta_dm_eir_cfg->bta_dm_eir_manufac_spec )) {
4301 if ( free_eir_length >= p_bta_dm_eir_cfg->bta_dm_eir_manufac_spec_len + 2) {
4302 p_length = p;
4303
4304 UINT8_TO_STREAM(p, p_bta_dm_eir_cfg->bta_dm_eir_manufac_spec_len + 1);
4305 UINT8_TO_STREAM(p, BTM_EIR_MANUFACTURER_SPECIFIC_TYPE);
4306 eir_type[eir_type_num++] = BTM_EIR_MANUFACTURER_SPECIFIC_TYPE;
4307 memcpy(p, p_bta_dm_eir_cfg->bta_dm_eir_manufac_spec,
4308 p_bta_dm_eir_cfg->bta_dm_eir_manufac_spec_len);
4309 p += p_bta_dm_eir_cfg->bta_dm_eir_manufac_spec_len;
4310 free_eir_length -= p_bta_dm_eir_cfg->bta_dm_eir_manufac_spec_len + 2;
4311 } else {
4312 status = BTA_EIR_TOO_LARGE;
4313 }
4314 } else {
4315 p_length = NULL;
4316 }
4317
4318 /* if Inquiry Tx Resp Power compiled */
4319 if (p_bta_dm_eir_cfg->bta_dm_eir_included_tx_power) {
4320 if (free_eir_length >= 3) {
4321 int min_power_level, max_power_level;
4322 if (bredr_txpwr_get(&min_power_level, &max_power_level) == 0) {
4323 INT8 btm_tx_power[BTM_TX_POWER_LEVEL_MAX + 1] = BTM_TX_POWER;
4324 p_bta_dm_eir_cfg->bta_dm_eir_inq_tx_power = btm_tx_power[max_power_level];
4325 UINT8_TO_STREAM(p, 2); /* Length field */
4326 UINT8_TO_STREAM(p, BTM_EIR_TX_POWER_LEVEL_TYPE);
4327 eir_type[eir_type_num++] = BTM_EIR_TX_POWER_LEVEL_TYPE;
4328 UINT8_TO_STREAM(p, p_bta_dm_eir_cfg->bta_dm_eir_inq_tx_power);
4329 free_eir_length -= 3;
4330 }
4331 } else {
4332 status = BTA_EIR_TOO_LARGE;
4333 }
4334 }
4335
4336 /* if URL are provided in configuration */
4337 if (( p_bta_dm_eir_cfg->bta_dm_eir_url_len > 0 )
4338 && ( p_bta_dm_eir_cfg->bta_dm_eir_url )) {
4339 if ( free_eir_length >= p_bta_dm_eir_cfg->bta_dm_eir_url_len + 2 ) {
4340 UINT8_TO_STREAM(p, p_bta_dm_eir_cfg->bta_dm_eir_url_len + 1);
4341 UINT8_TO_STREAM(p, BTM_EIR_URL_TYPE);
4342 eir_type[eir_type_num++] = BTM_EIR_URL_TYPE;
4343 memcpy(p, p_bta_dm_eir_cfg->bta_dm_eir_url,
4344 p_bta_dm_eir_cfg->bta_dm_eir_url_len);
4345 p += p_bta_dm_eir_cfg->bta_dm_eir_url_len;
4346 free_eir_length -= p_bta_dm_eir_cfg->bta_dm_eir_url_len + 2;
4347 } else {
4348 status = BTA_EIR_TOO_LARGE;
4349 }
4350 }
4351
4352 /* If there is no other data to be sent in the EIR packet, the Host shall
4353 * send a name tag with zero length and the type field set to indicate
4354 * that this is the complete name (i.e., total of 2 octets with length =
4355 * 1).
4356 */
4357 if (eir_type_num == 0) {
4358 UINT8_TO_STREAM(p, 1);
4359 UINT8_TO_STREAM(p, BTM_EIR_COMPLETE_LOCAL_NAME_TYPE);
4360 free_eir_length -= 2;
4361 }
4362
4363 if (free_eir_length) {
4364 UINT8_TO_STREAM(p, 0); /* terminator of significant part */
4365 }
4366
4367 tBTM_STATUS btm_status = BTM_WriteEIR( p_buf, p_bta_dm_eir_cfg->bta_dm_eir_fec_required );
4368
4369 if (btm_status == BTM_MODE_UNSUPPORTED) {
4370 status = BTA_WRONG_MODE;
4371 } else if (btm_status != BTM_SUCCESS) {
4372 status = BTA_FAILURE;
4373 }
4374
4375 if (p_bta_dm_eir_cfg->config_eir_callback) {
4376 p_bta_dm_eir_cfg->config_eir_callback(status, eir_type_num, eir_type);
4377 }
4378 }
4379 #endif
4380
4381 /*******************************************************************************
4382 **
4383 ** Function bta_dm_eir_search_services
4384 **
4385 ** Description This function searches services in received EIR
4386 **
4387 ** Returns None
4388 **
4389 *******************************************************************************/
4390 #if (SDP_INCLUDED == TRUE)
bta_dm_eir_search_services(tBTM_INQ_RESULTS * p_result,tBTA_SERVICE_MASK * p_services_to_search,tBTA_SERVICE_MASK * p_services_found)4391 static void bta_dm_eir_search_services( tBTM_INQ_RESULTS *p_result,
4392 tBTA_SERVICE_MASK *p_services_to_search,
4393 tBTA_SERVICE_MASK *p_services_found)
4394 {
4395 tBTA_SERVICE_MASK service_index = 0;
4396 tBTM_EIR_SEARCH_RESULT result;
4397
4398 APPL_TRACE_DEBUG("BTA searching services in EIR of BDA:0x%02X%02X%02X%02X%02X%02X",
4399 p_result->remote_bd_addr[0], p_result->remote_bd_addr[1],
4400 p_result->remote_bd_addr[2], p_result->remote_bd_addr[3],
4401 p_result->remote_bd_addr[4], p_result->remote_bd_addr[5]);
4402
4403 APPL_TRACE_DEBUG(" with services_to_search=0x%08X", *p_services_to_search);
4404
4405 #if BLE_INCLUDED == TRUE && BTA_GATT_INCLUDED == TRUE
4406 /* always do GATT based service discovery by SDP instead of from EIR */
4407 /* if GATT based service is also to be put in EIR, need to modify this */
4408 while (service_index < (BTA_MAX_SERVICE_ID - 1))
4409 #else
4410 while (service_index < BTA_MAX_SERVICE_ID)
4411 #endif
4412 {
4413 if ( *p_services_to_search
4414 & (tBTA_SERVICE_MASK)(BTA_SERVICE_ID_TO_SERVICE_MASK(service_index))) {
4415 result = BTM_HasInquiryEirService( p_result,
4416 bta_service_id_to_uuid_lkup_tbl[service_index] );
4417
4418 /* Searching for HSP v1.2 only device */
4419 if ((result != BTM_EIR_FOUND) &&
4420 (bta_service_id_to_uuid_lkup_tbl[service_index] == UUID_SERVCLASS_HEADSET)) {
4421 result = BTM_HasInquiryEirService (p_result, UUID_SERVCLASS_HEADSET_HS);
4422 }
4423
4424 if ( result == BTM_EIR_FOUND ) {
4425 /* If Plug and Play service record, need to check to see if Broadcom stack */
4426 /* However, EIR data doesn't have EXT_BRCM_VERSION so just skip it */
4427 if ( bta_service_id_to_uuid_lkup_tbl[service_index]
4428 != UUID_SERVCLASS_PNP_INFORMATION ) {
4429
4430 *p_services_found |=
4431 (tBTA_SERVICE_MASK)(BTA_SERVICE_ID_TO_SERVICE_MASK(service_index));
4432 /* remove the service from services to be searched */
4433 *p_services_to_search &=
4434 (tBTA_SERVICE_MASK)(~(BTA_SERVICE_ID_TO_SERVICE_MASK(service_index)));
4435 }
4436 } else if ( result == BTM_EIR_NOT_FOUND ) {
4437 /* remove the service from services to be searched */
4438 *p_services_to_search &=
4439 (tBTA_SERVICE_MASK)(~(BTA_SERVICE_ID_TO_SERVICE_MASK(service_index)));
4440 }
4441 }
4442
4443 service_index++;
4444 }
4445
4446 APPL_TRACE_ERROR("BTA EIR search result, services_to_search=0x%08X, services_found=0x%08X",
4447 *p_services_to_search, *p_services_found);
4448 }
4449 #endif ///SDP_INCLUDED == TRUE
4450
4451 #if (BTA_EIR_CANNED_UUID_LIST != TRUE)
4452 /*******************************************************************************
4453 **
4454 ** Function bta_dm_eir_update_uuid
4455 **
4456 ** Description This function adds or removes service UUID in EIR database.
4457 **
4458 ** Returns None
4459 **
4460 *******************************************************************************/
bta_dm_eir_update_uuid(tBT_UUID uuid,BOOLEAN adding)4461 void bta_dm_eir_update_uuid(tBT_UUID uuid, BOOLEAN adding)
4462 {
4463 /* 32 and 128-bit UUIDs go to the bta_dm_cb.custom_uuid array */
4464 if ((uuid.len == LEN_UUID_32) || (uuid.len == LEN_UUID_128)) {
4465 if (adding) {
4466 if (BTM_HasCustomEirService(bta_dm_cb.custom_uuid, uuid)) {
4467 APPL_TRACE_EVENT("UUID is already added for EIR");
4468 return;
4469 }
4470 APPL_TRACE_EVENT("Adding %d-bit UUID into EIR", uuid.len * 8);
4471
4472 BTM_AddCustomEirService(bta_dm_cb.custom_uuid, uuid);
4473 } else {
4474 APPL_TRACE_EVENT("Removing %d-bit UUID from EIR", uuid.len * 8);
4475
4476 BTM_RemoveCustomEirService(bta_dm_cb.custom_uuid, uuid);
4477 }
4478 } else {
4479 /* if this UUID is not advertised in EIR */
4480 if (!BTM_HasEirService(p_bta_dm_eir_cfg->uuid_mask, uuid.uu.uuid16)) {
4481 return;
4482 }
4483
4484 if (adding) {
4485 APPL_TRACE_EVENT("Adding UUID=0x%04X into EIR", uuid.uu.uuid16);
4486
4487 BTM_AddEirService(bta_dm_cb.eir_uuid, uuid.uu.uuid16);
4488 } else {
4489 APPL_TRACE_EVENT("Removing UUID=0x%04X from EIR", uuid.uu.uuid16);
4490
4491 BTM_RemoveEirService(bta_dm_cb.eir_uuid, uuid.uu.uuid16);
4492 }
4493 }
4494 #if CLASSIC_BT_INCLUDED
4495 bta_dm_set_eir (NULL);
4496 #endif
4497
4498 APPL_TRACE_EVENT("bta_dm_eir_update_uuid UUID bit mask=0x%08X %08X",
4499 bta_dm_cb.eir_uuid[1], bta_dm_cb.eir_uuid[0] );
4500 }
4501 #endif
4502
4503 /*******************************************************************************
4504 **
4505 ** Function bta_dm_enable_test_mode
4506 **
4507 ** Description enable test mode
4508 **
4509 **
4510 ** Returns void
4511 **
4512 *******************************************************************************/
bta_dm_enable_test_mode(tBTA_DM_MSG * p_data)4513 void bta_dm_enable_test_mode(tBTA_DM_MSG *p_data)
4514 {
4515 UNUSED(p_data);
4516 BTM_EnableTestMode();
4517 }
4518
4519 /*******************************************************************************
4520 **
4521 ** Function bta_dm_disable_test_mode
4522 **
4523 ** Description disable test mode
4524 **
4525 **
4526 ** Returns void
4527 **
4528 *******************************************************************************/
bta_dm_disable_test_mode(tBTA_DM_MSG * p_data)4529 void bta_dm_disable_test_mode(tBTA_DM_MSG *p_data)
4530 {
4531 UNUSED(p_data);
4532 BTM_DeviceReset(NULL);
4533 }
4534
4535 /*******************************************************************************
4536 **
4537 ** Function bta_dm_execute_callback
4538 **
4539 ** Description Just execute a generic call back in the context of the BTU/BTA tack
4540 **
4541 **
4542 ** Returns void
4543 **
4544 *******************************************************************************/
bta_dm_execute_callback(tBTA_DM_MSG * p_data)4545 void bta_dm_execute_callback(tBTA_DM_MSG *p_data)
4546 {
4547 /* sanity check */
4548 if (p_data->exec_cback.p_exec_cback == NULL) {
4549 return;
4550 }
4551
4552 p_data->exec_cback.p_exec_cback(p_data->exec_cback.p_param);
4553 }
4554
4555 /*******************************************************************************
4556 **
4557 ** Function bta_dm_encrypt_cback
4558 **
4559 ** Description link encryption complete callback.
4560 **
4561 ** Returns None
4562 **
4563 *******************************************************************************/
bta_dm_encrypt_cback(BD_ADDR bd_addr,tBT_TRANSPORT transport,void * p_ref_data,tBTM_STATUS result)4564 void bta_dm_encrypt_cback(BD_ADDR bd_addr, tBT_TRANSPORT transport, void *p_ref_data, tBTM_STATUS result)
4565 {
4566 tBTA_STATUS bta_status = BTA_SUCCESS;
4567 tBTA_DM_ENCRYPT_CBACK *p_callback = NULL;
4568 UINT8 i ;
4569 UNUSED(p_ref_data);
4570
4571 for (i = 0; i < bta_dm_cb.device_list.count; i++) {
4572 if (bdcmp( bta_dm_cb.device_list.peer_device[i].peer_bdaddr, bd_addr) == 0 &&
4573 bta_dm_cb.device_list.peer_device[i].conn_state == BTA_DM_CONNECTED) {
4574 break;
4575 }
4576 }
4577
4578 if (i < bta_dm_cb.device_list.count) {
4579 p_callback = bta_dm_cb.device_list.peer_device[i].p_encrypt_cback;
4580 bta_dm_cb.device_list.peer_device[i].p_encrypt_cback = NULL;
4581 }
4582
4583 switch (result) {
4584 case BTM_SUCCESS:
4585 break;
4586 case BTM_WRONG_MODE:
4587 bta_status = BTA_WRONG_MODE;
4588 break;
4589 case BTM_NO_RESOURCES:
4590 bta_status = BTA_NO_RESOURCES;
4591 break;
4592 case BTM_BUSY:
4593 bta_status = BTA_BUSY;
4594 break;
4595 default:
4596 bta_status = BTA_FAILURE;
4597 break;
4598 }
4599
4600 APPL_TRACE_DEBUG("bta_dm_encrypt_cback status =%d p_callback=%p", bta_status, p_callback);
4601
4602 if (p_callback) {
4603 (*p_callback)(bd_addr, transport, bta_status);
4604 }
4605 }
4606
4607 /*******************************************************************************
4608 **
4609 ** Function bta_dm_set_encryption
4610 **
4611 ** Description This function to encrypt the link
4612 **
4613 ** Returns None
4614 **
4615 *******************************************************************************/
4616 #if (SMP_INCLUDED == TRUE)
bta_dm_set_encryption(tBTA_DM_MSG * p_data)4617 void bta_dm_set_encryption (tBTA_DM_MSG *p_data)
4618 {
4619 UINT8 i ;
4620
4621 APPL_TRACE_DEBUG("bta_dm_set_encryption\n"); //todo
4622 if (!p_data->set_encryption.p_callback) {
4623 APPL_TRACE_ERROR("bta_dm_set_encryption callback is not provided\n");
4624 return;
4625 }
4626 for (i = 0; i < bta_dm_cb.device_list.count; i++) {
4627 if (bdcmp( bta_dm_cb.device_list.peer_device[i].peer_bdaddr, p_data->set_encryption.bd_addr) == 0 &&
4628 bta_dm_cb.device_list.peer_device[i].conn_state == BTA_DM_CONNECTED) {
4629 break;
4630 }
4631 }
4632 if (i < bta_dm_cb.device_list.count) {
4633 if (bta_dm_cb.device_list.peer_device[i].p_encrypt_cback) {
4634 APPL_TRACE_ERROR("earlier enc was not done for same device\n");
4635 (*p_data->set_encryption.p_callback)(p_data->set_encryption.bd_addr,
4636 p_data->set_encryption.transport,
4637 BTA_BUSY);
4638 return;
4639 }
4640
4641 if (BTM_SetEncryption(p_data->set_encryption.bd_addr, p_data->set_encryption.transport,
4642 bta_dm_encrypt_cback, &p_data->set_encryption.sec_act)
4643 == BTM_CMD_STARTED) {
4644 bta_dm_cb.device_list.peer_device[i].p_encrypt_cback = p_data->set_encryption.p_callback;
4645 }
4646 }else{
4647 APPL_TRACE_ERROR("%s, not find peer_bdaddr or peer_bdaddr connection state error", __func__);
4648 }
4649 }
4650 #endif ///SMP_INCLUDED == TRUE
4651
4652 #if (BTA_HD_INCLUDED == TRUE)
bta_dm_check_if_only_hd_connected(BD_ADDR peer_addr)4653 BOOLEAN bta_dm_check_if_only_hd_connected(BD_ADDR peer_addr)
4654 {
4655 APPL_TRACE_DEBUG("%s: count(%d)", __func__, bta_dm_conn_srvcs.count);
4656 for (uint8_t j = 0; j < bta_dm_conn_srvcs.count; j++) {
4657 // Check if profiles other than hid are connected
4658 if ((bta_dm_conn_srvcs.conn_srvc[j].id != BTA_ID_HD) &&
4659 !bdcmp(bta_dm_conn_srvcs.conn_srvc[j].peer_bdaddr, peer_addr)) {
4660 APPL_TRACE_DEBUG("%s: Another profile (id=%d) is connected", __func__, bta_dm_conn_srvcs.conn_srvc[j].id);
4661 return FALSE;
4662 }
4663 }
4664 return TRUE;
4665 }
4666 #endif /* BTA_HD_INCLUDED == TRUE */
4667
4668 #if (BLE_INCLUDED == TRUE)
4669 /*******************************************************************************
4670 **
4671 ** Function bta_dm_observe_results_cb
4672 **
4673 ** Description Callback for BLE Observe result
4674 **
4675 **
4676 ** Returns void
4677 **
4678 *******************************************************************************/
bta_dm_observe_results_cb(tBTM_INQ_RESULTS * p_inq,UINT8 * p_eir)4679 static void bta_dm_observe_results_cb (tBTM_INQ_RESULTS *p_inq, UINT8 *p_eir)
4680 {
4681 tBTA_DM_SEARCH result;
4682 tBTM_INQ_INFO *p_inq_info;
4683 APPL_TRACE_DEBUG("bta_dm_observe_results_cb")
4684
4685 bdcpy(result.inq_res.bd_addr, p_inq->remote_bd_addr);
4686 result.inq_res.rssi = p_inq->rssi;
4687 result.inq_res.ble_addr_type = p_inq->ble_addr_type;
4688 result.inq_res.inq_result_type = p_inq->inq_result_type;
4689 result.inq_res.device_type = p_inq->device_type;
4690 result.inq_res.flag = p_inq->flag;
4691 result.inq_res.adv_data_len = p_inq->adv_data_len;
4692 result.inq_res.scan_rsp_len = p_inq->scan_rsp_len;
4693 memcpy(result.inq_res.dev_class, p_inq->dev_class, sizeof(DEV_CLASS));
4694 result.inq_res.ble_evt_type = p_inq->ble_evt_type;
4695
4696 /* application will parse EIR to find out remote device name */
4697 result.inq_res.p_eir = p_eir;
4698
4699 if ((p_inq_info = BTM_InqDbRead(p_inq->remote_bd_addr)) != NULL) {
4700 /* initialize remt_name_not_required to FALSE so that we get the name by default */
4701 result.inq_res.remt_name_not_required = FALSE;
4702 }
4703
4704 if (bta_dm_search_cb.p_scan_cback) {
4705 bta_dm_search_cb.p_scan_cback(BTA_DM_INQ_RES_EVT, &result);
4706 }
4707
4708 if (p_inq_info) {
4709 /* application indicates if it knows the remote name, inside the callback
4710 copy that to the inquiry data base*/
4711 if (result.inq_res.remt_name_not_required) {
4712 p_inq_info->appl_knows_rem_name = TRUE;
4713 }
4714 }
4715 }
4716
4717 /*******************************************************************************
4718 **
4719 ** Function bta_dm_observe_cmpl_cb
4720 **
4721 ** Description Callback for BLE Observe complete
4722 **
4723 **
4724 ** Returns void
4725 **
4726 *******************************************************************************/
bta_dm_observe_cmpl_cb(void * p_result)4727 static void bta_dm_observe_cmpl_cb (void *p_result)
4728 {
4729 tBTA_DM_SEARCH data;
4730
4731 APPL_TRACE_DEBUG("bta_dm_observe_cmpl_cb");
4732
4733 data.inq_cmpl.num_resps = ((tBTM_INQUIRY_CMPL *)p_result)->num_resp;
4734 if (bta_dm_search_cb.p_scan_cback) {
4735 bta_dm_search_cb.p_scan_cback(BTA_DM_INQ_CMPL_EVT, &data);
4736 }
4737 }
4738
4739 /*******************************************************************************
4740 **
4741 ** Function bta_dm_observe_discard_cb
4742 **
4743 ** Description Callback for BLE Observe lost
4744 **
4745 **
4746 ** Returns void
4747 **
4748 *******************************************************************************/
bta_dm_observe_discard_cb(uint32_t num_dis)4749 static void bta_dm_observe_discard_cb (uint32_t num_dis)
4750 {
4751 tBTA_DM_SEARCH data;
4752
4753 APPL_TRACE_DEBUG("bta_dm_observe_discard_cb");
4754
4755 data.inq_dis.num_dis = num_dis;
4756 if (bta_dm_search_cb.p_scan_cback) {
4757 bta_dm_search_cb.p_scan_cback(BTA_DM_INQ_DISCARD_NUM_EVT, &data);
4758 }
4759 }
4760
4761 #if (SMP_INCLUDED == TRUE)
4762 /*******************************************************************************
4763 **
4764 ** Function bta_dm_ble_smp_cback
4765 **
4766 ** Description Callback for BLE SMP
4767 **
4768 **
4769 ** Returns void
4770 **
4771 *******************************************************************************/
bta_dm_ble_smp_cback(tBTM_LE_EVT event,BD_ADDR bda,tBTM_LE_EVT_DATA * p_data)4772 static UINT8 bta_dm_ble_smp_cback (tBTM_LE_EVT event, BD_ADDR bda, tBTM_LE_EVT_DATA *p_data)
4773 {
4774 tBTM_STATUS status = BTM_SUCCESS;
4775 tBTA_DM_SEC sec_event;
4776 char *p_name = NULL;
4777
4778 if (!bta_dm_cb.p_sec_cback) {
4779 return BTM_NOT_AUTHORIZED;
4780 }
4781
4782 memset(&sec_event, 0, sizeof(tBTA_DM_SEC));
4783 switch (event) {
4784 case BTM_LE_IO_REQ_EVT: {
4785 // #if (BT_SSP_INCLUDED == TRUE)
4786 bta_dm_co_ble_io_req(bda,
4787 &p_data->io_req.io_cap,
4788 &p_data->io_req.oob_data,
4789 &p_data->io_req.auth_req,
4790 &p_data->io_req.max_key_size,
4791 &p_data->io_req.init_keys,
4792 &p_data->io_req.resp_keys);
4793 // #endif
4794 #if BTM_OOB_INCLUDED == FALSE
4795 status = BTM_SUCCESS;
4796 #endif
4797 APPL_TRACE_EVENT("io mitm: %d oob_data:%d\n", p_data->io_req.auth_req, p_data->io_req.oob_data);
4798
4799 break;
4800 }
4801
4802 case BTM_LE_SEC_REQUEST_EVT:
4803 bdcpy(sec_event.ble_req.bd_addr, bda);
4804 p_name = BTM_SecReadDevName(bda);
4805 if (p_name != NULL) {
4806 BCM_STRNCPY_S((char *)sec_event.ble_req.bd_name, p_name, BD_NAME_LEN);
4807 sec_event.ble_req.bd_name[BD_NAME_LEN] = '\0';
4808 } else {
4809 sec_event.ble_req.bd_name[0] = '\0';
4810 }
4811 bta_dm_cb.p_sec_cback(BTA_DM_BLE_SEC_REQ_EVT, &sec_event);
4812 break;
4813
4814 case BTM_LE_KEY_NOTIF_EVT:
4815 bdcpy(sec_event.key_notif.bd_addr, bda);
4816 p_name = BTM_SecReadDevName(bda);
4817 if (p_name != NULL) {
4818 BCM_STRNCPY_S((char *)sec_event.key_notif.bd_name, p_name, BD_NAME_LEN);
4819 sec_event.key_notif.bd_name[BD_NAME_LEN] = '\0';
4820 } else {
4821 sec_event.key_notif.bd_name[0] = '\0';
4822 }
4823 sec_event.key_notif.passkey = p_data->key_notif;
4824 bta_dm_cb.p_sec_cback(BTA_DM_BLE_PASSKEY_NOTIF_EVT, &sec_event);
4825 break;
4826
4827 case BTM_LE_KEY_REQ_EVT:
4828 bdcpy(sec_event.ble_req.bd_addr, bda);
4829 bta_dm_cb.p_sec_cback(BTA_DM_BLE_PASSKEY_REQ_EVT, &sec_event);
4830 break;
4831
4832 case BTM_LE_OOB_REQ_EVT:
4833 bdcpy(sec_event.ble_req.bd_addr, bda);
4834 bta_dm_cb.p_sec_cback(BTA_DM_BLE_OOB_REQ_EVT, &sec_event);
4835 break;
4836
4837 case BTM_LE_SC_OOB_REQ_EVT:
4838 bdcpy(sec_event.ble_req.bd_addr, bda);
4839 bta_dm_cb.p_sec_cback(BTA_DM_BLE_SC_OOB_REQ_EVT, &sec_event);
4840 break;
4841
4842 case BTM_LE_SC_LOC_OOB_EVT:
4843 memcpy(sec_event.local_oob_data.local_oob_c, p_data->local_oob_data.commitment, BT_OCTET16_LEN);
4844 memcpy(sec_event.local_oob_data.local_oob_r, p_data->local_oob_data.randomizer, BT_OCTET16_LEN);
4845 bta_dm_cb.p_sec_cback(BTA_DM_BLE_SC_CR_LOC_OOB_EVT, &sec_event);
4846 break;
4847
4848 case BTM_LE_NC_REQ_EVT:
4849 bdcpy(sec_event.key_notif.bd_addr, bda);
4850 BCM_STRNCPY_S((char *)sec_event.key_notif.bd_name,bta_dm_get_remname(), BD_NAME_LEN);
4851 sec_event.key_notif.bd_name[BD_NAME_LEN] = '\0';
4852 sec_event.key_notif.passkey = p_data->key_notif;
4853 bta_dm_cb.p_sec_cback(BTA_DM_BLE_NC_REQ_EVT, &sec_event);
4854 break;
4855
4856 case BTM_LE_KEY_EVT:
4857 bdcpy(sec_event.ble_key.bd_addr, bda);
4858 sec_event.ble_key.key_type = p_data->key.key_type;
4859 sec_event.ble_key.p_key_value = p_data->key.p_key_value;
4860 bta_dm_cb.p_sec_cback(BTA_DM_BLE_KEY_EVT, &sec_event);
4861 break;
4862
4863 case BTM_LE_COMPLT_EVT:
4864 bdcpy(sec_event.auth_cmpl.bd_addr, bda);
4865 #if BLE_INCLUDED == TRUE
4866 BTM_ReadDevInfo(bda, &sec_event.auth_cmpl.dev_type, &sec_event.auth_cmpl.addr_type);
4867 #endif
4868 p_name = BTM_SecReadDevName(bda);
4869 if (p_name != NULL) {
4870 BCM_STRNCPY_S((char *)sec_event.auth_cmpl.bd_name, p_name, BD_NAME_LEN);
4871 sec_event.auth_cmpl.bd_name[BD_NAME_LEN] = '\0';
4872 } else {
4873 sec_event.auth_cmpl.bd_name[0] = '\0';
4874 }
4875 if (p_data->complt.reason != 0) {
4876 sec_event.auth_cmpl.fail_reason = BTA_DM_AUTH_CONVERT_SMP_CODE(((UINT8)p_data->complt.reason));
4877 /* delete this device entry from Sec Dev DB */
4878 bta_dm_remove_sec_dev_entry (bda);
4879 } else {
4880 sec_event.auth_cmpl.success = TRUE;
4881 if (!p_data->complt.smp_over_br) {
4882
4883 }
4884 }
4885 sec_event.auth_cmpl.auth_mode = p_data->complt.auth_mode;
4886 if (bta_dm_cb.p_sec_cback) {
4887 //bta_dm_cb.p_sec_cback(BTA_DM_AUTH_CMPL_EVT, &sec_event);
4888 bta_dm_cb.p_sec_cback(BTA_DM_BLE_AUTH_CMPL_EVT, &sec_event);
4889 }
4890
4891 break;
4892
4893 default:
4894 status = BTM_NOT_AUTHORIZED;
4895 break;
4896 }
4897 return status;
4898 }
4899
4900 /*******************************************************************************
4901 **
4902 ** Function bta_dm_ble_id_key_cback
4903 **
4904 ** Description Callback for BLE local ID keys
4905 **
4906 **
4907 ** Returns void
4908 **
4909 *******************************************************************************/
bta_dm_ble_id_key_cback(UINT8 key_type,tBTM_BLE_LOCAL_KEYS * p_key)4910 static void bta_dm_ble_id_key_cback (UINT8 key_type, tBTM_BLE_LOCAL_KEYS *p_key)
4911 {
4912 UINT8 evt;
4913 tBTA_DM_SEC dm_key;
4914
4915 switch (key_type) {
4916 case BTM_BLE_KEY_TYPE_ID:
4917 case BTM_BLE_KEY_TYPE_ER:
4918 if (bta_dm_cb.p_sec_cback) {
4919 memcpy(&dm_key.ble_id_keys, p_key, sizeof(tBTM_BLE_LOCAL_KEYS));
4920
4921 evt = (key_type == BTM_BLE_KEY_TYPE_ID) ? BTA_DM_BLE_LOCAL_IR_EVT : \
4922 BTA_DM_BLE_LOCAL_ER_EVT;
4923 bta_dm_cb.p_sec_cback(evt, &dm_key);
4924 }
4925 break;
4926
4927 default:
4928 APPL_TRACE_DEBUG("Unknown key type %d", key_type);
4929 break;
4930 }
4931 return;
4932
4933 }
4934
4935 /*******************************************************************************
4936 **
4937 ** Function bta_dm_add_blekey
4938 **
4939 ** Description This function adds an BLE Key to an security database entry.
4940 ** This function shall only be called AFTER BTA_DmAddBleDevice has been called.
4941 ** It is normally called during host startup to restore all required information
4942 ** stored in the NVRAM.
4943 **
4944 ** Parameters:
4945 **
4946 *******************************************************************************/
bta_dm_add_blekey(tBTA_DM_MSG * p_data)4947 void bta_dm_add_blekey (tBTA_DM_MSG *p_data)
4948 {
4949 if (!BTM_SecAddBleKey (p_data->add_ble_key.bd_addr,
4950 (tBTM_LE_KEY_VALUE *)&p_data->add_ble_key.blekey,
4951 p_data->add_ble_key.key_type)) {
4952 APPL_TRACE_ERROR ("BTA_DM: Error adding BLE Key for device %08x%04x",
4953 (p_data->add_ble_key.bd_addr[0] << 24) + (p_data->add_ble_key.bd_addr[1] << 16) + \
4954 (p_data->add_ble_key.bd_addr[2] << 8) + p_data->add_ble_key.bd_addr[3],
4955 (p_data->add_ble_key.bd_addr[4] << 8) + p_data->add_ble_key.bd_addr[5]);
4956 }
4957 }
4958
4959 /*******************************************************************************
4960 **
4961 ** Function bta_dm_add_ble_device
4962 **
4963 ** Description This function adds an BLE device to an security database entry.
4964 ** It is normally called during host startup to restore all required information
4965 ** stored in the NVRAM.
4966 **
4967 ** Parameters:
4968 **
4969 *******************************************************************************/
bta_dm_add_ble_device(tBTA_DM_MSG * p_data)4970 void bta_dm_add_ble_device (tBTA_DM_MSG *p_data)
4971 {
4972 if (!BTM_SecAddBleDevice (p_data->add_ble_device.bd_addr, NULL,
4973 p_data->add_ble_device.dev_type ,
4974 p_data->add_ble_device.addr_type,
4975 p_data->add_ble_device.auth_mode)) {
4976 APPL_TRACE_ERROR ("BTA_DM: Error adding BLE Device for device %08x%04x",
4977 (p_data->add_ble_device.bd_addr[0] << 24) + (p_data->add_ble_device.bd_addr[1] << 16) + \
4978 (p_data->add_ble_device.bd_addr[2] << 8) + p_data->add_ble_device.bd_addr[3],
4979 (p_data->add_ble_device.bd_addr[4] << 8) + p_data->add_ble_device.bd_addr[5]);
4980 }
4981 }
4982
4983 /*******************************************************************************
4984 **
4985 ** Function bta_dm_add_ble_device
4986 **
4987 ** Description This function adds an BLE device to an security database entry.
4988 ** It is normally called during host startup to restore all required information
4989 ** stored in the NVRAM.
4990 **
4991 ** Parameters:
4992 **
4993 *******************************************************************************/
bta_dm_ble_passkey_reply(tBTA_DM_MSG * p_data)4994 void bta_dm_ble_passkey_reply (tBTA_DM_MSG *p_data)
4995 {
4996 if (p_data->pin_reply.accept) {
4997 BTM_BlePasskeyReply(p_data->ble_passkey_reply.bd_addr, BTM_SUCCESS, p_data->ble_passkey_reply.passkey);
4998 } else {
4999 BTM_BlePasskeyReply(p_data->ble_passkey_reply.bd_addr, BTM_NOT_AUTHORIZED, p_data->ble_passkey_reply.passkey);
5000 }
5001
5002 }
5003
bta_dm_ble_set_static_passkey(tBTA_DM_MSG * p_data)5004 void bta_dm_ble_set_static_passkey(tBTA_DM_MSG *p_data)
5005 {
5006 BTM_BleSetStaticPasskey(p_data->ble_set_static_passkey.add, p_data->ble_set_static_passkey.static_passkey);
5007 }
5008 /*******************************************************************************
5009 **
5010 ** Function bta_dm_ble_confirm_reply
5011 **
5012 ** Description This is response to SM numeric comparison request submitted
5013 ** to application.
5014 **
5015 ** Parameters:
5016 **
5017 *******************************************************************************/
bta_dm_ble_confirm_reply(tBTA_DM_MSG * p_data)5018 void bta_dm_ble_confirm_reply (tBTA_DM_MSG *p_data)
5019 {
5020 if (p_data->confirm.accept) {
5021 BTM_BleConfirmReply(p_data->confirm.bd_addr, BTM_SUCCESS);
5022 } else {
5023 BTM_BleConfirmReply(p_data->ble_passkey_reply.bd_addr, BTM_NOT_AUTHORIZED);
5024 }
5025 }
5026
5027 /*******************************************************************************
5028 **
5029 ** Function bta_dm_security_grant
5030 **
5031 ** Description This function grant SMP security request access.
5032 **
5033 ** Parameters:
5034 **
5035 *******************************************************************************/
bta_dm_security_grant(tBTA_DM_MSG * p_data)5036 void bta_dm_security_grant (tBTA_DM_MSG *p_data)
5037 {
5038 BTM_SecurityGrant(p_data->ble_sec_grant.bd_addr, p_data->ble_sec_grant.res);
5039 }
5040 #endif ///SMP_INCLUDED == TRUE
5041
5042 /*******************************************************************************
5043 **
5044 ** Function bta_dm_ble_set_bg_conn_type
5045 **
5046 ** Description This function set the BLE background connection type
5047 **
5048 ** Parameters:
5049 **
5050 *******************************************************************************/
bta_dm_ble_set_bg_conn_type(tBTA_DM_MSG * p_data)5051 void bta_dm_ble_set_bg_conn_type (tBTA_DM_MSG *p_data)
5052 {
5053 BTM_BleSetBgConnType(p_data->ble_set_bd_conn_type.bg_conn_type,
5054 p_data->ble_set_bd_conn_type.p_select_cback);
5055 }
5056
5057 /*******************************************************************************
5058 **
5059 ** Function bta_dm_ble_set_conn_params
5060 **
5061 ** Description This function set the preferred connection parameters.
5062 **
5063 ** Parameters:
5064 **
5065 *******************************************************************************/
bta_dm_ble_set_conn_params(tBTA_DM_MSG * p_data)5066 void bta_dm_ble_set_conn_params (tBTA_DM_MSG *p_data)
5067 {
5068 BTM_BleSetPrefConnParams(p_data->ble_set_conn_params.peer_bda,
5069 p_data->ble_set_conn_params.conn_int_min,
5070 p_data->ble_set_conn_params.conn_int_max,
5071 p_data->ble_set_conn_params.slave_latency,
5072 p_data->ble_set_conn_params.supervision_tout);
5073
5074 BTM_BleConfigConnParams(p_data->ble_set_conn_params.conn_int_min, p_data->ble_set_conn_params.conn_int_max,
5075 p_data->ble_set_conn_params.slave_latency, p_data->ble_set_conn_params.supervision_tout);
5076 }
5077
5078 /*******************************************************************************
5079 **
5080 ** Function bta_dm_ble_set_conn_scan_params
5081 **
5082 ** Description This function sets BLE scan parameters.
5083 **
5084 ** Parameters:
5085 **
5086 *******************************************************************************/
bta_dm_ble_set_scan_params(tBTA_DM_MSG * p_data)5087 void bta_dm_ble_set_scan_params(tBTA_DM_MSG *p_data)
5088 {
5089 BTM_BleSetScanParams(p_data->ble_set_scan_params.client_if,
5090 p_data->ble_set_scan_params.scan_int,
5091 p_data->ble_set_scan_params.scan_window,
5092 p_data->ble_set_scan_params.scan_mode,
5093 p_data->ble_set_scan_params.scan_param_setup_cback);
5094 }
5095
5096 /*******************************************************************************
5097 **
5098 ** Function bta_dm_ble_set_scan_fil_params
5099 **
5100 ** Description This function sets BLE scan filter & parameters.
5101 **
5102 ** Parameters:
5103 **
5104 *******************************************************************************/
bta_dm_ble_set_scan_fil_params(tBTA_DM_MSG * p_data)5105 void bta_dm_ble_set_scan_fil_params(tBTA_DM_MSG *p_data)
5106 {
5107 tBTA_STATUS status = BTA_FAILURE;
5108
5109 if (BTM_BleSetScanFilterParams (p_data->ble_set_scan_fil_params.client_if,
5110 p_data->ble_set_scan_fil_params.scan_int,
5111 p_data->ble_set_scan_fil_params.scan_window,
5112 p_data->ble_set_scan_fil_params.scan_mode,
5113 p_data->ble_set_scan_fil_params.addr_type_own,
5114 p_data->ble_set_scan_fil_params.scan_duplicate_filter,
5115 p_data->ble_set_scan_fil_params.scan_filter_policy,
5116 p_data->ble_set_scan_fil_params.scan_param_setup_cback) == BTM_SUCCESS) {
5117 status = BTA_SUCCESS;
5118
5119 } else {
5120 APPL_TRACE_ERROR("%s(), fail to set scan params.", __func__);
5121 }
5122 if (p_data->ble_set_scan_fil_params.scan_param_setup_cback != NULL) {
5123 p_data->ble_set_scan_fil_params.scan_param_setup_cback(p_data->ble_set_scan_fil_params.client_if, status);
5124 }
5125
5126 }
5127
5128
5129 /*******************************************************************************
5130 **
5131 ** Function bta_dm_ble_set_conn_scan_params
5132 **
5133 ** Description This function set the preferred connection scan parameters.
5134 **
5135 ** Parameters:
5136 **
5137 *******************************************************************************/
bta_dm_ble_set_conn_scan_params(tBTA_DM_MSG * p_data)5138 void bta_dm_ble_set_conn_scan_params (tBTA_DM_MSG *p_data)
5139 {
5140 BTM_BleSetConnScanParams(p_data->ble_set_conn_scan_params.scan_int,
5141 p_data->ble_set_conn_scan_params.scan_window);
5142 }
5143 /*******************************************************************************
5144 **
5145 ** Function bta_dm_ble_update_conn_params
5146 **
5147 ** Description This function update LE connection parameters.
5148 **
5149 ** Parameters:
5150 **
5151 *******************************************************************************/
bta_dm_ble_update_conn_params(tBTA_DM_MSG * p_data)5152 void bta_dm_ble_update_conn_params (tBTA_DM_MSG *p_data)
5153 {
5154 if (!L2CA_UpdateBleConnParams(p_data->ble_update_conn_params.bd_addr,
5155 p_data->ble_update_conn_params.min_int,
5156 p_data->ble_update_conn_params.max_int,
5157 p_data->ble_update_conn_params.latency,
5158 p_data->ble_update_conn_params.timeout)) {
5159 APPL_TRACE_ERROR("Update connection parameters failed!");
5160 }
5161 }
5162 /*******************************************************************************
5163 **
5164 ** Function bta_dm_ble_disconnect
5165 **
5166 ** Description This function disconnect the ble connection.
5167 **
5168 ** Parameters:
5169 **
5170 *******************************************************************************/
bta_dm_ble_disconnect(tBTA_DM_MSG * p_data)5171 void bta_dm_ble_disconnect (tBTA_DM_MSG *p_data)
5172 {
5173 L2CA_BleDisconnect(p_data->ble_disconnect.remote_bda);
5174 }
5175
5176 /*******************************************************************************
5177 **
5178 ** Function bta_dm_ble_set_rand_address
5179 **
5180 ** Description This function set the LE random address for the device.
5181 **
5182 ** Parameters: rand_addr:the random address which should be setting
5183 ** Explanation: This function added by Yulong at 2016/9/9
5184 *******************************************************************************/
bta_dm_ble_set_rand_address(tBTA_DM_MSG * p_data)5185 void bta_dm_ble_set_rand_address(tBTA_DM_MSG *p_data)
5186 {
5187 tBTM_STATUS status = BTM_SET_STATIC_RAND_ADDR_FAIL;
5188 if (p_data->set_addr.addr_type != BLE_ADDR_RANDOM) {
5189 APPL_TRACE_ERROR("Invalid random address type = %d\n", p_data->set_addr.addr_type);
5190 if(p_data->set_addr.p_set_rand_addr_cback) {
5191 (*p_data->set_addr.p_set_rand_addr_cback)(status);
5192 }
5193 return;
5194 }
5195 //send the setting random address to BTM layer
5196 status = BTM_BleSetRandAddress(p_data->set_addr.address);
5197 if(p_data->set_addr.p_set_rand_addr_cback) {
5198 (*p_data->set_addr.p_set_rand_addr_cback)(status);
5199 }
5200
5201 }
5202
bta_dm_ble_clear_rand_address(tBTA_DM_MSG * p_data)5203 void bta_dm_ble_clear_rand_address(tBTA_DM_MSG *p_data)
5204 {
5205 UNUSED(p_data);
5206 BTM_BleClearRandAddress();
5207 }
5208
5209 /*******************************************************************************
5210 **
5211 ** Function bta_dm_ble_stop_advertising
5212 **
5213 ** Description This function stop the BLE avdertising for the device.
5214 **
5215 ** Parameters: void
5216 ** Explanation: This function added by Yulong at 2016/10/19
5217 *******************************************************************************/
bta_dm_ble_stop_advertising(tBTA_DM_MSG * p_data)5218 void bta_dm_ble_stop_advertising(tBTA_DM_MSG *p_data)
5219 {
5220 if (p_data->hdr.event != BTA_DM_API_BLE_STOP_ADV_EVT) {
5221 APPL_TRACE_ERROR("Invalid BTA event,can't stop the BLE adverting\n");
5222 }
5223
5224 btm_ble_stop_adv();
5225 }
5226
5227
5228
5229 #if BLE_PRIVACY_SPT == TRUE
5230 /*******************************************************************************
5231 **
5232 ** Function bta_dm_ble_config_local_privacy
5233 **
5234 ** Description This function set the local device LE privacy settings.
5235 **
5236 ** Parameters:
5237 **
5238 *******************************************************************************/
bta_dm_ble_config_local_privacy(tBTA_DM_MSG * p_data)5239 void bta_dm_ble_config_local_privacy (tBTA_DM_MSG *p_data)
5240 {
5241 BTM_BleConfigPrivacy (p_data->ble_local_privacy.privacy_enable, p_data->ble_local_privacy.set_local_privacy_cback);
5242 }
5243 #endif
5244
5245 /*******************************************************************************
5246 **
5247 ** Function bta_dm_ble_config_local_icon
5248 **
5249 ** Description This function sets the local icon value.
5250 **
5251 **
5252 *******************************************************************************/
bta_dm_ble_config_local_icon(tBTA_DM_MSG * p_data)5253 void bta_dm_ble_config_local_icon (tBTA_DM_MSG *p_data)
5254 {
5255 BTM_BleConfigLocalIcon (p_data->ble_local_icon.icon);
5256 }
5257
5258 /*******************************************************************************
5259 **
5260 ** Function bta_dm_ble_observe
5261 **
5262 ** Description This function set the preferred connection scan parameters.
5263 **
5264 ** Parameters:
5265 **
5266 *******************************************************************************/
bta_dm_ble_observe(tBTA_DM_MSG * p_data)5267 void bta_dm_ble_observe (tBTA_DM_MSG *p_data)
5268 {
5269 tBTM_STATUS status;
5270 if (p_data->ble_observe.start) {
5271 /*Save the callback to be called when a scan results are available */
5272 bta_dm_search_cb.p_scan_cback = p_data->ble_observe.p_cback;
5273
5274 if ((status = BTM_BleObserve(TRUE, p_data->ble_observe.duration,
5275 bta_dm_observe_results_cb, bta_dm_observe_cmpl_cb)) != BTM_CMD_STARTED) {
5276 APPL_TRACE_WARNING(" %s start observe failed. status=0x%x\n", __FUNCTION__, status);
5277 }
5278
5279 if (p_data->ble_observe.p_start_scan_cback) {
5280 status = (status == BTM_CMD_STARTED ? BTA_SUCCESS : BTA_FAILURE);
5281 p_data->ble_observe.p_start_scan_cback(status);
5282 }
5283 } else {
5284 bta_dm_search_cb.p_scan_cback = NULL;
5285 status = BTM_BleObserve(FALSE, 0, NULL, NULL);
5286
5287 if (status != BTM_CMD_STARTED){
5288 APPL_TRACE_WARNING(" %s stop observe failed, status=0x%x\n", __FUNCTION__, status);
5289 }
5290
5291 if (p_data->ble_observe.p_stop_scan_cback) {
5292 status = (status == BTM_CMD_STARTED ? BTA_SUCCESS : BTA_FAILURE);
5293 p_data->ble_observe.p_stop_scan_cback(status);
5294 }
5295 }
5296 }
5297
5298 /*******************************************************************************
5299 **
5300 ** Function bta_dm_ble_scan
5301 **
5302 ** Description This function set the preferred connection scan parameters.
5303 **
5304 ** Parameters:
5305 **
5306 *******************************************************************************/
bta_dm_ble_scan(tBTA_DM_MSG * p_data)5307 void bta_dm_ble_scan (tBTA_DM_MSG *p_data)
5308 {
5309 tBTM_STATUS status;
5310 if (p_data->ble_scan.start) {
5311 /*Save the callback to be called when a scan results are available */
5312 bta_dm_search_cb.p_scan_cback = p_data->ble_scan.p_cback;
5313
5314 if ((status = BTM_BleScan(TRUE, p_data->ble_scan.duration,
5315 bta_dm_observe_results_cb, bta_dm_observe_cmpl_cb, bta_dm_observe_discard_cb)) != BTM_CMD_STARTED) {
5316 APPL_TRACE_WARNING(" %s start scan failed. status=0x%x\n", __FUNCTION__, status);
5317 }
5318
5319 if (p_data->ble_scan.p_start_scan_cback) {
5320 status = (status == BTM_CMD_STARTED ? BTA_SUCCESS : BTA_FAILURE);
5321 p_data->ble_scan.p_start_scan_cback(status);
5322 }
5323 } else {
5324 bta_dm_search_cb.p_scan_cback = NULL;
5325 status = BTM_BleScan(FALSE, 0, NULL, NULL, NULL);
5326
5327 if (status != BTM_CMD_STARTED){
5328 APPL_TRACE_WARNING(" %s stop scan failed, status=0x%x\n", __FUNCTION__, status);
5329 }
5330
5331 if (p_data->ble_scan.p_stop_scan_cback) {
5332 status = (status == BTM_CMD_STARTED ? BTA_SUCCESS : BTA_FAILURE);
5333 p_data->ble_scan.p_stop_scan_cback(status);
5334 }
5335
5336 // reset BLE scan link state when stop scan
5337 btm_ble_clear_topology_mask(BTM_BLE_STATE_ACTIVE_SCAN_BIT);
5338 btm_ble_clear_topology_mask(BTM_BLE_STATE_PASSIVE_SCAN_BIT);
5339 }
5340 }
5341
5342 /*******************************************************************************
5343 **
5344 ** Function bta_dm_ble_set_adv_params
5345 **
5346 ** Description This function set the adv parameters.
5347 **
5348 ** Parameters:
5349 **
5350 *******************************************************************************/
bta_dm_ble_set_adv_params(tBTA_DM_MSG * p_data)5351 void bta_dm_ble_set_adv_params (tBTA_DM_MSG *p_data)
5352 {
5353 BTM_BleSetAdvParams(p_data->ble_set_adv_params.adv_int_min,
5354 p_data->ble_set_adv_params.adv_int_max,
5355 p_data->ble_set_adv_params.p_dir_bda,
5356 BTA_DM_BLE_ADV_CHNL_MAP);
5357 }
5358
5359 /*******************************************************************************
5360 **
5361 ** Function bta_dm_ble_set_adv_params_all
5362 **
5363 ** Description This function is called to set all of the advertising parameters.
5364 **
5365 ** Parameters: None.
5366 **
5367 ** Returns void
5368 **
5369 *******************************************************************************/
bta_dm_ble_set_adv_params_all(tBTA_DM_MSG * p_data)5370 void bta_dm_ble_set_adv_params_all (tBTA_DM_MSG *p_data)
5371 {
5372 tBTA_STATUS status = BTA_FAILURE;
5373 if (BTM_BleSetAdvParamsAll(p_data->ble_set_adv_params_all.adv_int_min,
5374 p_data->ble_set_adv_params_all.adv_int_max,
5375 p_data->ble_set_adv_params_all.adv_type,
5376 p_data->ble_set_adv_params_all.addr_type_own,
5377 p_data->ble_set_adv_params_all.p_dir_bda,
5378 p_data->ble_set_adv_params_all.channel_map,
5379 p_data->ble_set_adv_params_all.adv_filter_policy,
5380 p_data->ble_set_adv_params_all.p_start_adv_cback) == BTM_SUCCESS) {
5381 APPL_TRACE_DEBUG("%s(), success to set ble adv params.", __func__);
5382 } else {
5383 APPL_TRACE_ERROR("%s(), fail to set ble adv params.", __func__);
5384 if(p_data->ble_set_adv_params_all.p_start_adv_cback) {
5385 (*p_data->ble_set_adv_params_all.p_start_adv_cback)(status);
5386 }
5387 return;
5388 }
5389 if(BTM_BleStartAdv() == BTM_SUCCESS) {
5390 status = BTA_SUCCESS;
5391 }
5392 if(p_data->ble_set_adv_params_all.p_start_adv_cback) {
5393 (*p_data->ble_set_adv_params_all.p_start_adv_cback)(status);
5394 }
5395 }
5396
5397 /*******************************************************************************
5398 **
5399 ** Function bta_dm_ble_update_duplicate_exceptional_list
5400 **
5401 ** Description This function is to update duplicate scan exceptional list
5402 **
5403 **
5404 *******************************************************************************/
bta_dm_ble_update_duplicate_exceptional_list(tBTA_DM_MSG * p_data)5405 void bta_dm_ble_update_duplicate_exceptional_list(tBTA_DM_MSG *p_data)
5406 {
5407 BTM_UpdateBleDuplicateExceptionalList(p_data->ble_duplicate_exceptional_list.subcode,
5408 p_data->ble_duplicate_exceptional_list.type,
5409 p_data->ble_duplicate_exceptional_list.device_info,
5410 p_data->ble_duplicate_exceptional_list.exceptional_list_cb);
5411 }
5412
5413 /*******************************************************************************
5414 **
5415 ** Function bta_dm_ble_set_adv_config
5416 **
5417 ** Description This function set the customized ADV data configuration
5418 **
5419 ** Parameters:
5420 **
5421 *******************************************************************************/
bta_dm_ble_set_adv_config(tBTA_DM_MSG * p_data)5422 void bta_dm_ble_set_adv_config (tBTA_DM_MSG *p_data)
5423 {
5424 tBTA_STATUS status = BTA_FAILURE;
5425
5426 if (BTM_BleWriteAdvData(p_data->ble_set_adv_data.data_mask,
5427 (tBTM_BLE_ADV_DATA *)p_data->ble_set_adv_data.p_adv_cfg) == BTM_SUCCESS) {
5428 status = BTA_SUCCESS;
5429 }
5430
5431 if (p_data->ble_set_adv_data.p_adv_data_cback) {
5432 (*p_data->ble_set_adv_data.p_adv_data_cback)(status);
5433 }
5434 }
5435
5436 /*******************************************************************************
5437 **
5438 ** Function bta_dm_ble_set_long_adv
5439 **
5440 ** Description This function set the long ADV data
5441 **
5442 ** Parameters:
5443 **
5444 *******************************************************************************/
bta_dm_ble_set_long_adv(tBTA_DM_MSG * p_data)5445 void bta_dm_ble_set_long_adv (tBTA_DM_MSG *p_data)
5446 {
5447 tBTA_STATUS status = BTA_FAILURE;
5448
5449 if (BTM_BleWriteLongAdvData(p_data->ble_set_long_adv_data.adv_data,
5450 p_data->ble_set_long_adv_data.adv_data_len) == BTM_SUCCESS) {
5451 status = BTA_SUCCESS;
5452 }
5453
5454 if (p_data->ble_set_adv_data.p_adv_data_cback) {
5455 (*p_data->ble_set_adv_data.p_adv_data_cback)(status);
5456 }
5457 }
5458
5459 /*******************************************************************************
5460 **
5461 ** Function bta_dm_ble_set_adv_config_raw
5462 **
5463 ** Description This function set the customized ADV data configuration
5464 **
5465 ** Parameters:
5466 **
5467 *******************************************************************************/
bta_dm_ble_set_adv_config_raw(tBTA_DM_MSG * p_data)5468 void bta_dm_ble_set_adv_config_raw (tBTA_DM_MSG *p_data)
5469 {
5470 tBTA_STATUS status = BTA_FAILURE;
5471
5472 if (BTM_BleWriteAdvDataRaw(p_data->ble_set_adv_data_raw.p_raw_adv,
5473 p_data->ble_set_adv_data_raw.raw_adv_len) == BTM_SUCCESS) {
5474 status = BTA_SUCCESS;
5475 }
5476
5477 if (p_data->ble_set_adv_data_raw.p_adv_data_cback) {
5478 (*p_data->ble_set_adv_data_raw.p_adv_data_cback)(status);
5479 }
5480 }
5481
5482
5483 /*******************************************************************************
5484 **
5485 ** Function bta_dm_ble_set_scan_rsp
5486 **
5487 ** Description This function set the customized ADV scan resp. configuration
5488 **
5489 ** Parameters:
5490 **
5491 *******************************************************************************/
bta_dm_ble_set_scan_rsp(tBTA_DM_MSG * p_data)5492 void bta_dm_ble_set_scan_rsp (tBTA_DM_MSG *p_data)
5493 {
5494 tBTA_STATUS status = BTA_FAILURE;
5495
5496 if (BTM_BleWriteScanRsp(p_data->ble_set_adv_data.data_mask,
5497 (tBTM_BLE_ADV_DATA *)p_data->ble_set_adv_data.p_adv_cfg) == BTM_SUCCESS) {
5498 status = BTA_SUCCESS;
5499 }
5500
5501 if (p_data->ble_set_adv_data.p_adv_data_cback) {
5502 (*p_data->ble_set_adv_data.p_adv_data_cback)(status);
5503 }
5504 }
5505
5506 /*******************************************************************************
5507 **
5508 ** Function bta_dm_ble_set_scan_rsp_raw
5509 **
5510 ** Description This function set the raw scan response data
5511 **
5512 ** Parameters:
5513 **
5514 *******************************************************************************/
bta_dm_ble_set_scan_rsp_raw(tBTA_DM_MSG * p_data)5515 void bta_dm_ble_set_scan_rsp_raw (tBTA_DM_MSG *p_data)
5516 {
5517 tBTA_STATUS status = BTA_FAILURE;
5518
5519 if (BTM_BleWriteScanRspRaw(p_data->ble_set_adv_data_raw.p_raw_adv,
5520 p_data->ble_set_adv_data_raw.raw_adv_len) == BTM_SUCCESS) {
5521 status = BTA_SUCCESS;
5522 }
5523
5524 if (p_data->ble_set_adv_data_raw.p_adv_data_cback) {
5525 (*p_data->ble_set_adv_data_raw.p_adv_data_cback)(status);
5526 }
5527 }
5528
5529 /*******************************************************************************
5530 **
5531 ** Function bta_dm_ble_set_data_length
5532 **
5533 ** Description This function set the maximum transmission packet size
5534 **
5535 ** Parameters
5536 **
5537 *******************************************************************************/
bta_dm_ble_set_data_length(tBTA_DM_MSG * p_data)5538 void bta_dm_ble_set_data_length(tBTA_DM_MSG *p_data)
5539 {
5540 UINT8 status = BTM_SUCCESS;
5541 tACL_CONN *p_acl_cb = btm_bda_to_acl(p_data->ble_set_data_length.remote_bda, BT_TRANSPORT_LE);
5542 if (p_acl_cb == NULL) {
5543 APPL_TRACE_ERROR("%s error: Invalid connection remote_bda.", __func__);
5544 return;
5545 }
5546
5547 p_acl_cb->p_set_pkt_data_cback = p_data->ble_set_data_length.p_set_pkt_data_cback;
5548 // if the value of the data length is same, trigger callback directly
5549 if(p_data->ble_set_data_length.tx_data_length == p_acl_cb->data_length_params.tx_len) {
5550 if(p_data->ble_set_data_length.p_set_pkt_data_cback) {
5551 (*p_data->ble_set_data_length.p_set_pkt_data_cback)(status, &p_acl_cb->data_length_params);
5552 }
5553 return;
5554 }
5555
5556 if(p_acl_cb->data_len_updating) {
5557 // already have one cmd
5558 if(p_acl_cb->data_len_waiting) {
5559 status = BTM_ILLEGAL_ACTION;
5560 } else {
5561 // save the command
5562 p_acl_cb->p_set_data_len_cback_waiting = p_data->ble_set_data_length.p_set_pkt_data_cback;
5563 p_acl_cb->tx_len_waiting = p_data->ble_set_data_length.tx_data_length;
5564 p_acl_cb->data_len_waiting = true;
5565 return;
5566 }
5567 } else {
5568 status = BTM_SetBleDataLength(p_data->ble_set_data_length.remote_bda,
5569 p_data->ble_set_data_length.tx_data_length);
5570 }
5571 if (status != BTM_SUCCESS) {
5572 APPL_TRACE_ERROR("%s failed\n", __FUNCTION__);
5573 }
5574 if (p_data->ble_set_data_length.p_set_pkt_data_cback && status != BTM_SUCCESS) {
5575 if (p_acl_cb->data_length_params.tx_len == 0){
5576 uint16_t length = controller_get_interface()->get_acl_data_size_ble();
5577 p_acl_cb->data_length_params.rx_len = length;
5578 p_acl_cb->data_length_params.tx_len = length;
5579 }
5580 (*p_data->ble_set_data_length.p_set_pkt_data_cback)(status, &p_acl_cb->data_length_params);
5581 }
5582
5583 }
5584
5585 /*******************************************************************************
5586 **
5587 ** Function bta_dm_ble_broadcast
5588 **
5589 ** Description Starts or stops LE broadcasts
5590 **
5591 ** Parameters:
5592 **
5593 *******************************************************************************/
bta_dm_ble_broadcast(tBTA_DM_MSG * p_data)5594 void bta_dm_ble_broadcast (tBTA_DM_MSG *p_data)
5595 {
5596 tBTA_STATUS status = BTA_FAILURE;
5597 BOOLEAN start = p_data->ble_observe.start;
5598
5599 if (BTM_BleBroadcast(start, p_data->ble_observe.p_stop_adv_cback) == BTM_SUCCESS) {
5600 status = BTA_SUCCESS;
5601 } else {
5602 APPL_TRACE_ERROR("%s failed\n", __FUNCTION__);
5603 }
5604
5605 if (p_data->ble_observe.p_stop_adv_cback){
5606 (*p_data->ble_observe.p_stop_adv_cback)(status);
5607 }
5608
5609 }
5610
5611 /*******************************************************************************
5612 **
5613 ** Function bta_dm_ble_multi_adv_enb
5614 **
5615 ** Description This function enables a single advertising instance
5616 **
5617 ** Parameters:
5618 **
5619 *******************************************************************************/
bta_dm_ble_multi_adv_enb(tBTA_DM_MSG * p_data)5620 void bta_dm_ble_multi_adv_enb(tBTA_DM_MSG *p_data)
5621 {
5622 tBTM_STATUS btm_status = 0;
5623
5624 bta_dm_cb.p_multi_adv_cback = p_data->ble_multi_adv_enb.p_cback;
5625 if (BTM_BleMaxMultiAdvInstanceCount() > 0 && NULL != p_data->ble_multi_adv_enb.p_ref) {
5626 btm_status = BTM_BleEnableAdvInstance((tBTM_BLE_ADV_PARAMS *)
5627 p_data->ble_multi_adv_enb.p_params,
5628 p_data->ble_multi_adv_enb.p_cback,
5629 p_data->ble_multi_adv_enb.p_ref);
5630 }
5631
5632 if (BTM_CMD_STARTED != btm_status) {
5633 bta_dm_cb.p_multi_adv_cback(BTA_BLE_MULTI_ADV_ENB_EVT, 0xFF,
5634 p_data->ble_multi_adv_enb.p_ref, BTA_FAILURE);
5635 }
5636 }
5637 /*******************************************************************************
5638 **
5639 ** Function bta_dm_ble_multi_adv_param_upd
5640 **
5641 ** Description This function updates multiple advertising instance parameters
5642 **
5643 ** Parameters:
5644 **
5645 *******************************************************************************/
bta_dm_ble_multi_adv_upd_param(tBTA_DM_MSG * p_data)5646 void bta_dm_ble_multi_adv_upd_param(tBTA_DM_MSG *p_data)
5647 {
5648 tBTM_STATUS btm_status = 0;
5649 void *p_ref = NULL;
5650
5651 if (BTM_BleMaxMultiAdvInstanceCount() > 0 && p_data->ble_multi_adv_param.inst_id > 0
5652 && p_data->ble_multi_adv_param.inst_id < BTM_BleMaxMultiAdvInstanceCount()) {
5653 btm_status = BTM_BleUpdateAdvInstParam(p_data->ble_multi_adv_param.inst_id,
5654 (tBTM_BLE_ADV_PARAMS *)p_data->ble_multi_adv_param.p_params);
5655 }
5656
5657 if (BTM_CMD_STARTED != btm_status) {
5658 p_ref = btm_ble_multi_adv_get_ref(p_data->ble_multi_adv_param.inst_id);
5659 bta_dm_cb.p_multi_adv_cback(BTA_BLE_MULTI_ADV_PARAM_EVT,
5660 p_data->ble_multi_adv_param.inst_id, p_ref, BTA_FAILURE);
5661 }
5662 }
5663 /*******************************************************************************
5664 **
5665 ** Function bta_dm_ble_multi_adv_data
5666 **
5667 ** Description This function write multiple advertising instance adv data
5668 ** or scan response data
5669 **
5670 ** Parameters:
5671 **
5672 *******************************************************************************/
bta_dm_ble_multi_adv_data(tBTA_DM_MSG * p_data)5673 void bta_dm_ble_multi_adv_data(tBTA_DM_MSG *p_data)
5674 {
5675 tBTM_STATUS btm_status = 0;
5676 void *p_ref = NULL;
5677
5678 if (BTM_BleMaxMultiAdvInstanceCount() > 0 && p_data->ble_multi_adv_data.inst_id > 0
5679 && p_data->ble_multi_adv_data.inst_id < BTM_BleMaxMultiAdvInstanceCount()) {
5680 btm_status = BTM_BleCfgAdvInstData(p_data->ble_multi_adv_data.inst_id,
5681 p_data->ble_multi_adv_data.is_scan_rsp,
5682 p_data->ble_multi_adv_data.data_mask,
5683 (tBTM_BLE_ADV_DATA *)p_data->ble_multi_adv_data.p_data);
5684 }
5685
5686 if (BTM_CMD_STARTED != btm_status) {
5687 p_ref = btm_ble_multi_adv_get_ref(p_data->ble_multi_adv_data.inst_id);
5688 bta_dm_cb.p_multi_adv_cback(BTA_BLE_MULTI_ADV_DATA_EVT,
5689 p_data->ble_multi_adv_data.inst_id, p_ref, BTA_FAILURE);
5690 }
5691
5692 }
5693 /*******************************************************************************
5694 **
5695 ** Function btm_dm_ble_multi_adv_disable
5696 **
5697 ** Description This function disable a single adv instance
5698 **
5699 ** Parameters:
5700 **
5701 *******************************************************************************/
btm_dm_ble_multi_adv_disable(tBTA_DM_MSG * p_data)5702 void btm_dm_ble_multi_adv_disable(tBTA_DM_MSG *p_data)
5703 {
5704 tBTM_STATUS btm_status = 0;
5705 void *p_ref = NULL;
5706
5707 if (BTM_BleMaxMultiAdvInstanceCount() > 0 && p_data->ble_multi_adv_disable.inst_id > 0
5708 && p_data->ble_multi_adv_disable.inst_id < BTM_BleMaxMultiAdvInstanceCount()) {
5709 btm_status = BTM_BleDisableAdvInstance(p_data->ble_multi_adv_disable.inst_id);
5710 }
5711
5712 if (BTM_CMD_STARTED != btm_status) {
5713 p_ref = btm_ble_multi_adv_get_ref(p_data->ble_multi_adv_disable.inst_id);
5714 bta_dm_cb.p_multi_adv_cback(BTA_BLE_MULTI_ADV_DISABLE_EVT,
5715 p_data->ble_multi_adv_disable.inst_id, p_ref, BTA_FAILURE);
5716 }
5717 }
5718
bta_dm_ble_gap_dtm_tx_start(tBTA_DM_MSG * p_data)5719 void bta_dm_ble_gap_dtm_tx_start(tBTA_DM_MSG *p_data)
5720 {
5721 BTM_BleTransmitterTest(p_data->dtm_tx_start.tx_channel, p_data->dtm_tx_start.len_of_data, p_data->dtm_tx_start.pkt_payload, p_data->dtm_tx_start.p_dtm_cmpl_cback);
5722 }
5723
bta_dm_ble_gap_dtm_rx_start(tBTA_DM_MSG * p_data)5724 void bta_dm_ble_gap_dtm_rx_start(tBTA_DM_MSG *p_data)
5725 {
5726 BTM_BleReceiverTest(p_data->dtm_rx_start.rx_channel, p_data->dtm_rx_start.p_dtm_cmpl_cback);
5727 }
5728
bta_dm_ble_gap_dtm_stop(tBTA_DM_MSG * p_data)5729 void bta_dm_ble_gap_dtm_stop(tBTA_DM_MSG *p_data)
5730 {
5731 BTM_BleTestEnd(p_data->dtm_stop.p_dtm_cmpl_cback);
5732 }
5733
bta_dm_ble_gap_clear_adv(tBTA_DM_MSG * p_data)5734 void bta_dm_ble_gap_clear_adv(tBTA_DM_MSG *p_data)
5735 {
5736 if (BTM_BleClearAdv(p_data->ble_clear_adv.p_clear_adv_cback) == FALSE) {
5737 if (p_data->ble_clear_adv.p_clear_adv_cback) {
5738 (*p_data->ble_clear_adv.p_clear_adv_cback)(BTA_FAILURE);
5739 }
5740 }
5741 }
5742
bta_dm_ble_gap_set_rpa_timeout(tBTA_DM_MSG * p_data)5743 void bta_dm_ble_gap_set_rpa_timeout(tBTA_DM_MSG *p_data)
5744 {
5745 APPL_TRACE_API("%s, rpa_timeout = %d", __func__, p_data->set_rpa_timeout.rpa_timeout);
5746 BTM_BleSetRpaTimeout(p_data->set_rpa_timeout.rpa_timeout,p_data->set_rpa_timeout.p_set_rpa_timeout_cback);
5747 }
5748
bta_dm_ble_gap_add_dev_to_resolving_list(tBTA_DM_MSG * p_data)5749 void bta_dm_ble_gap_add_dev_to_resolving_list(tBTA_DM_MSG *p_data)
5750 {
5751 APPL_TRACE_API("%s", __func__);
5752 BTM_BleAddDevToResolvingList(p_data->add_dev_to_resolving_list.addr,
5753 p_data->add_dev_to_resolving_list.addr_type,
5754 p_data->add_dev_to_resolving_list.irk,
5755 p_data->add_dev_to_resolving_list.p_add_dev_to_resolving_list_callback);
5756 }
5757
bta_dm_ble_gap_set_privacy_mode(tBTA_DM_MSG * p_data)5758 void bta_dm_ble_gap_set_privacy_mode(tBTA_DM_MSG *p_data)
5759 {
5760 APPL_TRACE_API("%s, privacy_mode = %d", __func__, p_data->ble_set_privacy_mode.privacy_mode);
5761 BTM_BleSetPrivacyMode(p_data->ble_set_privacy_mode.addr_type, p_data->ble_set_privacy_mode.addr,
5762 p_data->ble_set_privacy_mode.privacy_mode, p_data->ble_set_privacy_mode.p_cback);
5763 }
5764
bta_dm_ble_gap_set_csa_support(tBTA_DM_MSG * p_data)5765 void bta_dm_ble_gap_set_csa_support(tBTA_DM_MSG *p_data)
5766 {
5767 APPL_TRACE_API("%s, csa_select = %d", __func__, p_data->ble_set_csa_support.csa_select);
5768 BTM_BleSetCsaSupport(p_data->ble_set_csa_support.csa_select, p_data->ble_set_csa_support.p_cback);
5769 }
5770
5771 #if (BLE_50_FEATURE_SUPPORT == TRUE)
bta_dm_ble_gap_dtm_enhance_tx_start(tBTA_DM_MSG * p_data)5772 void bta_dm_ble_gap_dtm_enhance_tx_start(tBTA_DM_MSG *p_data)
5773 {
5774 BTM_BleEnhancedTransmitterTest(p_data->dtm_enh_tx_start.tx_channel, p_data->dtm_enh_tx_start.len_of_data,
5775 p_data->dtm_enh_tx_start.pkt_payload, p_data->dtm_enh_tx_start.phy, p_data->dtm_enh_tx_start.p_dtm_cmpl_cback);
5776 }
5777
bta_dm_ble_gap_dtm_enhance_rx_start(tBTA_DM_MSG * p_data)5778 void bta_dm_ble_gap_dtm_enhance_rx_start(tBTA_DM_MSG *p_data)
5779 {
5780 BTM_BleEnhancedReceiverTest(p_data->dtm_enh_rx_start.rx_channel, p_data->dtm_enh_rx_start.phy,
5781 p_data->dtm_enh_rx_start.modulation_index, p_data->dtm_enh_rx_start.p_dtm_cmpl_cback);
5782 }
5783
bta_dm_ble_gap_read_phy(tBTA_DM_MSG * p_data)5784 void bta_dm_ble_gap_read_phy(tBTA_DM_MSG *p_data)
5785 {
5786 //tBTM_STATUS btm_status = 0;
5787 UINT8 tx_phy = 0, rx_phy = 0;
5788
5789 BTM_BleReadPhy(p_data->ble_read_phy.bd_addr, &tx_phy, &rx_phy);
5790
5791 }
5792
bta_dm_ble_gap_set_prefer_default_phy(tBTA_DM_MSG * p_data)5793 void bta_dm_ble_gap_set_prefer_default_phy(tBTA_DM_MSG *p_data)
5794 {
5795 APPL_TRACE_API("%s, tx_phy_mask = %d, rx_phy_mask = %d", __func__, p_data->ble_set_per_def_phy.tx_phy_mask, p_data->ble_set_per_def_phy.rx_phy_mask);
5796 BTM_BleSetPreferDefaultPhy(p_data->ble_set_per_def_phy.tx_phy_mask, p_data->ble_set_per_def_phy.rx_phy_mask);
5797 }
5798
bta_dm_ble_gap_set_prefer_phy(tBTA_DM_MSG * p_data)5799 void bta_dm_ble_gap_set_prefer_phy(tBTA_DM_MSG *p_data)
5800 {
5801 APPL_TRACE_API("%s, tx_phy_mask = %d, rx_phy_mask = %d, phy_options = %d",
5802 __func__, p_data->ble_set_per_phy.tx_phy_mask,
5803 p_data->ble_set_per_phy.rx_phy_mask, p_data->ble_set_per_phy.phy_options);
5804 BTM_BleSetPreferPhy(p_data->ble_set_per_phy.bd_addr, p_data->ble_set_per_phy.all_phys,
5805 p_data->ble_set_per_phy.tx_phy_mask, p_data->ble_set_per_phy.rx_phy_mask,
5806 p_data->ble_set_per_phy.phy_options);
5807 }
5808
bta_dm_ble_gap_ext_adv_set_rand_addr(tBTA_DM_MSG * p_data)5809 void bta_dm_ble_gap_ext_adv_set_rand_addr(tBTA_DM_MSG *p_data)
5810 {
5811 BTM_BleSetExtendedAdvRandaddr(p_data->ble_set_ext_adv_rand_addr.instance, p_data->ble_set_ext_adv_rand_addr.rand_addr);
5812 }
bta_dm_ble_gap_ext_adv_set_params(tBTA_DM_MSG * p_data)5813 void bta_dm_ble_gap_ext_adv_set_params(tBTA_DM_MSG *p_data)
5814 {
5815 APPL_TRACE_API("%s, instance = %d", __func__, p_data->ble_set_ext_adv_params.instance);
5816
5817 BTM_BleSetExtendedAdvParams(p_data->ble_set_ext_adv_params.instance,
5818 (tBTM_BLE_GAP_EXT_ADV_PARAMS *)&p_data->ble_set_ext_adv_params.params);
5819 }
5820
bta_dm_ble_gap_config_ext_adv_data_raw(tBTA_DM_MSG * p_data)5821 void bta_dm_ble_gap_config_ext_adv_data_raw(tBTA_DM_MSG *p_data)
5822 {
5823 APPL_TRACE_API("%s, instance = %d, len = %d", __func__, p_data->ble_cfg_ext_adv_data.instance,
5824 p_data->ble_cfg_ext_adv_data.length);
5825
5826 BTM_BleConfigExtendedAdvDataRaw(p_data->ble_cfg_ext_adv_data.is_scan_rsp,
5827 p_data->ble_cfg_ext_adv_data.instance,
5828 p_data->ble_cfg_ext_adv_data.length,
5829 p_data->ble_cfg_ext_adv_data.data);
5830 }
5831
bta_dm_ble_gap_start_ext_adv(tBTA_DM_MSG * p_data)5832 void bta_dm_ble_gap_start_ext_adv(tBTA_DM_MSG *p_data)
5833 {
5834 APPL_TRACE_API("%s, enable = %d, num = %d", __func__, p_data->ble_start_ext_adv.enable,
5835 p_data->ble_start_ext_adv.num);
5836 BTM_BleStartExtAdv(p_data->ble_start_ext_adv.enable, p_data->ble_start_ext_adv.num,
5837 (tBTM_BLE_EXT_ADV *)p_data->ble_start_ext_adv.ext_adv);
5838 }
5839
bta_dm_ble_gap_ext_adv_set_remove(tBTA_DM_MSG * p_data)5840 void bta_dm_ble_gap_ext_adv_set_remove(tBTA_DM_MSG *p_data)
5841 {
5842 BTM_BleExtAdvSetRemove(p_data->ble_ext_adv_set_remove.instance);
5843 }
5844
bta_dm_ble_gap_ext_adv_set_clear(tBTA_DM_MSG * p_data)5845 void bta_dm_ble_gap_ext_adv_set_clear(tBTA_DM_MSG *p_data)
5846 {
5847 BTM_BleExtAdvSetClear();
5848 }
5849
bta_dm_ble_gap_periodic_adv_set_params(tBTA_DM_MSG * p_data)5850 void bta_dm_ble_gap_periodic_adv_set_params(tBTA_DM_MSG *p_data)
5851 {
5852 APPL_TRACE_API("%s, instance = %d", __func__, p_data->ble_set_periodic_adv_params.instance);
5853 BTM_BlePeriodicAdvSetParams(p_data->ble_set_periodic_adv_params.instance,
5854 (tBTM_BLE_Periodic_Adv_Params *)&p_data->ble_set_periodic_adv_params.params);
5855 }
5856
bta_dm_ble_gap_periodic_adv_cfg_data_raw(tBTA_DM_MSG * p_data)5857 void bta_dm_ble_gap_periodic_adv_cfg_data_raw(tBTA_DM_MSG *p_data)
5858 {
5859 APPL_TRACE_API("%s, instance = %d, length = %d", __func__, p_data->ble_cfg_periodic_adv_data.instance,
5860 p_data->ble_cfg_periodic_adv_data.length);
5861
5862 BTM_BlePeriodicAdvCfgDataRaw(p_data->ble_cfg_periodic_adv_data.instance,
5863 p_data->ble_cfg_periodic_adv_data.length,
5864 p_data->ble_cfg_periodic_adv_data.data,
5865 p_data->ble_cfg_periodic_adv_data.only_update_did);
5866 }
5867
bta_dm_ble_gap_periodic_adv_enable(tBTA_DM_MSG * p_data)5868 void bta_dm_ble_gap_periodic_adv_enable(tBTA_DM_MSG *p_data)
5869 {
5870 APPL_TRACE_API("%s, instance = %d, enable = %d", __func__, p_data->ble_enable_periodic_adv.instance,
5871 p_data->ble_enable_periodic_adv.enable);
5872
5873 BTM_BlePeriodicAdvEnable(p_data->ble_enable_periodic_adv.instance,
5874 p_data->ble_enable_periodic_adv.enable);
5875 }
5876
bta_dm_ble_gap_periodic_adv_create_sync(tBTA_DM_MSG * p_data)5877 void bta_dm_ble_gap_periodic_adv_create_sync(tBTA_DM_MSG *p_data)
5878 {
5879 APPL_TRACE_API("%s", __func__);
5880 BTM_BlePeriodicAdvCreateSync((tBTM_BLE_Periodic_Sync_Params *)&p_data->ble_periodic_adv_sync.params);
5881 }
5882
bta_dm_ble_gap_periodic_adv_sync_cancel(tBTA_DM_MSG * p_data)5883 void bta_dm_ble_gap_periodic_adv_sync_cancel(tBTA_DM_MSG *p_data)
5884 {
5885 APPL_TRACE_API("%s", __func__);
5886 BTM_BlePeriodicAdvSyncCancel();
5887 }
5888
bta_dm_ble_gap_periodic_adv_sync_terminate(tBTA_DM_MSG * p_data)5889 void bta_dm_ble_gap_periodic_adv_sync_terminate(tBTA_DM_MSG *p_data)
5890 {
5891 APPL_TRACE_API("%s", __func__);
5892 BTM_BlePeriodicAdvSyncTerm(p_data->ble_periodic_adv_sync_term.sync_handle);
5893 }
5894
bta_dm_ble_gap_periodic_adv_add_dev_to_list(tBTA_DM_MSG * p_data)5895 void bta_dm_ble_gap_periodic_adv_add_dev_to_list(tBTA_DM_MSG *p_data)
5896 {
5897 APPL_TRACE_API("%s, addr_type = %d, sid = %d", __func__, p_data->ble_periodic_adv_add_dev_to_list.addr_type,
5898 p_data->ble_periodic_adv_add_dev_to_list.sid);
5899
5900 BTM_BlePeriodicAdvAddDevToList(p_data->ble_periodic_adv_add_dev_to_list.addr_type,
5901 p_data->ble_periodic_adv_add_dev_to_list.addr,
5902 p_data->ble_periodic_adv_add_dev_to_list.sid);
5903 }
5904
bta_dm_ble_gap_periodic_adv_remove_dev_from_list(tBTA_DM_MSG * p_data)5905 void bta_dm_ble_gap_periodic_adv_remove_dev_from_list(tBTA_DM_MSG *p_data)
5906 {
5907 APPL_TRACE_API("%s, addr_type = %d, sid = %d", __func__, p_data->ble_periodic_adv_remove_dev_from_list.addr_type,
5908 p_data->ble_periodic_adv_remove_dev_from_list.sid);
5909
5910 BTM_BlePeriodicAdvRemoveDevFromList(p_data->ble_periodic_adv_remove_dev_from_list.addr_type,
5911 p_data->ble_periodic_adv_remove_dev_from_list.addr,
5912 p_data->ble_periodic_adv_remove_dev_from_list.sid);
5913
5914 }
5915
bta_dm_ble_gap_periodic_adv_clear_dev(tBTA_DM_MSG * p_data)5916 void bta_dm_ble_gap_periodic_adv_clear_dev(tBTA_DM_MSG *p_data)
5917 {
5918 APPL_TRACE_API("%s", __func__);
5919 BTM_BlePeriodicAdvClearDev();
5920 }
5921
5922
bta_dm_ble_gap_set_ext_scan_params(tBTA_DM_MSG * p_data)5923 void bta_dm_ble_gap_set_ext_scan_params(tBTA_DM_MSG *p_data)
5924 {
5925 APPL_TRACE_API("%s", __func__);
5926 BTM_BleSetExtendedScanParams((tBTM_BLE_EXT_SCAN_PARAMS *)&p_data->ble_set_ext_scan_params.params);
5927 }
5928
bta_dm_ble_gap_ext_scan(tBTA_DM_MSG * p_data)5929 void bta_dm_ble_gap_ext_scan(tBTA_DM_MSG *p_data)
5930 {
5931 APPL_TRACE_API("%s, start = %d, duration = %d, period = %d", __func__, p_data->ble_ext_scan.start, p_data->ble_ext_scan.duration,
5932 p_data->ble_ext_scan.period);
5933 BTM_BleExtendedScan(p_data->ble_ext_scan.start, p_data->ble_ext_scan.duration,
5934 p_data->ble_ext_scan.period);
5935 }
5936
bta_dm_ble_gap_set_prefer_ext_conn_params(tBTA_DM_MSG * p_data)5937 void bta_dm_ble_gap_set_prefer_ext_conn_params(tBTA_DM_MSG *p_data)
5938 {
5939 tBTM_EXT_CONN_PARAMS conn_params;
5940 conn_params.phy_mask = p_data->ble_set_per_ext_conn_params.phy_mask;
5941
5942 APPL_TRACE_API("%s, start = %d, duration = %d, period = %d", __func__, p_data->ble_ext_scan.start, p_data->ble_ext_scan.duration,
5943 p_data->ble_ext_scan.period);
5944
5945 if (conn_params.phy_mask & BTA_PHY_1M_MASK) {
5946 memcpy(&conn_params.phy_1m_conn_params, &p_data->ble_set_per_ext_conn_params.phy_1m_conn_params,
5947 sizeof(tBTA_DM_BLE_CONN_PARAMS));
5948 }
5949
5950 if (conn_params.phy_mask & BTA_PHY_2M_MASK) {
5951 memcpy(&conn_params.phy_2m_conn_params, &p_data->ble_set_per_ext_conn_params.phy_2m_conn_params,
5952 sizeof(tBTA_DM_BLE_CONN_PARAMS));
5953 }
5954
5955 if (conn_params.phy_mask & BTA_PHY_CODED_MASK) {
5956 memcpy(&conn_params.phy_coded_conn_params, &p_data->ble_set_per_ext_conn_params.phy_coded_conn_params,
5957 sizeof(tBTA_DM_BLE_CONN_PARAMS));
5958 }
5959
5960 BTM_BleSetPreferExtenedConnParams(p_data->ble_set_per_ext_conn_params.bd_addr, &conn_params);
5961 }
5962
5963 #endif // #if (BLE_50_FEATURE_SUPPORT == TRUE)
5964
5965 #if (BLE_FEAT_PERIODIC_ADV_SYNC_TRANSFER == TRUE)
bta_dm_ble_gap_periodic_adv_recv_enable(tBTA_DM_MSG * p_data)5966 void bta_dm_ble_gap_periodic_adv_recv_enable(tBTA_DM_MSG *p_data)
5967 {
5968 BTM_BlePeriodicAdvRecvEnable(p_data->ble_periodic_adv_recv_enable.sync_handle,
5969 p_data->ble_periodic_adv_recv_enable.enable);
5970 }
5971
bta_dm_ble_gap_periodic_adv_sync_trans(tBTA_DM_MSG * p_data)5972 void bta_dm_ble_gap_periodic_adv_sync_trans(tBTA_DM_MSG *p_data)
5973 {
5974 BTM_BlePeriodicAdvSyncTrans(p_data->ble_periodic_adv_sync_trans.addr,
5975 p_data->ble_periodic_adv_sync_trans.service_data,
5976 p_data->ble_periodic_adv_sync_trans.sync_handle);
5977 }
5978
bta_dm_ble_gap_periodic_adv_set_info_trans(tBTA_DM_MSG * p_data)5979 void bta_dm_ble_gap_periodic_adv_set_info_trans(tBTA_DM_MSG *p_data)
5980 {
5981 BTM_BlePeriodicAdvSetInfoTrans(p_data->ble_periodic_adv_set_info_trans.addr,
5982 p_data->ble_periodic_adv_set_info_trans.service_data,
5983 p_data->ble_periodic_adv_set_info_trans.adv_hanlde);
5984 }
5985
bta_dm_ble_gap_set_periodic_adv_sync_trans_params(tBTA_DM_MSG * p_data)5986 void bta_dm_ble_gap_set_periodic_adv_sync_trans_params(tBTA_DM_MSG *p_data)
5987 {
5988 BTM_BleSetPeriodicAdvSyncTransParams(p_data->ble_set_past_params.addr,
5989 p_data->ble_set_past_params.params.mode,
5990 p_data->ble_set_past_params.params.skip,
5991 p_data->ble_set_past_params.params.sync_timeout,
5992 p_data->ble_set_past_params.params.cte_type);
5993 }
5994 #endif // #if (BLE_FEAT_PERIODIC_ADV_SYNC_TRANSFER == TRUE)
5995 /*******************************************************************************
5996 **
5997 ** Function bta_dm_ble_setup_storage
5998 **
5999 ** Description This function configures up the storage parameters for ADV batch scanning
6000 **
6001 ** Parameters:
6002 **
6003 *******************************************************************************/
bta_dm_ble_setup_storage(tBTA_DM_MSG * p_data)6004 void bta_dm_ble_setup_storage (tBTA_DM_MSG *p_data)
6005 {
6006 tBTM_STATUS btm_status = 0;
6007 tBTM_BLE_VSC_CB cmn_ble_vsc_cb;
6008
6009 BTM_BleGetVendorCapabilities(&cmn_ble_vsc_cb);
6010
6011 if (0 != cmn_ble_vsc_cb.tot_scan_results_strg) {
6012 btm_status = BTM_BleSetStorageConfig(p_data->ble_set_storage.batch_scan_full_max,
6013 p_data->ble_set_storage.batch_scan_trunc_max,
6014 p_data->ble_set_storage.batch_scan_notify_threshold,
6015 p_data->ble_set_storage.p_setup_cback,
6016 p_data->ble_set_storage.p_thres_cback,
6017 p_data->ble_set_storage.p_read_rep_cback,
6018 p_data->ble_set_storage.ref_value);
6019 }
6020
6021 if (BTM_CMD_STARTED != btm_status) {
6022 bta_ble_scan_setup_cb(BTM_BLE_BATCH_SCAN_CFG_STRG_EVT, p_data->ble_set_storage.ref_value,
6023 btm_status);
6024 }
6025 }
6026
6027 /*******************************************************************************
6028 **
6029 ** Function bta_dm_ble_enable_batch_scan
6030 **
6031 ** Description This function sets up the parameters and enables batch scan
6032 **
6033 ** Parameters:
6034 **
6035 *******************************************************************************/
bta_dm_ble_enable_batch_scan(tBTA_DM_MSG * p_data)6036 void bta_dm_ble_enable_batch_scan (tBTA_DM_MSG *p_data)
6037 {
6038 tBTM_STATUS btm_status = 0;
6039 tBTM_BLE_VSC_CB cmn_ble_vsc_cb;
6040
6041 BTM_BleGetVendorCapabilities(&cmn_ble_vsc_cb);
6042
6043 if (0 != cmn_ble_vsc_cb.tot_scan_results_strg) {
6044 btm_status = BTM_BleEnableBatchScan(p_data->ble_enable_scan.scan_mode,
6045 p_data->ble_enable_scan.scan_int,
6046 p_data->ble_enable_scan.scan_window,
6047 p_data->ble_enable_scan.discard_rule,
6048 p_data->ble_enable_scan.addr_type,
6049 p_data->ble_enable_scan.ref_value);
6050 }
6051
6052 if (BTM_CMD_STARTED != btm_status) {
6053 bta_ble_scan_setup_cb(BTM_BLE_BATCH_SCAN_ENABLE_EVT, p_data->ble_enable_scan.ref_value,
6054 btm_status);
6055 }
6056 }
6057
6058 /*******************************************************************************
6059 **
6060 ** Function bta_dm_ble_disable_batch_scan
6061 **
6062 ** Description This function disables the batch scan
6063 **
6064 ** Parameters:
6065 **
6066 *******************************************************************************/
bta_dm_ble_disable_batch_scan(tBTA_DM_MSG * p_data)6067 void bta_dm_ble_disable_batch_scan (tBTA_DM_MSG *p_data)
6068 {
6069 UNUSED(p_data);
6070 tBTM_STATUS btm_status = 0;
6071 tBTM_BLE_VSC_CB cmn_ble_vsc_cb;
6072
6073 BTM_BleGetVendorCapabilities(&cmn_ble_vsc_cb);
6074
6075 if (0 != cmn_ble_vsc_cb.tot_scan_results_strg) {
6076 btm_status = BTM_BleDisableBatchScan(p_data->ble_disable_scan.ref_value);
6077 }
6078
6079 if (BTM_CMD_STARTED != btm_status) {
6080 bta_ble_scan_setup_cb(BTM_BLE_BATCH_SCAN_DISABLE_EVT, p_data->ble_enable_scan.ref_value,
6081 btm_status);
6082 }
6083 }
6084
6085 /*******************************************************************************
6086 **
6087 ** Function bta_dm_ble_read_scan_reports
6088 **
6089 ** Description This function reads the batch scan reports
6090 **
6091 ** Parameters:
6092 **
6093 *******************************************************************************/
bta_dm_ble_read_scan_reports(tBTA_DM_MSG * p_data)6094 void bta_dm_ble_read_scan_reports(tBTA_DM_MSG *p_data)
6095 {
6096 tBTM_STATUS btm_status = 0;
6097 tBTM_BLE_VSC_CB cmn_ble_vsc_cb;
6098
6099 BTM_BleGetVendorCapabilities(&cmn_ble_vsc_cb);
6100
6101 if (0 != cmn_ble_vsc_cb.tot_scan_results_strg) {
6102 btm_status = BTM_BleReadScanReports(p_data->ble_read_reports.scan_type,
6103 p_data->ble_read_reports.ref_value);
6104 }
6105
6106 if (BTM_CMD_STARTED != btm_status) {
6107 bta_ble_scan_setup_cb(BTM_BLE_BATCH_SCAN_READ_REPTS_EVT, p_data->ble_enable_scan.ref_value,
6108 btm_status);
6109 }
6110 }
6111
6112 /*******************************************************************************
6113 **
6114 ** Function bta_dm_ble_track_advertiser
6115 **
6116 ** Description This function tracks the specific advertiser
6117 **
6118 ** Parameters:
6119 **
6120 *******************************************************************************/
bta_dm_ble_track_advertiser(tBTA_DM_MSG * p_data)6121 void bta_dm_ble_track_advertiser(tBTA_DM_MSG *p_data)
6122 {
6123 tBTM_STATUS btm_status = 0;
6124 BD_ADDR bda;
6125 memset(&bda, 0 , sizeof(BD_ADDR));
6126 tBTM_BLE_VSC_CB cmn_ble_vsc_cb;
6127 tBTA_DM_BLE_TRACK_ADV_DATA track_adv_data;
6128
6129 BTM_BleGetVendorCapabilities(&cmn_ble_vsc_cb);
6130
6131 if (0 != cmn_ble_vsc_cb.tot_scan_results_strg) {
6132 btm_status = BTM_BleTrackAdvertiser((tBTM_BLE_TRACK_ADV_CBACK *)
6133 p_data->ble_track_advert.p_track_adv_cback,
6134 p_data->ble_track_advert.ref_value);
6135 }
6136
6137 if (BTM_CMD_STARTED != btm_status) {
6138 memset(&track_adv_data, 0, sizeof(tBTA_DM_BLE_TRACK_ADV_DATA));
6139 track_adv_data.advertiser_info_present = NO_ADV_INFO_PRESENT; /* Indicates failure */
6140 track_adv_data.client_if = (UINT8)p_data->ble_track_advert.ref_value;
6141 p_data->ble_track_advert.p_track_adv_cback(&track_adv_data);
6142 }
6143 }
6144
6145 /*******************************************************************************
6146 **
6147 ** Function bta_ble_scan_setup_cb
6148 **
6149 ** Description Handle the setup callback from BTM layer and forward it to app layer
6150 **
6151 ** Parameters:
6152 **
6153 *******************************************************************************/
bta_ble_scan_setup_cb(tBTM_BLE_BATCH_SCAN_EVT evt,tBTM_BLE_REF_VALUE ref_value,tBTM_STATUS status)6154 void bta_ble_scan_setup_cb(tBTM_BLE_BATCH_SCAN_EVT evt, tBTM_BLE_REF_VALUE ref_value,
6155 tBTM_STATUS status)
6156 {
6157 tBTA_BLE_BATCH_SCAN_EVT bta_evt = 0;
6158
6159 APPL_TRACE_DEBUG("bta_ble_scan_setup_cb : evt: %d, ref_value: %d, status:%d", evt,
6160 ref_value, status);
6161
6162 switch (evt) {
6163 case BTM_BLE_BATCH_SCAN_ENABLE_EVT:
6164 bta_evt = BTA_BLE_BATCH_SCAN_ENB_EVT;
6165 break;
6166 case BTM_BLE_BATCH_SCAN_CFG_STRG_EVT:
6167 bta_evt = BTA_BLE_BATCH_SCAN_CFG_STRG_EVT;
6168 break;
6169 case BTM_BLE_BATCH_SCAN_DISABLE_EVT:
6170 bta_evt = BTA_BLE_BATCH_SCAN_DIS_EVT;
6171 break;
6172 case BTM_BLE_BATCH_SCAN_PARAM_EVT:
6173 bta_evt = BTA_BLE_BATCH_SCAN_PARAM_EVT;
6174 break;
6175 default:
6176 break;
6177 }
6178
6179 if (NULL != bta_dm_cb.p_setup_cback) {
6180 bta_dm_cb.p_setup_cback(bta_evt, ref_value, status);
6181 }
6182 }
6183
6184
6185 #if BLE_ANDROID_CONTROLLER_SCAN_FILTER == TRUE
6186 /*******************************************************************************
6187 **
6188 ** Function bta_ble_scan_pf_cmpl
6189 **
6190 ** Description ADV payload filtering operation complete callback
6191 **
6192 **
6193 ** Returns TRUE if handled, otherwise FALSE.
6194 **
6195 *******************************************************************************/
bta_ble_scan_cfg_cmpl(tBTM_BLE_PF_ACTION action,tBTM_BLE_SCAN_COND_OP cfg_op,tBTM_BLE_PF_AVBL_SPACE avbl_space,tBTM_STATUS status,tBTM_BLE_REF_VALUE ref_value)6196 static void bta_ble_scan_cfg_cmpl(tBTM_BLE_PF_ACTION action, tBTM_BLE_SCAN_COND_OP cfg_op,
6197 tBTM_BLE_PF_AVBL_SPACE avbl_space, tBTM_STATUS status,
6198 tBTM_BLE_REF_VALUE ref_value)
6199 {
6200 tBTA_STATUS st = (status == BTM_SUCCESS) ? BTA_SUCCESS : BTA_FAILURE;
6201
6202 APPL_TRACE_DEBUG("bta_ble_scan_cfg_cmpl: %d, %d, %d, %d", action, cfg_op, avbl_space, status);
6203
6204 if (bta_dm_cb.p_scan_filt_cfg_cback) {
6205 bta_dm_cb.p_scan_filt_cfg_cback(action, cfg_op, avbl_space, st, ref_value);
6206 }
6207 }
6208
6209 /*******************************************************************************
6210 **
6211 ** Function bta_dm_cfg_filter_cond
6212 **
6213 ** Description This function configure adv payload filtering condition
6214 **
6215 ** Parameters:
6216 **
6217 *******************************************************************************/
bta_dm_cfg_filter_cond(tBTA_DM_MSG * p_data)6218 void bta_dm_cfg_filter_cond (tBTA_DM_MSG *p_data)
6219 {
6220 tBTM_STATUS st = BTM_MODE_UNSUPPORTED;
6221 tBTA_STATUS status = BTA_FAILURE;
6222
6223 tBTM_BLE_VSC_CB cmn_vsc_cb;
6224
6225 APPL_TRACE_DEBUG("bta_dm_cfg_filter_cond");
6226 BTM_BleGetVendorCapabilities(&cmn_vsc_cb);
6227 if (0 != cmn_vsc_cb.filter_support) {
6228 if ((st = BTM_BleCfgFilterCondition(p_data->ble_cfg_filter_cond.action,
6229 p_data->ble_cfg_filter_cond.cond_type,
6230 (tBTM_BLE_PF_FILT_INDEX)p_data->ble_cfg_filter_cond.filt_index,
6231 (tBTM_BLE_PF_COND_PARAM *)p_data->ble_cfg_filter_cond.p_cond_param,
6232 bta_ble_scan_cfg_cmpl, p_data->ble_cfg_filter_cond.ref_value))
6233 == BTM_CMD_STARTED) {
6234 bta_dm_cb.p_scan_filt_cfg_cback = p_data->ble_cfg_filter_cond.p_filt_cfg_cback;
6235 return;
6236 }
6237 }
6238
6239 if (p_data->ble_cfg_filter_cond.p_filt_cfg_cback) {
6240 p_data->ble_cfg_filter_cond.p_filt_cfg_cback(BTA_DM_BLE_PF_CONFIG_EVT,
6241 p_data->ble_cfg_filter_cond.cond_type, 0, status,
6242 p_data->ble_cfg_filter_cond.ref_value);
6243 }
6244 return;
6245 }
6246
6247 /*******************************************************************************
6248 **
6249 ** Function bta_dm_enable_scan_filter
6250 **
6251 ** Description This function enable/disable adv payload filtering condition
6252 **
6253 ** Parameters:
6254 **
6255 *******************************************************************************/
bta_dm_enable_scan_filter(tBTA_DM_MSG * p_data)6256 void bta_dm_enable_scan_filter(tBTA_DM_MSG *p_data)
6257 {
6258 tBTM_STATUS st = BTM_MODE_UNSUPPORTED;
6259 tBTA_STATUS status = BTA_FAILURE;
6260
6261 tBTM_BLE_VSC_CB cmn_vsc_cb;
6262 APPL_TRACE_DEBUG("bta_dm_enable_scan_filter");
6263 BTM_BleGetVendorCapabilities(&cmn_vsc_cb);
6264
6265 if (0 != cmn_vsc_cb.filter_support) {
6266 if ((st = BTM_BleEnableDisableFilterFeature(p_data->ble_enable_scan_filt.action,
6267 p_data->ble_enable_scan_filt.p_filt_status_cback,
6268 (tBTM_BLE_REF_VALUE)p_data->ble_enable_scan_filt.ref_value)) == BTM_CMD_STARTED) {
6269 bta_dm_cb.p_scan_filt_status_cback = p_data->ble_enable_scan_filt.p_filt_status_cback;
6270 }
6271 return;
6272 }
6273
6274 if (p_data->ble_enable_scan_filt.p_filt_status_cback) {
6275 p_data->ble_enable_scan_filt.p_filt_status_cback (BTA_DM_BLE_PF_ENABLE_EVT,
6276 p_data->ble_enable_scan_filt.ref_value, status);
6277 }
6278
6279 }
6280
6281 /*******************************************************************************
6282 **
6283 ** Function bta_dm_scan_filter_param_setup
6284 **
6285 ** Description This function sets up scan filter params
6286 **
6287 ** Parameters:
6288 **
6289 *******************************************************************************/
bta_dm_scan_filter_param_setup(tBTA_DM_MSG * p_data)6290 void bta_dm_scan_filter_param_setup (tBTA_DM_MSG *p_data)
6291 {
6292 tBTM_STATUS st = BTM_MODE_UNSUPPORTED;
6293 tBTA_STATUS status = BTA_FAILURE;
6294
6295 tBTM_BLE_VSC_CB cmn_vsc_cb;
6296
6297 APPL_TRACE_DEBUG("bta_dm_scan_filter_param_setup");
6298 BTM_BleGetVendorCapabilities(&cmn_vsc_cb);
6299 if (0 != cmn_vsc_cb.filter_support) {
6300 if ((st = BTM_BleAdvFilterParamSetup(p_data->ble_scan_filt_param_setup.action,
6301 p_data->ble_scan_filt_param_setup.filt_index,
6302 (tBTM_BLE_PF_FILT_PARAMS *)&p_data->ble_scan_filt_param_setup.filt_params,
6303 p_data->ble_scan_filt_param_setup.p_target,
6304 p_data->ble_scan_filt_param_setup.p_filt_param_cback,
6305 p_data->ble_scan_filt_param_setup.ref_value)) == BTM_CMD_STARTED) {
6306 bta_dm_cb.p_scan_filt_param_cback = p_data->ble_scan_filt_param_setup.p_filt_param_cback;
6307 return;
6308 }
6309 }
6310
6311 if (p_data->ble_scan_filt_param_setup.p_filt_param_cback) {
6312 p_data->ble_scan_filt_param_setup.p_filt_param_cback (BTA_DM_BLE_PF_ENABLE_EVT, 0,
6313 p_data->ble_scan_filt_param_setup.ref_value, status);
6314 }
6315
6316 return;
6317 }
6318 #endif
6319
6320 /*******************************************************************************
6321 **
6322 ** Function bta_ble_enable_scan_cmpl
6323 **
6324 ** Description ADV payload filtering enable / disable complete callback
6325 **
6326 **
6327 ** Returns None
6328 **
6329 *******************************************************************************/
bta_ble_energy_info_cmpl(tBTM_BLE_TX_TIME_MS tx_time,tBTM_BLE_RX_TIME_MS rx_time,tBTM_BLE_IDLE_TIME_MS idle_time,tBTM_BLE_ENERGY_USED energy_used,tBTM_STATUS status)6330 static void bta_ble_energy_info_cmpl(tBTM_BLE_TX_TIME_MS tx_time,
6331 tBTM_BLE_RX_TIME_MS rx_time,
6332 tBTM_BLE_IDLE_TIME_MS idle_time,
6333 tBTM_BLE_ENERGY_USED energy_used,
6334 tBTM_STATUS status)
6335 {
6336 tBTA_STATUS st = (status == BTM_SUCCESS) ? BTA_SUCCESS : BTA_FAILURE;
6337 tBTA_DM_CONTRL_STATE ctrl_state = 0;
6338 #if ((defined BTA_GATT_INCLUDED) && (BTA_GATT_INCLUDED == TRUE) && SDP_INCLUDED == TRUE)
6339 if (BTA_SUCCESS == st) {
6340 ctrl_state = bta_dm_pm_obtain_controller_state();
6341 }
6342 #endif
6343 if (bta_dm_cb.p_energy_info_cback) {
6344 bta_dm_cb.p_energy_info_cback(tx_time, rx_time, idle_time, energy_used, ctrl_state, st);
6345 }
6346 }
6347
6348 /*******************************************************************************
6349 **
6350 ** Function bta_dm_ble_get_energy_info
6351 **
6352 ** Description This function obtains the energy info
6353 **
6354 ** Parameters:
6355 **
6356 *******************************************************************************/
bta_dm_ble_get_energy_info(tBTA_DM_MSG * p_data)6357 void bta_dm_ble_get_energy_info(tBTA_DM_MSG *p_data)
6358 {
6359 tBTM_STATUS btm_status = 0;
6360
6361 bta_dm_cb.p_energy_info_cback = p_data->ble_energy_info.p_energy_info_cback;
6362 btm_status = BTM_BleGetEnergyInfo(bta_ble_energy_info_cmpl);
6363 if (BTM_CMD_STARTED != btm_status) {
6364 bta_ble_energy_info_cmpl(0, 0, 0, 0, btm_status);
6365 }
6366 }
6367
6368 #if ((defined BTA_GATT_INCLUDED) && (BTA_GATT_INCLUDED == TRUE) && SDP_INCLUDED == TRUE)
6369 #ifndef BTA_DM_GATT_CLOSE_DELAY_TOUT
6370 #define BTA_DM_GATT_CLOSE_DELAY_TOUT 1000
6371 #endif
6372
6373 /*******************************************************************************
6374 **
6375 ** Function bta_dm_gattc_register
6376 **
6377 ** Description Register with GATTC in DM if BLE is needed.
6378 **
6379 **
6380 ** Returns void
6381 **
6382 *******************************************************************************/
6383 #if (GATTC_INCLUDED == TRUE)
bta_dm_gattc_register(void)6384 static void bta_dm_gattc_register(void)
6385 {
6386 tBT_UUID app_uuid = {LEN_UUID_128, {0}};
6387
6388 if (bta_dm_search_cb.client_if == BTA_GATTS_INVALID_IF) {
6389 memset (&app_uuid.uu.uuid128, 0x87, LEN_UUID_128);
6390 BTA_GATTC_AppRegister(&app_uuid, bta_dm_gattc_callback);
6391 }
6392 }
6393 #endif /* GATTC_INCLUDED == TRUE */
6394
6395 /*******************************************************************************
6396 **
6397 ** Function btm_dm_start_disc_gatt_services
6398 **
6399 ** Description This function starts a GATT service search request.
6400 **
6401 ** Parameters:
6402 **
6403 *******************************************************************************/
6404 #if (GATTC_INCLUDED == TRUE)
btm_dm_start_disc_gatt_services(UINT16 conn_id)6405 static void btm_dm_start_disc_gatt_services (UINT16 conn_id)
6406 {
6407 tBT_UUID *p_uuid = bta_dm_search_cb.p_srvc_uuid +
6408 bta_dm_search_cb.num_uuid - bta_dm_search_cb.uuid_to_search;
6409
6410 p_uuid = bta_dm_search_cb.p_srvc_uuid +
6411 bta_dm_search_cb.num_uuid - bta_dm_search_cb.uuid_to_search;
6412
6413 /* always search for all services */
6414 BTA_GATTC_ServiceSearchRequest(conn_id, p_uuid);
6415 }
6416 #endif /* GATTC_INCLUDED == TRUE */
6417
6418 /*******************************************************************************
6419 **
6420 ** Function bta_dm_gatt_disc_result
6421 **
6422 ** Description This function process the GATT service search result.
6423 **
6424 ** Parameters:
6425 **
6426 *******************************************************************************/
6427 #if (GATTC_INCLUDED == TRUE)
bta_dm_gatt_disc_result(tBTA_GATT_ID service_id)6428 static void bta_dm_gatt_disc_result(tBTA_GATT_ID service_id)
6429 {
6430 tBTA_DM_SEARCH result;
6431
6432 /*
6433 * This logic will not work for gatt case. We are checking against the bluetooth profiles here
6434 * just copy the GATTID in raw data field and send it across.
6435 */
6436
6437
6438 if ( bta_dm_search_cb.ble_raw_used + sizeof(tBTA_GATT_ID) < bta_dm_search_cb.ble_raw_size ) {
6439 APPL_TRACE_DEBUG("ADDING BLE SERVICE uuid=0x%x, ble_ptr = %p, ble_raw_used = 0x%x",
6440 service_id.uuid.uu.uuid16, bta_dm_search_cb.p_ble_rawdata, bta_dm_search_cb.ble_raw_used);
6441
6442 if (bta_dm_search_cb.p_ble_rawdata) {
6443 memcpy((bta_dm_search_cb.p_ble_rawdata + bta_dm_search_cb.ble_raw_used), &service_id,
6444 sizeof(service_id) );
6445
6446 bta_dm_search_cb.ble_raw_used += sizeof(service_id);
6447 } else {
6448 APPL_TRACE_ERROR("p_ble_rawdata is NULL");
6449 }
6450
6451 } else {
6452 APPL_TRACE_ERROR("%s out of room to accommodate more service ids ble_raw_size = %d ble_raw_used = %d", __FUNCTION__, bta_dm_search_cb.ble_raw_size, bta_dm_search_cb.ble_raw_used );
6453 }
6454
6455 APPL_TRACE_API("%s service_id_uuid_len=%d ", __func__, service_id.uuid.len);
6456 if ( bta_dm_search_cb.state != BTA_DM_SEARCH_IDLE) {
6457
6458 /* send result back to app now, one by one */
6459 bdcpy (result.disc_ble_res.bd_addr, bta_dm_search_cb.peer_bdaddr);
6460 BCM_STRNCPY_S((char *)result.disc_ble_res.bd_name, bta_dm_get_remname(), BD_NAME_LEN);
6461 result.disc_ble_res.bd_name[BD_NAME_LEN] = '\0';
6462 memcpy(&result.disc_ble_res.service, &service_id.uuid, sizeof(tBT_UUID));
6463
6464 bta_dm_search_cb.p_search_cback(BTA_DM_DISC_BLE_RES_EVT, &result);
6465 }
6466 }
6467 #endif /* #if (GATTC_INCLUDED == TRUE) */
6468 /*******************************************************************************
6469 **
6470 ** Function bta_dm_gatt_disc_complete
6471 **
6472 ** Description This function process the GATT service search complete.
6473 **
6474 ** Parameters:
6475 **
6476 *******************************************************************************/
6477 #if (GATTC_INCLUDED == TRUE)
bta_dm_gatt_disc_complete(UINT16 conn_id,tBTA_GATT_STATUS status)6478 static void bta_dm_gatt_disc_complete(UINT16 conn_id, tBTA_GATT_STATUS status)
6479 {
6480 tBTA_DM_MSG *p_msg;
6481
6482 APPL_TRACE_DEBUG("bta_dm_gatt_disc_complete conn_id = %d", conn_id);
6483
6484 if (bta_dm_search_cb.uuid_to_search > 0) {
6485 bta_dm_search_cb.uuid_to_search --;
6486 }
6487
6488 if (status == BTA_GATT_OK && bta_dm_search_cb.uuid_to_search > 0) {
6489 btm_dm_start_disc_gatt_services(conn_id);
6490 } else {
6491 bta_dm_search_cb.uuid_to_search = 0;
6492
6493 /* no more services to be discovered */
6494 if ((p_msg = (tBTA_DM_MSG *) osi_malloc(sizeof(tBTA_DM_MSG))) != NULL) {
6495 p_msg->hdr.event = BTA_DM_DISCOVERY_RESULT_EVT;
6496 p_msg->disc_result.result.disc_res.result = (status == BTA_GATT_OK) ? BTA_SUCCESS : BTA_FAILURE;
6497 APPL_TRACE_DEBUG("%s service found: 0x%08x", __FUNCTION__,
6498 bta_dm_search_cb.services_found);
6499 p_msg->disc_result.result.disc_res.services = bta_dm_search_cb.services_found;
6500 p_msg->disc_result.result.disc_res.num_uuids = 0;
6501 p_msg->disc_result.result.disc_res.p_uuid_list = NULL;
6502 bdcpy (p_msg->disc_result.result.disc_res.bd_addr, bta_dm_search_cb.peer_bdaddr);
6503 BCM_STRNCPY_S((char *)p_msg->disc_result.result.disc_res.bd_name, bta_dm_get_remname(), BD_NAME_LEN);
6504 p_msg->disc_result.result.disc_res.bd_name[BD_NAME_LEN] = '\0';
6505
6506 p_msg->disc_result.result.disc_res.device_type |= BT_DEVICE_TYPE_BLE;
6507 if ( bta_dm_search_cb.ble_raw_used > 0 ) {
6508 p_msg->disc_result.result.disc_res.p_raw_data = osi_malloc(bta_dm_search_cb.ble_raw_used);
6509
6510 memcpy( p_msg->disc_result.result.disc_res.p_raw_data,
6511 bta_dm_search_cb.p_ble_rawdata,
6512 bta_dm_search_cb.ble_raw_used );
6513
6514 p_msg->disc_result.result.disc_res.raw_data_size = bta_dm_search_cb.ble_raw_used;
6515 } else {
6516 p_msg->disc_result.result.disc_res.p_raw_data = NULL;
6517 bta_dm_search_cb.p_ble_rawdata = 0;
6518 }
6519
6520 bta_sys_sendmsg(p_msg);
6521 }
6522
6523 if (conn_id != BTA_GATT_INVALID_CONN_ID) {
6524 /* start a GATT channel close delay timer */
6525 bta_sys_start_timer(&bta_dm_search_cb.gatt_close_timer, BTA_DM_DISC_CLOSE_TOUT_EVT,
6526 BTA_DM_GATT_CLOSE_DELAY_TOUT);
6527 bdcpy(bta_dm_search_cb.pending_close_bda, bta_dm_search_cb.peer_bdaddr);
6528 }
6529 bta_dm_search_cb.gatt_disc_active = FALSE;
6530 }
6531 }
6532 #endif /* #if (GATTC_INCLUDED == TRUE) */
6533
6534 /*******************************************************************************
6535 **
6536 ** Function bta_dm_close_gatt_conn
6537 **
6538 ** Description This function close the GATT connection after delay timeout.
6539 **
6540 ** Parameters:
6541 **
6542 *******************************************************************************/
6543 #if (GATTC_INCLUDED == TRUE)
bta_dm_close_gatt_conn(tBTA_DM_MSG * p_data)6544 void bta_dm_close_gatt_conn(tBTA_DM_MSG *p_data)
6545 {
6546 UNUSED(p_data);
6547
6548 if (bta_dm_search_cb.conn_id != BTA_GATT_INVALID_CONN_ID) {
6549 BTA_GATTC_Close(bta_dm_search_cb.conn_id);
6550 }
6551
6552 memset(bta_dm_search_cb.pending_close_bda, 0, BD_ADDR_LEN);
6553 bta_dm_search_cb.conn_id = BTA_GATT_INVALID_CONN_ID;
6554 }
6555 #endif /* #if (GATTC_INCLUDED == TRUE) */
6556 /*******************************************************************************
6557 **
6558 ** Function btm_dm_start_gatt_discovery
6559 **
6560 ** Description This is GATT initiate the service search by open a GATT connection
6561 ** first.
6562 **
6563 ** Parameters:
6564 **
6565 *******************************************************************************/
6566 #if (GATTC_INCLUDED == TRUE)
btm_dm_start_gatt_discovery(BD_ADDR bd_addr)6567 void btm_dm_start_gatt_discovery (BD_ADDR bd_addr)
6568 {
6569 bta_dm_search_cb.gatt_disc_active = TRUE;
6570
6571 /* connection is already open */
6572 if (bdcmp(bta_dm_search_cb.pending_close_bda, bd_addr) == 0 &&
6573 bta_dm_search_cb.conn_id != BTA_GATT_INVALID_CONN_ID) {
6574 memset(bta_dm_search_cb.pending_close_bda, 0, BD_ADDR_LEN);
6575 bta_sys_stop_timer(&bta_dm_search_cb.gatt_close_timer);
6576 btm_dm_start_disc_gatt_services(bta_dm_search_cb.conn_id);
6577 } else {
6578 //TODO need to add addr_type in future
6579 BTA_GATTC_Enh_Open(bta_dm_search_cb.client_if, bd_addr, BLE_ADDR_UNKNOWN_TYPE, TRUE,
6580 BTA_GATT_TRANSPORT_LE, FALSE, BLE_ADDR_UNKNOWN_TYPE, 0, NULL, NULL, NULL);
6581
6582 }
6583 }
6584 #endif /* #if (GATTC_INCLUDED == TRUE) */
6585 /*******************************************************************************
6586 **
6587 ** Function bta_dm_cancel_gatt_discovery
6588 **
6589 ** Description This is GATT cancel the GATT service search.
6590 **
6591 ** Parameters:
6592 **
6593 *******************************************************************************/
6594 #if (GATTC_INCLUDED == TRUE)
bta_dm_cancel_gatt_discovery(BD_ADDR bd_addr)6595 static void bta_dm_cancel_gatt_discovery(BD_ADDR bd_addr)
6596 {
6597 if (bta_dm_search_cb.conn_id == BTA_GATT_INVALID_CONN_ID) {
6598 BTA_GATTC_CancelOpen(bta_dm_search_cb.client_if, bd_addr, TRUE);
6599 }
6600
6601 bta_dm_gatt_disc_complete(bta_dm_search_cb.conn_id, (tBTA_GATT_STATUS) BTA_GATT_ERROR);
6602 }
6603 #endif /* #if (GATTC_INCLUDED == TRUE) */
6604
6605 /*******************************************************************************
6606 **
6607 ** Function bta_dm_proc_open_evt
6608 **
6609 ** Description process BTA_GATTC_OPEN_EVT in DM.
6610 **
6611 ** Parameters:
6612 **
6613 *******************************************************************************/
6614 #if (GATTC_INCLUDED == TRUE)
bta_dm_proc_open_evt(tBTA_GATTC_OPEN * p_data)6615 void bta_dm_proc_open_evt(tBTA_GATTC_OPEN *p_data)
6616 {
6617 UINT8 *p1;
6618 UINT8 *p2;
6619
6620 p1 = bta_dm_search_cb.peer_bdaddr;
6621 p2 = p_data->remote_bda;
6622
6623 APPL_TRACE_DEBUG("DM Search state= %d search_cb.peer_dbaddr: [%08x%04x] connected_bda= [%08x%04x] ",
6624 bta_dm_search_cb.state,
6625 ((p1[0]) << 24) + ((p1[1]) << 16) + ((p1[2]) << 8) + (p1[3]),
6626 ((p1[4]) << 8) + p1[5],
6627 ((p2[0]) << 24) + ((p2[1]) << 16) + ((p2[2]) << 8) + (p2[3]),
6628 ((p2[4]) << 8) + p2[5]);
6629
6630 UNUSED(p1);
6631 UNUSED(p2);
6632 APPL_TRACE_DEBUG("BTA_GATTC_OPEN_EVT conn_id = %d client_if=%d status = %d" ,
6633 p_data->conn_id,
6634 p_data->client_if,
6635 p_data->status);
6636
6637 bta_dm_search_cb.conn_id = p_data->conn_id;
6638
6639 if (p_data->status == BTA_GATT_OK) {
6640 btm_dm_start_disc_gatt_services(p_data->conn_id);
6641 } else {
6642 bta_dm_gatt_disc_complete(BTA_GATT_INVALID_CONN_ID, p_data->status);
6643 }
6644 }
6645 #endif /* #if (GATTC_INCLUDED == TRUE) */
6646
6647 /*******************************************************************************
6648 **
6649 ** Function bta_dm_gattc_callback
6650 **
6651 ** Description This is GATT client callback function used in DM.
6652 **
6653 ** Parameters:
6654 **
6655 *******************************************************************************/
6656 #if (GATTC_INCLUDED == TRUE)
bta_dm_gattc_callback(tBTA_GATTC_EVT event,tBTA_GATTC * p_data)6657 static void bta_dm_gattc_callback(tBTA_GATTC_EVT event, tBTA_GATTC *p_data)
6658 {
6659 APPL_TRACE_DEBUG("bta_dm_gattc_callback event = %d", event);
6660
6661 switch (event) {
6662 case BTA_GATTC_REG_EVT:
6663 APPL_TRACE_DEBUG("BTA_GATTC_REG_EVT client_if = %d", p_data->reg_oper.client_if);
6664 if (p_data->reg_oper.status == BTA_GATT_OK) {
6665 bta_dm_search_cb.client_if = p_data->reg_oper.client_if;
6666 } else {
6667 bta_dm_search_cb.client_if = BTA_GATTS_INVALID_IF;
6668 }
6669 break;
6670
6671 case BTA_GATTC_OPEN_EVT:
6672 bta_dm_proc_open_evt(&p_data->open);
6673 break;
6674
6675 case BTA_GATTC_SEARCH_RES_EVT:
6676 bta_dm_gatt_disc_result(p_data->srvc_res.service_uuid);
6677 break;
6678
6679 case BTA_GATTC_SEARCH_CMPL_EVT:
6680 if ( bta_dm_search_cb.state != BTA_DM_SEARCH_IDLE) {
6681 bta_dm_gatt_disc_complete(p_data->search_cmpl.conn_id, p_data->search_cmpl.status);
6682 }
6683 break;
6684
6685 case BTA_GATTC_CLOSE_EVT:
6686 APPL_TRACE_DEBUG("BTA_GATTC_CLOSE_EVT reason = %d", p_data->close.reason);
6687 /* in case of disconnect before search is completed */
6688 if ( (bta_dm_search_cb.state != BTA_DM_SEARCH_IDLE) &&
6689 (bta_dm_search_cb.state != BTA_DM_SEARCH_ACTIVE) &&
6690 !memcmp(p_data->close.remote_bda, bta_dm_search_cb.peer_bdaddr, BD_ADDR_LEN)) {
6691 bta_dm_gatt_disc_complete((UINT16)BTA_GATT_INVALID_CONN_ID, (tBTA_GATT_STATUS) BTA_GATT_ERROR);
6692 }
6693 break;
6694
6695 default:
6696 break;
6697 }
6698 }
6699 #endif /* #if (GATTC_INCLUDED == TRUE) */
6700 #endif /* BTA_GATT_INCLUDED */
6701
6702 #if BLE_VND_INCLUDED == TRUE
6703 /*******************************************************************************
6704 **
6705 ** Function bta_dm_ctrl_features_rd_cmpl_cback
6706 **
6707 ** Description callback to handle controller feature read complete
6708 **
6709 ** Parameters:
6710 **
6711 *******************************************************************************/
bta_dm_ctrl_features_rd_cmpl_cback(tBTM_STATUS result)6712 static void bta_dm_ctrl_features_rd_cmpl_cback(tBTM_STATUS result)
6713 {
6714 APPL_TRACE_DEBUG("%s status = %d ", __FUNCTION__, result);
6715 if (result == BTM_SUCCESS) {
6716 if (bta_dm_cb.p_sec_cback) {
6717 bta_dm_cb.p_sec_cback(BTA_DM_LE_FEATURES_READ, NULL);
6718 }
6719 } else {
6720 APPL_TRACE_ERROR("%s Ctrl BLE feature read failed: status :%d", __FUNCTION__, result);
6721 }
6722
6723 }
6724 #endif /* BLE_VND_INCLUDED */
6725
6726 #endif /* BLE_INCLUDED */
6727
