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 is the API implementation file for the BTA device manager.
22 *
23 ******************************************************************************/
24
25 #include "bt_common.h"
26 #include "bta_sys.h"
27 #include "bta_api.h"
28 #include "bta_dm_int.h"
29 #include "bta_sys_int.h"
30 #include "btm_api.h"
31 #include "btm_int.h"
32 #include <string.h>
33 #include "utl.h"
34
35 /*****************************************************************************
36 ** Constants
37 *****************************************************************************/
38
39 static const tBTA_SYS_REG bta_dm_reg =
40 {
41 bta_dm_sm_execute,
42 bta_dm_sm_disable
43 };
44
45 static const tBTA_SYS_REG bta_dm_search_reg =
46 {
47 bta_dm_search_sm_execute,
48 bta_dm_search_sm_disable
49 };
50
51 /*******************************************************************************
52 **
53 ** Function BTA_EnableBluetooth
54 **
55 ** Description Enables bluetooth service. This function must be
56 ** called before any other functions in the BTA API are called.
57 **
58 **
59 ** Returns tBTA_STATUS
60 **
61 *******************************************************************************/
BTA_EnableBluetooth(tBTA_DM_SEC_CBACK * p_cback)62 tBTA_STATUS BTA_EnableBluetooth(tBTA_DM_SEC_CBACK *p_cback)
63 {
64 /* Bluetooth disabling is in progress */
65 if (bta_dm_cb.disabling)
66 return BTA_FAILURE;
67
68 bta_dm_init_cb();
69
70 bta_sys_register(BTA_ID_DM, &bta_dm_reg );
71 bta_sys_register(BTA_ID_DM_SEARCH, &bta_dm_search_reg );
72
73 /* if UUID list is not provided as static data */
74 bta_sys_eir_register(bta_dm_eir_update_uuid);
75
76 tBTA_DM_API_ENABLE *p_msg =
77 (tBTA_DM_API_ENABLE *)osi_malloc(sizeof(tBTA_DM_API_ENABLE));
78 p_msg->hdr.event = BTA_DM_API_ENABLE_EVT;
79 p_msg->p_sec_cback = p_cback;
80
81 bta_sys_sendmsg(p_msg);
82
83 return BTA_SUCCESS;
84 }
85
86 /*******************************************************************************
87 **
88 ** Function BTA_DisableBluetooth
89 **
90 ** Description Disables bluetooth service. This function is called when
91 ** the application no longer needs bluetooth service
92 **
93 ** Returns void
94 **
95 *******************************************************************************/
BTA_DisableBluetooth(void)96 tBTA_STATUS BTA_DisableBluetooth(void)
97 {
98 BT_HDR *p_msg = (BT_HDR *)osi_malloc(sizeof(BT_HDR));
99
100 p_msg->event = BTA_DM_API_DISABLE_EVT;
101
102 bta_sys_sendmsg(p_msg);
103
104 return BTA_SUCCESS;
105 }
106
107 /*******************************************************************************
108 **
109 ** Function BTA_EnableTestMode
110 **
111 ** Description Enables bluetooth device under test mode
112 **
113 **
114 ** Returns tBTA_STATUS
115 **
116 *******************************************************************************/
BTA_EnableTestMode(void)117 tBTA_STATUS BTA_EnableTestMode(void)
118 {
119 BT_HDR *p_msg = (BT_HDR *)osi_malloc(sizeof(BT_HDR));
120
121 APPL_TRACE_API("%s", __func__);
122
123 p_msg->event = BTA_DM_API_ENABLE_TEST_MODE_EVT;
124 bta_sys_sendmsg(p_msg);
125
126 return BTA_SUCCESS;
127 }
128
129 /*******************************************************************************
130 **
131 ** Function BTA_DisableTestMode
132 **
133 ** Description Disable bluetooth device under test mode
134 **
135 **
136 ** Returns None
137 **
138 *******************************************************************************/
BTA_DisableTestMode(void)139 void BTA_DisableTestMode(void)
140 {
141 BT_HDR *p_msg = (BT_HDR *)osi_malloc(sizeof(BT_HDR));
142
143 APPL_TRACE_API("%s", __func__);
144
145 p_msg->event = BTA_DM_API_DISABLE_TEST_MODE_EVT;
146 bta_sys_sendmsg(p_msg);
147 }
148
149 /*******************************************************************************
150 **
151 ** Function BTA_DmSetDeviceName
152 **
153 ** Description This function sets the Bluetooth name of local device
154 **
155 **
156 ** Returns void
157 **
158 *******************************************************************************/
BTA_DmSetDeviceName(char * p_name)159 void BTA_DmSetDeviceName(char *p_name)
160 {
161 tBTA_DM_API_SET_NAME *p_msg =
162 (tBTA_DM_API_SET_NAME *)osi_malloc(sizeof(tBTA_DM_API_SET_NAME));
163
164 p_msg->hdr.event = BTA_DM_API_SET_NAME_EVT;
165 strlcpy((char*)p_msg->name, p_name, BD_NAME_LEN);
166
167 bta_sys_sendmsg(p_msg);
168 }
169
170 /*******************************************************************************
171 **
172 ** Function BTA_DmSetVisibility
173 **
174 ** Description This function sets the Bluetooth connectable,
175 ** discoverable, pairable and conn paired only modes of local device
176 **
177 **
178 ** Returns void
179 **
180 *******************************************************************************/
BTA_DmSetVisibility(tBTA_DM_DISC disc_mode,tBTA_DM_CONN conn_mode,UINT8 pairable_mode,UINT8 conn_filter)181 void BTA_DmSetVisibility(tBTA_DM_DISC disc_mode, tBTA_DM_CONN conn_mode, UINT8 pairable_mode, UINT8 conn_filter )
182 {
183 tBTA_DM_API_SET_VISIBILITY *p_msg =
184 (tBTA_DM_API_SET_VISIBILITY *)osi_malloc(sizeof(tBTA_DM_MSG));
185
186 p_msg->hdr.event = BTA_DM_API_SET_VISIBILITY_EVT;
187 p_msg->disc_mode = disc_mode;
188 p_msg->conn_mode = conn_mode;
189 p_msg->pair_mode = pairable_mode;
190 p_msg->conn_paired_only = conn_filter;
191
192 bta_sys_sendmsg(p_msg);
193 }
194
195 /*******************************************************************************
196 **
197 ** Function BTA_DmSearch
198 **
199 ** Description This function searches for peer Bluetooth devices. It performs
200 ** an inquiry and gets the remote name for devices. Service
201 ** discovery is done if services is non zero
202 **
203 **
204 ** Returns void
205 **
206 *******************************************************************************/
BTA_DmSearch(tBTA_DM_INQ * p_dm_inq,tBTA_SERVICE_MASK services,tBTA_DM_SEARCH_CBACK * p_cback)207 void BTA_DmSearch(tBTA_DM_INQ *p_dm_inq, tBTA_SERVICE_MASK services, tBTA_DM_SEARCH_CBACK *p_cback)
208 {
209 tBTA_DM_API_SEARCH *p_msg =
210 (tBTA_DM_API_SEARCH *)osi_calloc(sizeof(tBTA_DM_API_SEARCH));
211
212 p_msg->hdr.event = BTA_DM_API_SEARCH_EVT;
213 memcpy(&p_msg->inq_params, p_dm_inq, sizeof(tBTA_DM_INQ));
214 p_msg->services = services;
215 p_msg->p_cback = p_cback;
216 p_msg->rs_res = BTA_DM_RS_NONE;
217
218 bta_sys_sendmsg(p_msg);
219 }
220
221 /*******************************************************************************
222 **
223 ** Function BTA_DmSearchCancel
224 **
225 ** Description This function cancels a search initiated by BTA_DmSearch
226 **
227 **
228 ** Returns void
229 **
230 *******************************************************************************/
BTA_DmSearchCancel(void)231 void BTA_DmSearchCancel(void)
232 {
233 BT_HDR *p_msg = (BT_HDR *)osi_malloc(sizeof(BT_HDR));
234
235 p_msg->event = BTA_DM_API_SEARCH_CANCEL_EVT;
236 bta_sys_sendmsg(p_msg);
237 }
238
239 /*******************************************************************************
240 **
241 ** Function BTA_DmDiscover
242 **
243 ** Description This function does service discovery for services of a
244 ** peer device
245 **
246 **
247 ** Returns void
248 **
249 *******************************************************************************/
BTA_DmDiscover(BD_ADDR bd_addr,tBTA_SERVICE_MASK services,tBTA_DM_SEARCH_CBACK * p_cback,BOOLEAN sdp_search)250 void BTA_DmDiscover(BD_ADDR bd_addr, tBTA_SERVICE_MASK services,
251 tBTA_DM_SEARCH_CBACK *p_cback, BOOLEAN sdp_search)
252 {
253 tBTA_DM_API_DISCOVER *p_msg =
254 (tBTA_DM_API_DISCOVER *)osi_calloc(sizeof(tBTA_DM_API_DISCOVER));
255
256 p_msg->hdr.event = BTA_DM_API_DISCOVER_EVT;
257 bdcpy(p_msg->bd_addr, bd_addr);
258 p_msg->services = services;
259 p_msg->p_cback = p_cback;
260 p_msg->sdp_search = sdp_search;
261
262 bta_sys_sendmsg(p_msg);
263 }
264
265 /*******************************************************************************
266 **
267 ** Function BTA_DmDiscoverUUID
268 **
269 ** Description This function does service discovery for services of a
270 ** peer device
271 **
272 **
273 ** Returns void
274 **
275 *******************************************************************************/
BTA_DmDiscoverUUID(BD_ADDR bd_addr,tSDP_UUID * uuid,tBTA_DM_SEARCH_CBACK * p_cback,BOOLEAN sdp_search)276 void BTA_DmDiscoverUUID(BD_ADDR bd_addr, tSDP_UUID *uuid,
277 tBTA_DM_SEARCH_CBACK *p_cback, BOOLEAN sdp_search)
278 {
279 tBTA_DM_API_DISCOVER *p_msg =
280 (tBTA_DM_API_DISCOVER *)osi_malloc(sizeof(tBTA_DM_API_DISCOVER));
281
282 p_msg->hdr.event = BTA_DM_API_DISCOVER_EVT;
283 bdcpy(p_msg->bd_addr, bd_addr);
284 p_msg->services = BTA_USER_SERVICE_MASK; //Not exposed at API level
285 p_msg->p_cback = p_cback;
286 p_msg->sdp_search = sdp_search;
287
288 #if BLE_INCLUDED == TRUE && BTA_GATT_INCLUDED == TRUE
289 p_msg->num_uuid = 0;
290 p_msg->p_uuid = NULL;
291 #endif
292 memcpy(&p_msg->uuid, uuid, sizeof(tSDP_UUID) );
293
294 bta_sys_sendmsg(p_msg);
295 }
296
297 /*******************************************************************************
298 **
299 ** Function BTA_DmBond
300 **
301 ** Description This function initiates a bonding procedure with a peer
302 ** device
303 **
304 **
305 ** Returns void
306 **
307 *******************************************************************************/
BTA_DmBond(BD_ADDR bd_addr)308 void BTA_DmBond(BD_ADDR bd_addr)
309 {
310 tBTA_DM_API_BOND *p_msg =
311 (tBTA_DM_API_BOND *)osi_malloc(sizeof(tBTA_DM_API_BOND));
312
313 p_msg->hdr.event = BTA_DM_API_BOND_EVT;
314 bdcpy(p_msg->bd_addr, bd_addr);
315 p_msg->transport = BTA_TRANSPORT_UNKNOWN;
316
317 bta_sys_sendmsg(p_msg);
318 }
319
320 /*******************************************************************************
321 **
322 ** Function BTA_DmBondByTransports
323 **
324 ** Description This function initiates a bonding procedure with a peer
325 ** device
326 **
327 **
328 ** Returns void
329 **
330 *******************************************************************************/
BTA_DmBondByTransport(BD_ADDR bd_addr,tBTA_TRANSPORT transport)331 void BTA_DmBondByTransport(BD_ADDR bd_addr, tBTA_TRANSPORT transport)
332 {
333 tBTA_DM_API_BOND *p_msg =
334 (tBTA_DM_API_BOND *)osi_malloc(sizeof(tBTA_DM_API_BOND));
335
336 p_msg->hdr.event = BTA_DM_API_BOND_EVT;
337 bdcpy(p_msg->bd_addr, bd_addr);
338 p_msg->transport = transport;
339
340 bta_sys_sendmsg(p_msg);
341 }
342
343 /*******************************************************************************
344 **
345 ** Function BTA_DmBondCancel
346 **
347 ** Description This function cancels the bonding procedure with a peer
348 ** device
349 **
350 **
351 ** Returns void
352 **
353 *******************************************************************************/
BTA_DmBondCancel(BD_ADDR bd_addr)354 void BTA_DmBondCancel(BD_ADDR bd_addr)
355 {
356 tBTA_DM_API_BOND_CANCEL *p_msg =
357 (tBTA_DM_API_BOND_CANCEL *)osi_malloc(sizeof(tBTA_DM_API_BOND_CANCEL));
358
359 p_msg->hdr.event = BTA_DM_API_BOND_CANCEL_EVT;
360 bdcpy(p_msg->bd_addr, bd_addr);
361
362 bta_sys_sendmsg(p_msg);
363 }
364
365 /*******************************************************************************
366 **
367 ** Function BTA_DmPinReply
368 **
369 ** Description This function provides a pincode for a remote device when
370 ** one is requested by DM through BTA_DM_PIN_REQ_EVT
371 **
372 **
373 ** Returns void
374 **
375 *******************************************************************************/
BTA_DmPinReply(BD_ADDR bd_addr,BOOLEAN accept,UINT8 pin_len,UINT8 * p_pin)376 void BTA_DmPinReply(BD_ADDR bd_addr, BOOLEAN accept, UINT8 pin_len, UINT8 *p_pin)
377
378 {
379 tBTA_DM_API_PIN_REPLY *p_msg =
380 (tBTA_DM_API_PIN_REPLY *)osi_malloc(sizeof(tBTA_DM_API_PIN_REPLY));
381
382 p_msg->hdr.event = BTA_DM_API_PIN_REPLY_EVT;
383 bdcpy(p_msg->bd_addr, bd_addr);
384 p_msg->accept = accept;
385 if (accept) {
386 p_msg->pin_len = pin_len;
387 memcpy(p_msg->p_pin, p_pin, pin_len);
388 }
389
390 bta_sys_sendmsg(p_msg);
391 }
392
393 /*******************************************************************************
394 **
395 ** Function BTA_DmLocalOob
396 **
397 ** Description This function retrieves the OOB data from local controller.
398 ** The result is reported by:
399 ** - bta_dm_co_loc_oob_ext() if device supports secure
400 ** connections (SC)
401 ** - bta_dm_co_loc_oob() if device doesn't support SC
402 **
403 ** Returns void
404 **
405 *******************************************************************************/
BTA_DmLocalOob(void)406 void BTA_DmLocalOob(void)
407 {
408 tBTA_DM_API_LOC_OOB *p_msg =
409 (tBTA_DM_API_LOC_OOB *)osi_malloc(sizeof(tBTA_DM_API_LOC_OOB));
410
411 p_msg->hdr.event = BTA_DM_API_LOC_OOB_EVT;
412 bta_sys_sendmsg(p_msg);
413 }
414
415 /*******************************************************************************
416 **
417 ** Function BTA_DmConfirm
418 **
419 ** Description This function accepts or rejects the numerical value of the
420 ** Simple Pairing process on BTA_DM_SP_CFM_REQ_EVT
421 **
422 ** Returns void
423 **
424 *******************************************************************************/
BTA_DmConfirm(BD_ADDR bd_addr,BOOLEAN accept)425 void BTA_DmConfirm(BD_ADDR bd_addr, BOOLEAN accept)
426 {
427 tBTA_DM_API_CONFIRM *p_msg =
428 (tBTA_DM_API_CONFIRM *)osi_malloc(sizeof(tBTA_DM_API_CONFIRM));
429
430 p_msg->hdr.event = BTA_DM_API_CONFIRM_EVT;
431 bdcpy(p_msg->bd_addr, bd_addr);
432 p_msg->accept = accept;
433
434 bta_sys_sendmsg(p_msg);
435 }
436
437 /*******************************************************************************
438 **
439 ** Function BTA_DmAddDevice
440 **
441 ** Description This function adds a device to the security database list of
442 ** peer device
443 **
444 **
445 ** Returns void
446 **
447 *******************************************************************************/
BTA_DmAddDevice(BD_ADDR bd_addr,DEV_CLASS dev_class,LINK_KEY link_key,tBTA_SERVICE_MASK trusted_mask,BOOLEAN is_trusted,UINT8 key_type,tBTA_IO_CAP io_cap,UINT8 pin_length)448 void BTA_DmAddDevice(BD_ADDR bd_addr, DEV_CLASS dev_class, LINK_KEY link_key,
449 tBTA_SERVICE_MASK trusted_mask, BOOLEAN is_trusted,
450 UINT8 key_type, tBTA_IO_CAP io_cap, UINT8 pin_length)
451 {
452 tBTA_DM_API_ADD_DEVICE *p_msg =
453 (tBTA_DM_API_ADD_DEVICE *)osi_calloc(sizeof(tBTA_DM_API_ADD_DEVICE));
454
455 p_msg->hdr.event = BTA_DM_API_ADD_DEVICE_EVT;
456 bdcpy(p_msg->bd_addr, bd_addr);
457 p_msg->tm = trusted_mask;
458 p_msg->is_trusted = is_trusted;
459 p_msg->io_cap = io_cap;
460
461 if (link_key) {
462 p_msg->link_key_known = TRUE;
463 p_msg->key_type = key_type;
464 memcpy(p_msg->link_key, link_key, LINK_KEY_LEN);
465 }
466
467 /* Load device class if specified */
468 if (dev_class) {
469 p_msg->dc_known = TRUE;
470 memcpy(p_msg->dc, dev_class, DEV_CLASS_LEN);
471 }
472
473 memset(p_msg->bd_name, 0, BD_NAME_LEN + 1);
474 memset(p_msg->features, 0, sizeof (p_msg->features));
475 p_msg->pin_length = pin_length;
476
477 bta_sys_sendmsg(p_msg);
478 }
479
480 /*******************************************************************************
481 **
482 ** Function BTA_DmRemoveDevice
483 **
484 ** Description This function removes a device fromthe security database list of
485 ** peer device. It manages unpairing even while connected.
486 **
487 **
488 ** Returns void
489 **
490 *******************************************************************************/
BTA_DmRemoveDevice(BD_ADDR bd_addr)491 tBTA_STATUS BTA_DmRemoveDevice(BD_ADDR bd_addr)
492 {
493 tBTA_DM_API_REMOVE_DEVICE *p_msg =
494 (tBTA_DM_API_REMOVE_DEVICE *)osi_calloc(sizeof(tBTA_DM_API_REMOVE_DEVICE));
495
496 p_msg->hdr.event = BTA_DM_API_REMOVE_DEVICE_EVT;
497 bdcpy(p_msg->bd_addr, bd_addr);
498
499 bta_sys_sendmsg(p_msg);
500
501 return BTA_SUCCESS;
502 }
503
504 /*******************************************************************************
505 **
506 ** Function BTA_GetEirService
507 **
508 ** Description This function is called to get BTA service mask from EIR.
509 **
510 ** Parameters p_eir - pointer of EIR significant part
511 ** p_services - return the BTA service mask
512 **
513 ** Returns None
514 **
515 *******************************************************************************/
516 extern const UINT16 bta_service_id_to_uuid_lkup_tbl [];
BTA_GetEirService(UINT8 * p_eir,tBTA_SERVICE_MASK * p_services)517 void BTA_GetEirService( UINT8 *p_eir, tBTA_SERVICE_MASK *p_services )
518 {
519 UINT8 xx, yy;
520 UINT8 num_uuid, max_num_uuid = 32;
521 UINT8 uuid_list[32*LEN_UUID_16];
522 UINT16 *p_uuid16 = (UINT16 *)uuid_list;
523 tBTA_SERVICE_MASK mask;
524
525 BTM_GetEirUuidList( p_eir, LEN_UUID_16, &num_uuid, uuid_list, max_num_uuid);
526 for( xx = 0; xx < num_uuid; xx++ )
527 {
528 mask = 1;
529 for( yy = 0; yy < BTA_MAX_SERVICE_ID; yy++ )
530 {
531 if( *(p_uuid16 + xx) == bta_service_id_to_uuid_lkup_tbl[yy] )
532 {
533 *p_services |= mask;
534 break;
535 }
536 mask <<= 1;
537 }
538
539 /* for HSP v1.2 only device */
540 if (*(p_uuid16 + xx) == UUID_SERVCLASS_HEADSET_HS)
541 *p_services |= BTA_HSP_SERVICE_MASK;
542
543 if (*(p_uuid16 + xx) == UUID_SERVCLASS_HDP_SOURCE)
544 *p_services |= BTA_HL_SERVICE_MASK;
545
546 if (*(p_uuid16 + xx) == UUID_SERVCLASS_HDP_SINK)
547 *p_services |= BTA_HL_SERVICE_MASK;
548 }
549 }
550
551 /*******************************************************************************
552 **
553 ** Function BTA_DmGetConnectionState
554 **
555 ** Description Returns whether the remote device is currently connected.
556 **
557 ** Returns 0 if the device is NOT connected.
558 **
559 *******************************************************************************/
BTA_DmGetConnectionState(BD_ADDR bd_addr)560 UINT16 BTA_DmGetConnectionState( BD_ADDR bd_addr )
561 {
562 tBTA_DM_PEER_DEVICE * p_dev = bta_dm_find_peer_device(bd_addr);
563 return (p_dev && p_dev->conn_state == BTA_DM_CONNECTED);
564 }
565
566
567 /*******************************************************************************
568 ** Device Identification (DI) Server Functions
569 *******************************************************************************/
570 /*******************************************************************************
571 **
572 ** Function BTA_DmSetLocalDiRecord
573 **
574 ** Description This function adds a DI record to the local SDP database.
575 **
576 ** Returns BTA_SUCCESS if record set sucessfully, otherwise error code.
577 **
578 *******************************************************************************/
BTA_DmSetLocalDiRecord(tBTA_DI_RECORD * p_device_info,UINT32 * p_handle)579 tBTA_STATUS BTA_DmSetLocalDiRecord( tBTA_DI_RECORD *p_device_info,
580 UINT32 *p_handle )
581 {
582 tBTA_STATUS status = BTA_FAILURE;
583
584 if(bta_dm_di_cb.di_num < BTA_DI_NUM_MAX)
585 {
586 if(SDP_SetLocalDiRecord((tSDP_DI_RECORD *)p_device_info, p_handle) == SDP_SUCCESS)
587 {
588 if(!p_device_info->primary_record)
589 {
590 bta_dm_di_cb.di_handle[bta_dm_di_cb.di_num] = *p_handle;
591 bta_dm_di_cb.di_num ++;
592 }
593
594 bta_sys_add_uuid(UUID_SERVCLASS_PNP_INFORMATION);
595 status = BTA_SUCCESS;
596 }
597 }
598
599 return status;
600 }
601
602 /*******************************************************************************
603 **
604 ** Function bta_dmexecutecallback
605 **
606 ** Description This function will request BTA to execute a call back in the context of BTU task
607 ** This API was named in lower case because it is only intended
608 ** for the internal customers(like BTIF).
609 **
610 ** Returns void
611 **
612 *******************************************************************************/
bta_dmexecutecallback(tBTA_DM_EXEC_CBACK * p_callback,void * p_param)613 void bta_dmexecutecallback (tBTA_DM_EXEC_CBACK* p_callback, void * p_param)
614 {
615 tBTA_DM_API_EXECUTE_CBACK *p_msg =
616 (tBTA_DM_API_EXECUTE_CBACK *)osi_malloc(sizeof(tBTA_DM_MSG));
617
618 p_msg->hdr.event = BTA_DM_API_EXECUTE_CBACK_EVT;
619 p_msg->p_param= p_param;
620 p_msg->p_exec_cback= p_callback;
621
622 bta_sys_sendmsg(p_msg);
623 }
624
625 /*******************************************************************************
626 **
627 ** Function BTA_DmAddBleKey
628 **
629 ** Description Add/modify LE device information. This function will be
630 ** normally called during host startup to restore all required
631 ** information stored in the NVRAM.
632 **
633 ** Parameters: bd_addr - BD address of the peer
634 ** p_le_key - LE key values.
635 ** key_type - LE SMP key type.
636 **
637 ** Returns BTA_SUCCESS if successful
638 ** BTA_FAIL if operation failed.
639 **
640 *******************************************************************************/
BTA_DmAddBleKey(BD_ADDR bd_addr,tBTA_LE_KEY_VALUE * p_le_key,tBTA_LE_KEY_TYPE key_type)641 void BTA_DmAddBleKey (BD_ADDR bd_addr, tBTA_LE_KEY_VALUE *p_le_key, tBTA_LE_KEY_TYPE key_type)
642 {
643 #if BLE_INCLUDED == TRUE
644
645 tBTA_DM_API_ADD_BLEKEY *p_msg =
646 (tBTA_DM_API_ADD_BLEKEY *)osi_calloc(sizeof(tBTA_DM_API_ADD_BLEKEY));
647
648 p_msg->hdr.event = BTA_DM_API_ADD_BLEKEY_EVT;
649 p_msg->key_type = key_type;
650 bdcpy(p_msg->bd_addr, bd_addr);
651 memcpy(&p_msg->blekey, p_le_key, sizeof(tBTA_LE_KEY_VALUE));
652
653 bta_sys_sendmsg(p_msg);
654 #endif
655 }
656
657 /*******************************************************************************
658 **
659 ** Function BTA_DmAddBleDevice
660 **
661 ** Description Add a BLE device. This function will be normally called
662 ** during host startup to restore all required information
663 ** for a LE device stored in the NVRAM.
664 **
665 ** Parameters: bd_addr - BD address of the peer
666 ** dev_type - Remote device's device type.
667 ** addr_type - LE device address type.
668 **
669 ** Returns void
670 **
671 *******************************************************************************/
BTA_DmAddBleDevice(BD_ADDR bd_addr,tBLE_ADDR_TYPE addr_type,tBT_DEVICE_TYPE dev_type)672 void BTA_DmAddBleDevice(BD_ADDR bd_addr, tBLE_ADDR_TYPE addr_type, tBT_DEVICE_TYPE dev_type)
673 {
674 #if BLE_INCLUDED == TRUE
675 tBTA_DM_API_ADD_BLE_DEVICE *p_msg =
676 (tBTA_DM_API_ADD_BLE_DEVICE *)osi_calloc(sizeof(tBTA_DM_API_ADD_BLE_DEVICE));
677
678 p_msg->hdr.event = BTA_DM_API_ADD_BLEDEVICE_EVT;
679 bdcpy(p_msg->bd_addr, bd_addr);
680 p_msg->addr_type = addr_type;
681 p_msg->dev_type = dev_type;
682
683 bta_sys_sendmsg(p_msg);
684 #endif
685 }
686
687 /*******************************************************************************
688 **
689 ** Function BTA_DmBlePasskeyReply
690 **
691 ** Description Send BLE SMP passkey reply.
692 **
693 ** Parameters: bd_addr - BD address of the peer
694 ** accept - passkey entry sucessful or declined.
695 ** passkey - passkey value, must be a 6 digit number,
696 ** can be lead by 0.
697 **
698 ** Returns void
699 **
700 *******************************************************************************/
BTA_DmBlePasskeyReply(BD_ADDR bd_addr,BOOLEAN accept,UINT32 passkey)701 void BTA_DmBlePasskeyReply(BD_ADDR bd_addr, BOOLEAN accept, UINT32 passkey)
702 {
703 #if BLE_INCLUDED == TRUE
704 tBTA_DM_API_PASSKEY_REPLY *p_msg =
705 (tBTA_DM_API_PASSKEY_REPLY *)osi_calloc(sizeof(tBTA_DM_API_PASSKEY_REPLY));
706
707 p_msg->hdr.event = BTA_DM_API_BLE_PASSKEY_REPLY_EVT;
708 bdcpy(p_msg->bd_addr, bd_addr);
709 p_msg->accept = accept;
710
711 if (accept)
712 p_msg->passkey = passkey;
713
714 bta_sys_sendmsg(p_msg);
715 #endif
716 }
717
718 /*******************************************************************************
719 **
720 ** Function BTA_DmBleConfirmReply
721 **
722 ** Description Send BLE SMP SC user confirmation reply.
723 **
724 ** Parameters: bd_addr - BD address of the peer
725 ** accept - numbers to compare are the same or different.
726 **
727 ** Returns void
728 **
729 *******************************************************************************/
BTA_DmBleConfirmReply(BD_ADDR bd_addr,BOOLEAN accept)730 void BTA_DmBleConfirmReply(BD_ADDR bd_addr, BOOLEAN accept)
731 {
732 #if BLE_INCLUDED == TRUE
733 tBTA_DM_API_CONFIRM *p_msg =
734 (tBTA_DM_API_CONFIRM *)osi_calloc(sizeof(tBTA_DM_API_CONFIRM));
735
736 p_msg->hdr.event = BTA_DM_API_BLE_CONFIRM_REPLY_EVT;
737 bdcpy(p_msg->bd_addr, bd_addr);
738 p_msg->accept = accept;
739
740 bta_sys_sendmsg(p_msg);
741 #endif
742 }
743
744 /*******************************************************************************
745 **
746 ** Function BTA_DmBleSecurityGrant
747 **
748 ** Description Grant security request access.
749 **
750 ** Parameters: bd_addr - BD address of the peer
751 ** res - security grant status.
752 **
753 ** Returns void
754 **
755 *******************************************************************************/
BTA_DmBleSecurityGrant(BD_ADDR bd_addr,tBTA_DM_BLE_SEC_GRANT res)756 void BTA_DmBleSecurityGrant(BD_ADDR bd_addr, tBTA_DM_BLE_SEC_GRANT res)
757 {
758 #if BLE_INCLUDED == TRUE
759 tBTA_DM_API_BLE_SEC_GRANT *p_msg =
760 (tBTA_DM_API_BLE_SEC_GRANT *)osi_calloc(sizeof(tBTA_DM_API_BLE_SEC_GRANT));
761
762 p_msg->hdr.event = BTA_DM_API_BLE_SEC_GRANT_EVT;
763 bdcpy(p_msg->bd_addr, bd_addr);
764 p_msg->res = res;
765
766 bta_sys_sendmsg(p_msg);
767 #endif
768 }
769
770 /*******************************************************************************
771 **
772 ** Function BTA_DmSetBlePrefConnParams
773 **
774 ** Description This function is called to set the preferred connection
775 ** parameters when default connection parameter is not desired.
776 **
777 ** Parameters: bd_addr - BD address of the peripheral
778 ** scan_interval - scan interval
779 ** scan_window - scan window
780 ** min_conn_int - minimum preferred connection interval
781 ** max_conn_int - maximum preferred connection interval
782 ** slave_latency - preferred slave latency
783 ** supervision_tout - preferred supervision timeout
784 **
785 **
786 ** Returns void
787 **
788 *******************************************************************************/
BTA_DmSetBlePrefConnParams(BD_ADDR bd_addr,UINT16 min_conn_int,UINT16 max_conn_int,UINT16 slave_latency,UINT16 supervision_tout)789 void BTA_DmSetBlePrefConnParams(BD_ADDR bd_addr,
790 UINT16 min_conn_int, UINT16 max_conn_int,
791 UINT16 slave_latency, UINT16 supervision_tout )
792 {
793 #if BLE_INCLUDED == TRUE
794 tBTA_DM_API_BLE_CONN_PARAMS *p_msg =
795 (tBTA_DM_API_BLE_CONN_PARAMS *)osi_calloc(sizeof(tBTA_DM_API_BLE_CONN_PARAMS));
796
797 p_msg->hdr.event = BTA_DM_API_BLE_CONN_PARAM_EVT;
798 memcpy(p_msg->peer_bda, bd_addr, BD_ADDR_LEN);
799 p_msg->conn_int_max = max_conn_int;
800 p_msg->conn_int_min = min_conn_int;
801 p_msg->slave_latency = slave_latency;
802 p_msg->supervision_tout = supervision_tout;
803
804 bta_sys_sendmsg(p_msg);
805 #endif
806 }
807
808 /*******************************************************************************
809 **
810 ** Function BTA_DmSetBleConnScanParams
811 **
812 ** Description This function is called to set scan parameters used in
813 ** BLE connection request
814 **
815 ** Parameters: scan_interval - scan interval
816 ** scan_window - scan window
817 **
818 ** Returns void
819 **
820 *******************************************************************************/
BTA_DmSetBleConnScanParams(UINT32 scan_interval,UINT32 scan_window)821 void BTA_DmSetBleConnScanParams(UINT32 scan_interval, UINT32 scan_window)
822 {
823 #if BLE_INCLUDED == TRUE
824 tBTA_DM_API_BLE_SCAN_PARAMS *p_msg =
825 (tBTA_DM_API_BLE_SCAN_PARAMS *)osi_calloc(sizeof(tBTA_DM_API_BLE_SCAN_PARAMS));
826
827 p_msg->hdr.event = BTA_DM_API_BLE_CONN_SCAN_PARAM_EVT;
828 p_msg->scan_int = scan_interval;
829 p_msg->scan_window = scan_window;
830
831 bta_sys_sendmsg(p_msg);
832 #endif // BLE_INCLUDED == TRUE
833 }
834
835 /*******************************************************************************
836 **
837 ** Function BTA_DmSetBleScanParams
838 **
839 ** Description This function is called to set scan parameters
840 **
841 ** Parameters: client_if - Client IF
842 ** scan_interval - scan interval
843 ** scan_window - scan window
844 ** scan_mode - scan mode
845 ** scan_param_setup_status_cback - Set scan param status callback
846 **
847 ** Returns void
848 **
849 *******************************************************************************/
850
851 #if BLE_INCLUDED == TRUE
BTA_DmSetBleScanParams(tGATT_IF client_if,UINT32 scan_interval,UINT32 scan_window,tBLE_SCAN_MODE scan_mode,tBLE_SCAN_PARAM_SETUP_CBACK scan_param_setup_cback)852 void BTA_DmSetBleScanParams(tGATT_IF client_if, UINT32 scan_interval,
853 UINT32 scan_window, tBLE_SCAN_MODE scan_mode,
854 tBLE_SCAN_PARAM_SETUP_CBACK scan_param_setup_cback)
855 {
856 tBTA_DM_API_BLE_SCAN_PARAMS *p_msg =
857 (tBTA_DM_API_BLE_SCAN_PARAMS *)osi_calloc(sizeof(tBTA_DM_API_BLE_SCAN_PARAMS));
858
859 p_msg->hdr.event = BTA_DM_API_BLE_SCAN_PARAM_EVT;
860 p_msg->client_if = client_if;
861 p_msg->scan_int = scan_interval;
862 p_msg->scan_window = scan_window;
863 p_msg->scan_mode = scan_mode;
864 p_msg->scan_param_setup_cback = scan_param_setup_cback;
865
866 bta_sys_sendmsg(p_msg);
867 }
868 #endif // BLE_INCLUDED == TRUE
869
870 /*******************************************************************************
871 **
872 ** Function BTA_DmSetBleAdvParams
873 **
874 ** Description This function sets the advertising parameters BLE functionality.
875 ** It is to be called when device act in peripheral or broadcaster
876 ** role.
877 **
878 **
879 ** Returns void
880 **
881 *******************************************************************************/
BTA_DmSetBleAdvParams(UINT16 adv_int_min,UINT16 adv_int_max,tBLE_BD_ADDR * p_dir_bda)882 void BTA_DmSetBleAdvParams (UINT16 adv_int_min, UINT16 adv_int_max,
883 tBLE_BD_ADDR *p_dir_bda)
884 {
885 #if BLE_INCLUDED == TRUE
886 tBTA_DM_API_BLE_ADV_PARAMS *p_msg =
887 (tBTA_DM_API_BLE_ADV_PARAMS *)osi_calloc(sizeof(tBTA_DM_API_BLE_ADV_PARAMS));
888
889 APPL_TRACE_API("BTA_DmSetBleAdvParam: %d, %d", adv_int_min, adv_int_max);
890
891 p_msg->hdr.event = BTA_DM_API_BLE_ADV_PARAM_EVT;
892 p_msg->adv_int_min = adv_int_min;
893 p_msg->adv_int_max = adv_int_max;
894
895 if (p_dir_bda != NULL) {
896 p_msg->p_dir_bda = (tBLE_BD_ADDR *)(p_msg + 1);
897 memcpy(p_msg->p_dir_bda, p_dir_bda, sizeof(tBLE_BD_ADDR));
898 }
899
900 bta_sys_sendmsg(p_msg);
901 #endif
902 }
903
904 /*******************************************************************************
905 ** BLE ADV data management API
906 ********************************************************************************/
907
908 #if BLE_INCLUDED == TRUE
909 /*******************************************************************************
910 **
911 ** Function BTA_DmBleSetAdvConfig
912 **
913 ** Description This function is called to override the BTA default ADV parameters.
914 **
915 ** Parameters data_mask: adv data mask.
916 ** p_adv_cfg: Pointer to User defined ADV data structure. This
917 ** memory space can not be freed until p_adv_data_cback
918 ** is received.
919 ** p_adv_data_cback: set adv data complete callback.
920 **
921 ** Returns None
922 **
923 *******************************************************************************/
BTA_DmBleSetAdvConfig(tBTA_BLE_AD_MASK data_mask,tBTA_BLE_ADV_DATA * p_adv_cfg,tBTA_SET_ADV_DATA_CMPL_CBACK * p_adv_data_cback)924 void BTA_DmBleSetAdvConfig (tBTA_BLE_AD_MASK data_mask, tBTA_BLE_ADV_DATA *p_adv_cfg,
925 tBTA_SET_ADV_DATA_CMPL_CBACK *p_adv_data_cback)
926 {
927 tBTA_DM_API_SET_ADV_CONFIG *p_msg = osi_calloc(sizeof(*p_msg));
928
929 p_msg->hdr.event = BTA_DM_API_BLE_SET_ADV_CONFIG_EVT;
930 p_msg->data_mask = data_mask;
931 p_msg->p_adv_data_cback = p_adv_data_cback;
932 memcpy(&p_msg->adv_cfg, p_adv_cfg, sizeof(p_msg->adv_cfg));
933
934 bta_sys_sendmsg(p_msg);
935 }
936
937 /*******************************************************************************
938 **
939 ** Function BTA_DmBleSetScanRsp
940 **
941 ** Description This function is called to override the BTA scan response.
942 **
943 ** Parameters Pointer to User defined ADV data structure
944 **
945 ** Returns None
946 **
947 *******************************************************************************/
BTA_DmBleSetScanRsp(tBTA_BLE_AD_MASK data_mask,tBTA_BLE_ADV_DATA * p_adv_cfg,tBTA_SET_ADV_DATA_CMPL_CBACK * p_adv_data_cback)948 extern void BTA_DmBleSetScanRsp (tBTA_BLE_AD_MASK data_mask, tBTA_BLE_ADV_DATA *p_adv_cfg,
949 tBTA_SET_ADV_DATA_CMPL_CBACK *p_adv_data_cback)
950 {
951 tBTA_DM_API_SET_ADV_CONFIG *p_msg = osi_calloc(sizeof(*p_msg));
952
953 p_msg->hdr.event = BTA_DM_API_BLE_SET_SCAN_RSP_EVT;
954 p_msg->data_mask = data_mask;
955 p_msg->p_adv_data_cback = p_adv_data_cback;
956 memcpy(&p_msg->adv_cfg, p_adv_cfg, sizeof(p_msg->adv_cfg));
957
958 bta_sys_sendmsg(p_msg);
959 }
960
961 /*******************************************************************************
962 **
963 ** Function BTA_DmBleSetStorageParams
964 **
965 ** Description This function is called to override the BTA scan response.
966 **
967 ** Parameters batch_scan_full_max -Max storage space (in %) allocated to full scanning
968 ** batch_scan_trunc_max -Max storage space (in %) allocated to truncated scanning
969 ** batch_scan_notify_threshold -Setup notification level based on total space
970 ** p_setup_cback - Setup callback pointer
971 ** p_thres_cback - Threshold callback pointer
972 ** p_rep_cback - Reports callback pointer
973 ** ref_value - Ref value
974 **
975 ** Returns None
976 **
977 *******************************************************************************/
BTA_DmBleSetStorageParams(UINT8 batch_scan_full_max,UINT8 batch_scan_trunc_max,UINT8 batch_scan_notify_threshold,tBTA_BLE_SCAN_SETUP_CBACK * p_setup_cback,tBTA_BLE_SCAN_THRESHOLD_CBACK * p_thres_cback,tBTA_BLE_SCAN_REP_CBACK * p_rep_cback,tBTA_DM_BLE_REF_VALUE ref_value)978 extern void BTA_DmBleSetStorageParams(UINT8 batch_scan_full_max,
979 UINT8 batch_scan_trunc_max,
980 UINT8 batch_scan_notify_threshold,
981 tBTA_BLE_SCAN_SETUP_CBACK *p_setup_cback,
982 tBTA_BLE_SCAN_THRESHOLD_CBACK *p_thres_cback,
983 tBTA_BLE_SCAN_REP_CBACK* p_rep_cback,
984 tBTA_DM_BLE_REF_VALUE ref_value)
985 {
986 tBTA_DM_API_SET_STORAGE_CONFIG *p_msg =
987 (tBTA_DM_API_SET_STORAGE_CONFIG *)osi_malloc(sizeof(tBTA_DM_API_SET_STORAGE_CONFIG));
988
989 bta_dm_cb.p_setup_cback = p_setup_cback;
990
991 p_msg->hdr.event = BTA_DM_API_BLE_SETUP_STORAGE_EVT;
992 p_msg->p_setup_cback=bta_ble_scan_setup_cb;
993 p_msg->p_thres_cback=p_thres_cback;
994 p_msg->p_read_rep_cback=p_rep_cback;
995 p_msg->ref_value = ref_value;
996 p_msg->batch_scan_full_max = batch_scan_full_max;
997 p_msg->batch_scan_trunc_max = batch_scan_trunc_max;
998 p_msg->batch_scan_notify_threshold = batch_scan_notify_threshold;
999
1000 bta_sys_sendmsg(p_msg);
1001 }
1002
1003 /*******************************************************************************
1004 **
1005 ** Function BTA_DmBleEnableBatchScan
1006 **
1007 ** Description This function is called to enable the batch scan
1008 **
1009 ** Parameters scan_mode -Batch scan mode
1010 ** scan_interval - Scan interval
1011 ** scan_window - Scan window
1012 ** discard_rule -Discard rules
1013 ** addr_type - Address type
1014 ** ref_value - Reference value
1015 **
1016 ** Returns None
1017 **
1018 *******************************************************************************/
BTA_DmBleEnableBatchScan(tBTA_BLE_BATCH_SCAN_MODE scan_mode,UINT32 scan_interval,UINT32 scan_window,tBTA_BLE_DISCARD_RULE discard_rule,tBLE_ADDR_TYPE addr_type,tBTA_DM_BLE_REF_VALUE ref_value)1019 extern void BTA_DmBleEnableBatchScan(tBTA_BLE_BATCH_SCAN_MODE scan_mode,
1020 UINT32 scan_interval, UINT32 scan_window,
1021 tBTA_BLE_DISCARD_RULE discard_rule,
1022 tBLE_ADDR_TYPE addr_type,
1023 tBTA_DM_BLE_REF_VALUE ref_value)
1024 {
1025 tBTA_DM_API_ENABLE_SCAN *p_msg =
1026 (tBTA_DM_API_ENABLE_SCAN *)osi_malloc(sizeof(tBTA_DM_API_ENABLE_SCAN));
1027
1028 p_msg->hdr.event = BTA_DM_API_BLE_ENABLE_BATCH_SCAN_EVT;
1029 p_msg->scan_mode = scan_mode;
1030 p_msg->scan_int = scan_interval;
1031 p_msg->scan_window = scan_window;
1032 p_msg->discard_rule = discard_rule;
1033 p_msg->addr_type = addr_type;
1034 p_msg->ref_value = ref_value;
1035
1036 bta_sys_sendmsg(p_msg);
1037 }
1038
1039 /*******************************************************************************
1040 **
1041 ** Function BTA_DmBleDisableBatchScan
1042 **
1043 ** Description This function is called to disable the batch scan
1044 **
1045 ** Parameters ref_value - Reference value
1046 **
1047 ** Returns None
1048 **
1049 *******************************************************************************/
BTA_DmBleDisableBatchScan(tBTA_DM_BLE_REF_VALUE ref_value)1050 extern void BTA_DmBleDisableBatchScan(tBTA_DM_BLE_REF_VALUE ref_value)
1051 {
1052 tBTA_DM_API_DISABLE_SCAN *p_msg =
1053 (tBTA_DM_API_DISABLE_SCAN *)osi_malloc(sizeof(tBTA_DM_API_DISABLE_SCAN));
1054
1055 p_msg->hdr.event = BTA_DM_API_BLE_DISABLE_BATCH_SCAN_EVT;
1056 p_msg->ref_value = ref_value;
1057
1058 bta_sys_sendmsg(p_msg);
1059 }
1060
1061 /*******************************************************************************
1062 **
1063 ** Function BTA_DmBleReadScanReports
1064 **
1065 ** Description This function is called to read scan reports
1066 **
1067 ** Parameters scan_type -Batch scan mode
1068 ** ref_value - Reference value
1069 **
1070 ** Returns None
1071 **
1072 *******************************************************************************/
BTA_DmBleReadScanReports(tBTA_BLE_BATCH_SCAN_MODE scan_type,tBTA_DM_BLE_REF_VALUE ref_value)1073 extern void BTA_DmBleReadScanReports(tBTA_BLE_BATCH_SCAN_MODE scan_type,
1074 tBTA_DM_BLE_REF_VALUE ref_value)
1075 {
1076 tBTA_DM_API_READ_SCAN_REPORTS *p_msg =
1077 (tBTA_DM_API_READ_SCAN_REPORTS *)osi_malloc(sizeof(tBTA_DM_API_READ_SCAN_REPORTS));
1078
1079 p_msg->hdr.event = BTA_DM_API_BLE_READ_SCAN_REPORTS_EVT;
1080 p_msg->scan_type = scan_type;
1081 p_msg->ref_value = ref_value;
1082
1083 bta_sys_sendmsg(p_msg);
1084 }
1085
1086 /*******************************************************************************
1087 **
1088 ** Function BTA_DmBleTrackAdvertiser
1089 **
1090 ** Description This function is called to track advertiser
1091 **
1092 ** Parameters ref_value - Reference value
1093 ** p_track_adv_cback - Track ADV callback
1094 **
1095 ** Returns None
1096 **
1097 *******************************************************************************/
BTA_DmBleTrackAdvertiser(tBTA_DM_BLE_REF_VALUE ref_value,tBTA_BLE_TRACK_ADV_CBACK * p_track_adv_cback)1098 extern void BTA_DmBleTrackAdvertiser(tBTA_DM_BLE_REF_VALUE ref_value,
1099 tBTA_BLE_TRACK_ADV_CBACK *p_track_adv_cback)
1100 {
1101 tBTA_DM_API_TRACK_ADVERTISER *p_msg =
1102 (tBTA_DM_API_TRACK_ADVERTISER *)osi_malloc(sizeof(tBTA_DM_API_TRACK_ADVERTISER));
1103
1104 p_msg->hdr.event = BTA_DM_API_BLE_TRACK_ADVERTISER_EVT;
1105 p_msg->p_track_adv_cback = p_track_adv_cback;
1106 p_msg->ref_value = ref_value;
1107
1108 bta_sys_sendmsg(p_msg);
1109 }
1110
1111 #endif
1112
1113 /*******************************************************************************
1114 ** BLE ADV data management API
1115 ********************************************************************************/
1116 #if BLE_INCLUDED == TRUE
1117
1118 /*******************************************************************************
1119 **
1120 ** Function BTA_DmBleBroadcast
1121 **
1122 ** Description This function starts or stops LE broadcasting.
1123 **
1124 ** Parameters start: start or stop broadcast.
1125 **
1126 ** Returns None
1127 **
1128 *******************************************************************************/
BTA_DmBleBroadcast(BOOLEAN start)1129 extern void BTA_DmBleBroadcast (BOOLEAN start)
1130 {
1131 tBTA_DM_API_BLE_OBSERVE *p_msg =
1132 (tBTA_DM_API_BLE_OBSERVE *)osi_calloc(sizeof(tBTA_DM_API_BLE_OBSERVE));
1133
1134 APPL_TRACE_API("BTA_DmBleBroadcast: start = %d ", start);
1135
1136 p_msg->hdr.event = BTA_DM_API_BLE_BROADCAST_EVT;
1137 p_msg->start = start;
1138
1139 bta_sys_sendmsg(p_msg);
1140 }
1141
1142 #endif
1143 /*******************************************************************************
1144 **
1145 ** Function BTA_DmBleSetBgConnType
1146 **
1147 ** Description This function is called to set BLE connectable mode for a
1148 ** peripheral device.
1149 **
1150 ** Parameters bg_conn_type: it can be auto connection, or selective connection.
1151 ** p_select_cback: callback function when selective connection procedure
1152 ** is being used.
1153 **
1154 ** Returns void
1155 **
1156 *******************************************************************************/
BTA_DmBleSetBgConnType(tBTA_DM_BLE_CONN_TYPE bg_conn_type,tBTA_DM_BLE_SEL_CBACK * p_select_cback)1157 void BTA_DmBleSetBgConnType(tBTA_DM_BLE_CONN_TYPE bg_conn_type, tBTA_DM_BLE_SEL_CBACK *p_select_cback)
1158 {
1159 #if BLE_INCLUDED == TRUE
1160 tBTA_DM_API_BLE_SET_BG_CONN_TYPE *p_msg =
1161 (tBTA_DM_API_BLE_SET_BG_CONN_TYPE *)osi_calloc(sizeof(tBTA_DM_API_BLE_SET_BG_CONN_TYPE));
1162
1163 p_msg->hdr.event = BTA_DM_API_BLE_SET_BG_CONN_TYPE;
1164 p_msg->bg_conn_type = bg_conn_type;
1165 p_msg->p_select_cback = p_select_cback;
1166
1167 bta_sys_sendmsg(p_msg);
1168 #endif
1169 }
1170
1171 /*******************************************************************************
1172 **
1173 ** Function bta_dm_discover_send_msg
1174 **
1175 ** Description This function send discover message to BTA task.
1176 **
1177 ** Returns void
1178 **
1179 *******************************************************************************/
1180 #if BLE_INCLUDED == TRUE && BTA_GATT_INCLUDED == TRUE
bta_dm_discover_send_msg(BD_ADDR bd_addr,tBTA_SERVICE_MASK_EXT * p_services,tBTA_DM_SEARCH_CBACK * p_cback,BOOLEAN sdp_search,tBTA_TRANSPORT transport)1181 static void bta_dm_discover_send_msg(BD_ADDR bd_addr, tBTA_SERVICE_MASK_EXT *p_services,
1182 tBTA_DM_SEARCH_CBACK *p_cback, BOOLEAN sdp_search,
1183 tBTA_TRANSPORT transport)
1184 {
1185 const size_t len = p_services ?
1186 (sizeof(tBTA_DM_API_DISCOVER) + sizeof(tBT_UUID) * p_services->num_uuid)
1187 : sizeof(tBTA_DM_API_DISCOVER);
1188 tBTA_DM_API_DISCOVER *p_msg = (tBTA_DM_API_DISCOVER *)osi_calloc(len);
1189
1190 p_msg->hdr.event = BTA_DM_API_DISCOVER_EVT;
1191 bdcpy(p_msg->bd_addr, bd_addr);
1192 p_msg->p_cback = p_cback;
1193 p_msg->sdp_search = sdp_search;
1194 p_msg->transport = transport;
1195
1196 if (p_services != NULL) {
1197 #if BLE_INCLUDED == TRUE && BTA_GATT_INCLUDED == TRUE
1198 p_msg->services = p_services->srvc_mask;
1199 p_msg->num_uuid = p_services->num_uuid;
1200 if (p_services->num_uuid != 0) {
1201 p_msg->p_uuid = (tBT_UUID *)(p_msg + 1);
1202 memcpy(p_msg->p_uuid, p_services->p_uuid,
1203 sizeof(tBT_UUID) * p_services->num_uuid);
1204 }
1205 #endif
1206 }
1207
1208 bta_sys_sendmsg(p_msg);
1209 }
1210 #endif
1211
1212 /*******************************************************************************
1213 **
1214 ** Function BTA_DmDiscoverByTransport
1215 **
1216 ** Description This function does service discovery on particular transport
1217 ** for services of a
1218 ** peer device. When services.num_uuid is 0, it indicates all
1219 ** GATT based services are to be searched; otherwise a list of
1220 ** UUID of interested services should be provided through
1221 ** p_services->p_uuid.
1222 **
1223 **
1224 **
1225 ** Returns void
1226 **
1227 *******************************************************************************/
BTA_DmDiscoverByTransport(BD_ADDR bd_addr,tBTA_SERVICE_MASK_EXT * p_services,tBTA_DM_SEARCH_CBACK * p_cback,BOOLEAN sdp_search,tBTA_TRANSPORT transport)1228 void BTA_DmDiscoverByTransport(BD_ADDR bd_addr, tBTA_SERVICE_MASK_EXT *p_services,
1229 tBTA_DM_SEARCH_CBACK *p_cback, BOOLEAN sdp_search,
1230 tBTA_TRANSPORT transport)
1231 {
1232 #if BLE_INCLUDED == TRUE && BTA_GATT_INCLUDED == TRUE
1233 bta_dm_discover_send_msg(bd_addr, p_services, p_cback, sdp_search, transport);
1234 #endif
1235 }
1236
1237
1238 /*******************************************************************************
1239 **
1240 ** Function BTA_DmDiscoverExt
1241 **
1242 ** Description This function does service discovery for services of a
1243 ** peer device. When services.num_uuid is 0, it indicates all
1244 ** GATT based services are to be searched; other wise a list of
1245 ** UUID of interested services should be provided through
1246 ** p_services->p_uuid.
1247 **
1248 **
1249 **
1250 ** Returns void
1251 **
1252 *******************************************************************************/
BTA_DmDiscoverExt(BD_ADDR bd_addr,tBTA_SERVICE_MASK_EXT * p_services,tBTA_DM_SEARCH_CBACK * p_cback,BOOLEAN sdp_search)1253 void BTA_DmDiscoverExt(BD_ADDR bd_addr, tBTA_SERVICE_MASK_EXT *p_services,
1254 tBTA_DM_SEARCH_CBACK *p_cback, BOOLEAN sdp_search)
1255 {
1256 #if BLE_INCLUDED == TRUE && BTA_GATT_INCLUDED == TRUE
1257 bta_dm_discover_send_msg(bd_addr, p_services, p_cback, sdp_search, BTA_TRANSPORT_UNKNOWN);
1258 #endif
1259
1260 }
1261
1262 /*******************************************************************************
1263 **
1264 ** Function BTA_DmSearchExt
1265 **
1266 ** Description This function searches for peer Bluetooth devices. It performs
1267 ** an inquiry and gets the remote name for devices. Service
1268 ** discovery is done if services is non zero
1269 **
1270 ** Parameters p_dm_inq: inquiry conditions
1271 ** p_services: if service is not empty, service discovery will be done.
1272 ** for all GATT based service condition, put num_uuid, and
1273 ** p_uuid is the pointer to the list of UUID values.
1274 ** p_cback: callback functino when search is completed.
1275 **
1276 **
1277 **
1278 ** Returns void
1279 **
1280 *******************************************************************************/
BTA_DmSearchExt(tBTA_DM_INQ * p_dm_inq,tBTA_SERVICE_MASK_EXT * p_services,tBTA_DM_SEARCH_CBACK * p_cback)1281 void BTA_DmSearchExt(tBTA_DM_INQ *p_dm_inq, tBTA_SERVICE_MASK_EXT *p_services, tBTA_DM_SEARCH_CBACK *p_cback)
1282 {
1283 #if BLE_INCLUDED == TRUE && BTA_GATT_INCLUDED == TRUE
1284 const size_t len = p_services ?
1285 (sizeof(tBTA_DM_API_SEARCH) + sizeof(tBT_UUID) * p_services->num_uuid)
1286 : sizeof(tBTA_DM_API_SEARCH);
1287 tBTA_DM_API_SEARCH *p_msg = (tBTA_DM_API_SEARCH *)osi_calloc(len);
1288
1289 p_msg->hdr.event = BTA_DM_API_SEARCH_EVT;
1290 memcpy(&p_msg->inq_params, p_dm_inq, sizeof(tBTA_DM_INQ));
1291 p_msg->p_cback = p_cback;
1292 p_msg->rs_res = BTA_DM_RS_NONE;
1293
1294 if (p_services != NULL) {
1295 p_msg->services = p_services->srvc_mask;
1296 p_msg->num_uuid = p_services->num_uuid;
1297
1298 if (p_services->num_uuid != 0) {
1299 p_msg->p_uuid = (tBT_UUID *)(p_msg + 1);
1300 memcpy(p_msg->p_uuid, p_services->p_uuid,
1301 sizeof(tBT_UUID) * p_services->num_uuid);
1302 } else {
1303 p_msg->p_uuid = NULL;
1304 }
1305 }
1306
1307 bta_sys_sendmsg(p_msg);
1308 #else
1309 UNUSED(p_dm_inq);
1310 UNUSED(p_services);
1311 UNUSED(p_cback);
1312 #endif
1313 }
1314 /*******************************************************************************
1315 **
1316 ** Function BTA_DmBleUpdateConnectionParam
1317 **
1318 ** Description Update connection parameters, can only be used when connection is up.
1319 **
1320 ** Parameters: bd_addr - BD address of the peer
1321 ** min_int - minimum connection interval, [0x0004~ 0x4000]
1322 ** max_int - maximum connection interval, [0x0004~ 0x4000]
1323 ** latency - slave latency [0 ~ 500]
1324 ** timeout - supervision timeout [0x000a ~ 0xc80]
1325 **
1326 ** Returns void
1327 **
1328 *******************************************************************************/
BTA_DmBleUpdateConnectionParam(BD_ADDR bd_addr,UINT16 min_int,UINT16 max_int,UINT16 latency,UINT16 timeout)1329 void BTA_DmBleUpdateConnectionParam(BD_ADDR bd_addr, UINT16 min_int,
1330 UINT16 max_int, UINT16 latency,
1331 UINT16 timeout)
1332 {
1333 #if BLE_INCLUDED == TRUE
1334 tBTA_DM_API_UPDATE_CONN_PARAM *p_msg =
1335 (tBTA_DM_API_UPDATE_CONN_PARAM *)osi_calloc(sizeof(tBTA_DM_API_UPDATE_CONN_PARAM));
1336
1337 p_msg->hdr.event = BTA_DM_API_UPDATE_CONN_PARAM_EVT;
1338 bdcpy(p_msg->bd_addr, bd_addr);
1339 p_msg->min_int = min_int;
1340 p_msg->max_int = max_int;
1341 p_msg->latency = latency;
1342 p_msg->timeout = timeout;
1343
1344 bta_sys_sendmsg(p_msg);
1345 #endif
1346 }
1347
1348 /*******************************************************************************
1349 **
1350 ** Function BTA_DmBleConfigLocalPrivacy
1351 **
1352 ** Description Enable/disable privacy on the local device
1353 **
1354 ** Parameters: privacy_enable - enable/disabe privacy on remote device.
1355 **
1356 ** Returns void
1357 **
1358 *******************************************************************************/
BTA_DmBleConfigLocalPrivacy(BOOLEAN privacy_enable)1359 void BTA_DmBleConfigLocalPrivacy(BOOLEAN privacy_enable)
1360 {
1361 #if BLE_INCLUDED == TRUE && BLE_PRIVACY_SPT == TRUE
1362 tBTA_DM_API_LOCAL_PRIVACY *p_msg =
1363 (tBTA_DM_API_LOCAL_PRIVACY *)osi_calloc(sizeof(tBTA_DM_API_ENABLE_PRIVACY));
1364
1365 p_msg->hdr.event = BTA_DM_API_LOCAL_PRIVACY_EVT;
1366 p_msg->privacy_enable = privacy_enable;
1367
1368 bta_sys_sendmsg(p_msg);
1369 #else
1370 UNUSED (privacy_enable);
1371 #endif
1372 }
1373
1374 #if BLE_INCLUDED == TRUE
1375 /*******************************************************************************
1376 **
1377 ** Function BTA_BleEnableAdvInstance
1378 **
1379 ** Description This function enable a Multi-ADV instance with the specififed
1380 ** adv parameters
1381 **
1382 ** Parameters p_params: pointer to the adv parameter structure.
1383 ** p_cback: callback function associated to this adv instance.
1384 ** p_ref: reference data pointer to this adv instance.
1385 **
1386 ** Returns BTA_SUCCESS if command started sucessfully; otherwise failure.
1387 **
1388 *******************************************************************************/
BTA_BleEnableAdvInstance(tBTA_BLE_ADV_PARAMS * p_params,tBTA_BLE_MULTI_ADV_CBACK * p_cback,void * p_ref)1389 void BTA_BleEnableAdvInstance (tBTA_BLE_ADV_PARAMS *p_params,
1390 tBTA_BLE_MULTI_ADV_CBACK *p_cback,
1391 void *p_ref)
1392 {
1393 const size_t len = sizeof(tBTA_BLE_ADV_PARAMS) +
1394 sizeof(tBTA_DM_API_BLE_MULTI_ADV_ENB);
1395 tBTA_DM_API_BLE_MULTI_ADV_ENB *p_msg =
1396 (tBTA_DM_API_BLE_MULTI_ADV_ENB *)osi_calloc(len);
1397
1398 APPL_TRACE_API("%s", __func__);
1399
1400 p_msg->hdr.event = BTA_DM_API_BLE_MULTI_ADV_ENB_EVT;
1401 p_msg->p_cback = (void *)p_cback;
1402 if (p_params != NULL) {
1403 p_msg->p_params = (void *)(p_msg + 1);
1404 memcpy(p_msg->p_params, p_params, sizeof(tBTA_BLE_ADV_PARAMS));
1405 }
1406 p_msg->p_ref = p_ref;
1407
1408 bta_sys_sendmsg(p_msg);
1409 }
1410
1411 /*******************************************************************************
1412 **
1413 ** Function BTA_BleUpdateAdvInstParam
1414 **
1415 ** Description This function update a Multi-ADV instance with the specififed
1416 ** adv parameters.
1417 **
1418 ** Parameters inst_id: Adv instance to update the parameter.
1419 ** p_params: pointer to the adv parameter structure.
1420 **
1421 ** Returns BTA_SUCCESS if command started sucessfully; otherwise failure.
1422 **
1423 *******************************************************************************/
BTA_BleUpdateAdvInstParam(UINT8 inst_id,tBTA_BLE_ADV_PARAMS * p_params)1424 void BTA_BleUpdateAdvInstParam (UINT8 inst_id, tBTA_BLE_ADV_PARAMS *p_params)
1425 {
1426 const size_t len = sizeof(tBTA_BLE_ADV_PARAMS) +
1427 sizeof(tBTA_DM_API_BLE_MULTI_ADV_PARAM);
1428 tBTA_DM_API_BLE_MULTI_ADV_PARAM *p_msg =
1429 (tBTA_DM_API_BLE_MULTI_ADV_PARAM *)osi_calloc(len);
1430
1431 APPL_TRACE_API("%s", __func__);
1432
1433 p_msg->hdr.event = BTA_DM_API_BLE_MULTI_ADV_PARAM_UPD_EVT;
1434 p_msg->inst_id = inst_id;
1435 p_msg->p_params = (void *)(p_msg + 1);
1436 memcpy(p_msg->p_params, p_params, sizeof(tBTA_BLE_ADV_PARAMS));
1437
1438 bta_sys_sendmsg(p_msg);
1439 }
1440
1441 /*******************************************************************************
1442 **
1443 ** Function BTA_BleCfgAdvInstData
1444 **
1445 ** Description This function configure a Multi-ADV instance with the specififed
1446 ** adv data or scan response data.
1447 **
1448 ** Parameter inst_id: Adv instance to configure the adv data or scan response.
1449 ** is_scan_rsp: is the data scan response or adv data.
1450 ** data_mask: adv data type as bit mask.
1451 ** p_data: pointer to the ADV data structure tBTA_BLE_ADV_DATA. This
1452 ** memory space can not be freed until BTA_BLE_MULTI_ADV_DATA_EVT
1453 ** is sent to application.
1454 **
1455 ** Returns BTA_SUCCESS if command started sucessfully; otherwise failure.
1456 **
1457 *******************************************************************************/
BTA_BleCfgAdvInstData(UINT8 inst_id,BOOLEAN is_scan_rsp,tBTA_BLE_AD_MASK data_mask,tBTA_BLE_ADV_DATA * p_data)1458 void BTA_BleCfgAdvInstData (UINT8 inst_id, BOOLEAN is_scan_rsp,
1459 tBTA_BLE_AD_MASK data_mask,
1460 tBTA_BLE_ADV_DATA *p_data)
1461 {
1462 tBTA_DM_API_BLE_MULTI_ADV_DATA *p_msg = osi_calloc(sizeof(*p_msg));
1463
1464 p_msg->hdr.event = BTA_DM_API_BLE_MULTI_ADV_DATA_EVT;
1465 p_msg->inst_id = inst_id;
1466 p_msg->is_scan_rsp = is_scan_rsp;
1467 p_msg->data_mask = data_mask;
1468 memcpy(&p_msg->data, p_data, sizeof(p_msg->data));
1469
1470 bta_sys_sendmsg(p_msg);
1471 }
1472
1473 /*******************************************************************************
1474 **
1475 ** Function BTA_BleDisableAdvInstance
1476 **
1477 ** Description This function disable a Multi-ADV instance.
1478 **
1479 ** Parameter inst_id: instance ID to disable.
1480 **
1481 ** Returns BTA_SUCCESS if command started sucessfully; otherwise failure.
1482 **
1483 *******************************************************************************/
BTA_BleDisableAdvInstance(UINT8 inst_id)1484 void BTA_BleDisableAdvInstance(UINT8 inst_id)
1485 {
1486 tBTA_DM_API_BLE_MULTI_ADV_DISABLE *p_msg =
1487 (tBTA_DM_API_BLE_MULTI_ADV_DISABLE *)osi_calloc(sizeof(tBTA_DM_API_BLE_MULTI_ADV_DISABLE));
1488
1489 APPL_TRACE_API("%s: %d", __func__, inst_id);
1490
1491 p_msg->hdr.event = BTA_DM_API_BLE_MULTI_ADV_DISABLE_EVT;
1492 p_msg->inst_id = inst_id;
1493
1494 bta_sys_sendmsg(p_msg);
1495 }
1496
1497 /*******************************************************************************
1498 **
1499 ** Function BTA_DmBleCfgFilterCondition
1500 **
1501 ** Description This function is called to configure the adv data payload filter
1502 ** condition.
1503 **
1504 ** Parameters action: to read/write/clear
1505 ** cond_type: filter condition type
1506 ** filt_index - Filter index
1507 ** p_cond: filter condition parameter
1508 ** p_cmpl_back - Command completed callback
1509 ** ref_value - Reference value
1510 **
1511 ** Returns void
1512 **
1513 *******************************************************************************/
BTA_DmBleCfgFilterCondition(tBTA_DM_BLE_SCAN_COND_OP action,tBTA_DM_BLE_PF_COND_TYPE cond_type,tBTA_DM_BLE_PF_FILT_INDEX filt_index,tBTA_DM_BLE_PF_COND_PARAM * p_cond,tBTA_DM_BLE_PF_CFG_CBACK * p_cmpl_cback,tBTA_DM_BLE_REF_VALUE ref_value)1514 void BTA_DmBleCfgFilterCondition(tBTA_DM_BLE_SCAN_COND_OP action,
1515 tBTA_DM_BLE_PF_COND_TYPE cond_type,
1516 tBTA_DM_BLE_PF_FILT_INDEX filt_index,
1517 tBTA_DM_BLE_PF_COND_PARAM *p_cond,
1518 tBTA_DM_BLE_PF_CFG_CBACK *p_cmpl_cback,
1519 tBTA_DM_BLE_REF_VALUE ref_value)
1520 {
1521 #if BLE_ANDROID_CONTROLLER_SCAN_FILTER == TRUE
1522 tBTA_DM_API_CFG_FILTER_COND *p_msg;
1523 APPL_TRACE_API ("BTA_DmBleCfgFilterCondition: %d, %d", action, cond_type);
1524
1525 UINT16 len = sizeof(tBTA_DM_API_CFG_FILTER_COND) +
1526 sizeof(tBTA_DM_BLE_PF_COND_PARAM);
1527 UINT8 *p;
1528
1529 if (NULL != p_cond)
1530 {
1531 switch(cond_type)
1532 {
1533 case BTA_DM_BLE_PF_SRVC_DATA_PATTERN:
1534 case BTA_DM_BLE_PF_MANU_DATA:
1535 /* Length of pattern and pattern mask and other elements in */
1536 /* tBTA_DM_BLE_PF_MANU_COND */
1537 len += ((p_cond->manu_data.data_len) * 2) +
1538 sizeof(UINT16) + sizeof(UINT16) + sizeof(UINT8);
1539 break;
1540
1541 case BTA_DM_BLE_PF_LOCAL_NAME:
1542 len += ((p_cond->local_name.data_len) + sizeof(UINT8));
1543 break;
1544
1545 case BTM_BLE_PF_SRVC_UUID:
1546 case BTM_BLE_PF_SRVC_SOL_UUID:
1547 len += sizeof(tBLE_BD_ADDR) + sizeof(tBTA_DM_BLE_PF_COND_MASK);
1548 break;
1549
1550 default:
1551 break;
1552 }
1553 }
1554
1555 p_msg = (tBTA_DM_API_CFG_FILTER_COND *)osi_calloc(len);
1556 p_msg->hdr.event = BTA_DM_API_CFG_FILTER_COND_EVT;
1557 p_msg->action = action;
1558 p_msg->cond_type = cond_type;
1559 p_msg->filt_index = filt_index;
1560 p_msg->p_filt_cfg_cback = p_cmpl_cback;
1561 p_msg->ref_value = ref_value;
1562 if (p_cond) {
1563 p_msg->p_cond_param = (tBTA_DM_BLE_PF_COND_PARAM *)(p_msg + 1);
1564 memcpy(p_msg->p_cond_param, p_cond, sizeof(tBTA_DM_BLE_PF_COND_PARAM));
1565
1566 p = (UINT8 *)(p_msg->p_cond_param + 1);
1567
1568 if (cond_type == BTA_DM_BLE_PF_SRVC_DATA_PATTERN ||
1569 cond_type == BTA_DM_BLE_PF_MANU_DATA) {
1570 p_msg->p_cond_param->manu_data.p_pattern = p;
1571 p_msg->p_cond_param->manu_data.data_len = p_cond->manu_data.data_len;
1572 memcpy(p_msg->p_cond_param->manu_data.p_pattern, p_cond->manu_data.p_pattern,
1573 p_cond->manu_data.data_len);
1574 p += p_cond->manu_data.data_len;
1575
1576 if (cond_type == BTA_DM_BLE_PF_MANU_DATA) {
1577 p_msg->p_cond_param->manu_data.company_id_mask =
1578 p_cond->manu_data.company_id_mask;
1579 if ( p_cond->manu_data.p_pattern_mask != NULL) {
1580 p_msg->p_cond_param->manu_data.p_pattern_mask = p;
1581 memcpy(p_msg->p_cond_param->manu_data.p_pattern_mask,
1582 p_cond->manu_data.p_pattern_mask,
1583 p_cond->manu_data.data_len);
1584 }
1585 }
1586 } else if (cond_type == BTA_DM_BLE_PF_LOCAL_NAME) {
1587 p_msg->p_cond_param->local_name.p_data = p;
1588 p_msg->p_cond_param->local_name.data_len =
1589 p_cond->local_name.data_len;
1590 memcpy(p_msg->p_cond_param->local_name.p_data,
1591 p_cond->local_name.p_data, p_cond->local_name.data_len);
1592 } else if (cond_type == BTM_BLE_PF_SRVC_UUID ||
1593 cond_type == BTM_BLE_PF_SRVC_SOL_UUID) {
1594 if (p_cond->srvc_uuid.p_target_addr != NULL) {
1595 p_msg->p_cond_param->srvc_uuid.p_target_addr = (tBLE_BD_ADDR *)(p);
1596 p_msg->p_cond_param->srvc_uuid.p_target_addr->type =
1597 p_cond->srvc_uuid.p_target_addr->type;
1598 memcpy(p_msg->p_cond_param->srvc_uuid.p_target_addr->bda,
1599 p_cond->srvc_uuid.p_target_addr->bda, BD_ADDR_LEN);
1600 p = (UINT8 *)(p_msg->p_cond_param->srvc_uuid.p_target_addr + 1);
1601 }
1602 if (p_cond->srvc_uuid.p_uuid_mask) {
1603 p_msg->p_cond_param->srvc_uuid.p_uuid_mask = (tBTA_DM_BLE_PF_COND_MASK *)p;
1604 memcpy(p_msg->p_cond_param->srvc_uuid.p_uuid_mask,
1605 p_cond->srvc_uuid.p_uuid_mask,
1606 sizeof(tBTA_DM_BLE_PF_COND_MASK));
1607 }
1608 }
1609 }
1610
1611 bta_sys_sendmsg(p_msg);
1612
1613 #else
1614 UNUSED(action);
1615 UNUSED(cond_type);
1616 UNUSED(filt_index);
1617 UNUSED(p_cond);
1618 UNUSED(p_cmpl_cback);
1619 UNUSED(ref_value);
1620 #endif
1621 }
1622
1623 /*******************************************************************************
1624 **
1625 ** Function BTA_DmBleScanFilterSetup
1626 **
1627 ** Description This function is called to setup the adv data payload filter param
1628 **
1629 ** Parameters p_target: enable the filter condition on a target device; if NULL
1630 ** filt_index - Filter index
1631 ** p_filt_params -Filter parameters
1632 ** ref_value - Reference value
1633 ** action - Add, delete or clear
1634 ** p_cmpl_back - Command completed callback
1635 **
1636 ** Returns void
1637 **
1638 *******************************************************************************/
BTA_DmBleScanFilterSetup(UINT8 action,tBTA_DM_BLE_PF_FILT_INDEX filt_index,tBTA_DM_BLE_PF_FILT_PARAMS * p_filt_params,tBLE_BD_ADDR * p_target,tBTA_DM_BLE_PF_PARAM_CBACK * p_cmpl_cback,tBTA_DM_BLE_REF_VALUE ref_value)1639 void BTA_DmBleScanFilterSetup(UINT8 action,
1640 tBTA_DM_BLE_PF_FILT_INDEX filt_index,
1641 tBTA_DM_BLE_PF_FILT_PARAMS *p_filt_params,
1642 tBLE_BD_ADDR *p_target,
1643 tBTA_DM_BLE_PF_PARAM_CBACK *p_cmpl_cback,
1644 tBTA_DM_BLE_REF_VALUE ref_value)
1645 {
1646 #if BLE_ANDROID_CONTROLLER_SCAN_FILTER == TRUE
1647 const size_t len = sizeof(tBTA_DM_API_SCAN_FILTER_PARAM_SETUP) +
1648 sizeof(tBLE_BD_ADDR);
1649 tBTA_DM_API_SCAN_FILTER_PARAM_SETUP *p_msg =
1650 (tBTA_DM_API_SCAN_FILTER_PARAM_SETUP *)osi_calloc(len);
1651
1652 APPL_TRACE_API("%s: %d", __func__, action);
1653
1654 p_msg->hdr.event = BTA_DM_API_SCAN_FILTER_SETUP_EVT;
1655 p_msg->action = action;
1656 p_msg->filt_index = filt_index;
1657 if (p_filt_params) {
1658 memcpy(&p_msg->filt_params, p_filt_params,
1659 sizeof(tBTA_DM_BLE_PF_FILT_PARAMS));
1660 }
1661 p_msg->p_filt_param_cback = p_cmpl_cback;
1662 p_msg->ref_value = ref_value;
1663
1664 if (p_target) {
1665 p_msg->p_target = (tBLE_BD_ADDR *)(p_msg + 1);
1666 memcpy(p_msg->p_target, p_target, sizeof(tBLE_BD_ADDR));
1667 }
1668
1669 bta_sys_sendmsg(p_msg);
1670
1671 #else
1672 UNUSED(action);
1673 UNUSED(filt_index);
1674 UNUSED(p_filt_params);
1675 UNUSED(p_target);
1676 UNUSED(p_cmpl_cback);
1677 UNUSED(ref_value);
1678 #endif
1679 }
1680
1681 /*******************************************************************************
1682 **
1683 ** Function BTA_DmBleGetEnergyInfo
1684 **
1685 ** Description This function is called to obtain the energy info
1686 **
1687 ** Parameters p_cmpl_cback - Command complete callback
1688 **
1689 ** Returns void
1690 **
1691 *******************************************************************************/
BTA_DmBleGetEnergyInfo(tBTA_BLE_ENERGY_INFO_CBACK * p_cmpl_cback)1692 void BTA_DmBleGetEnergyInfo(tBTA_BLE_ENERGY_INFO_CBACK *p_cmpl_cback)
1693 {
1694 const size_t len = sizeof(tBTA_DM_API_ENERGY_INFO) + sizeof(tBLE_BD_ADDR);
1695 tBTA_DM_API_ENERGY_INFO *p_msg = (tBTA_DM_API_ENERGY_INFO *)osi_calloc(len);
1696
1697 APPL_TRACE_API("%s", __func__);
1698
1699 p_msg->hdr.event = BTA_DM_API_BLE_ENERGY_INFO_EVT;
1700 p_msg->p_energy_info_cback = p_cmpl_cback;
1701
1702 bta_sys_sendmsg(p_msg);
1703 }
1704
1705 /*******************************************************************************
1706 **
1707 ** Function BTA_DmEnableScanFilter
1708 **
1709 ** Description This function is called to enable the adv data payload filter
1710 **
1711 ** Parameters action - enable or disable the APCF feature
1712 ** p_cmpl_cback - Command completed callback
1713 ** ref_value - Reference value
1714 **
1715 ** Returns void
1716 **
1717 *******************************************************************************/
BTA_DmEnableScanFilter(UINT8 action,tBTA_DM_BLE_PF_STATUS_CBACK * p_cmpl_cback,tBTA_DM_BLE_REF_VALUE ref_value)1718 void BTA_DmEnableScanFilter(UINT8 action, tBTA_DM_BLE_PF_STATUS_CBACK *p_cmpl_cback,
1719 tBTA_DM_BLE_REF_VALUE ref_value)
1720 {
1721 #if BLE_ANDROID_CONTROLLER_SCAN_FILTER == TRUE
1722 const size_t len = sizeof(tBTA_DM_API_ENABLE_SCAN_FILTER) +
1723 sizeof(tBLE_BD_ADDR);
1724 tBTA_DM_API_ENABLE_SCAN_FILTER *p_msg =
1725 (tBTA_DM_API_ENABLE_SCAN_FILTER *)osi_calloc(len);
1726
1727 APPL_TRACE_API("%s: %d", __func__, action);
1728
1729 p_msg->hdr.event = BTA_DM_API_SCAN_FILTER_ENABLE_EVT;
1730 p_msg->action = action;
1731 p_msg->ref_value = ref_value;
1732 p_msg->p_filt_status_cback = p_cmpl_cback;
1733
1734 bta_sys_sendmsg(p_msg);
1735
1736 #else
1737 UNUSED(action);
1738 UNUSED(p_cmpl_cback);
1739 UNUSED(ref_value);
1740 #endif
1741 }
1742
1743 /*******************************************************************************
1744 **
1745 ** Function BTA_DmBleUpdateConnectionParams
1746 **
1747 ** Description Update connection parameters, can only be used when connection is up.
1748 **
1749 ** Parameters: bd_addr - BD address of the peer
1750 ** min_int - minimum connection interval, [0x0004~ 0x4000]
1751 ** max_int - maximum connection interval, [0x0004~ 0x4000]
1752 ** latency - slave latency [0 ~ 500]
1753 ** timeout - supervision timeout [0x000a ~ 0xc80]
1754 **
1755 ** Returns void
1756 **
1757 *******************************************************************************/
BTA_DmBleUpdateConnectionParams(BD_ADDR bd_addr,UINT16 min_int,UINT16 max_int,UINT16 latency,UINT16 timeout)1758 void BTA_DmBleUpdateConnectionParams(BD_ADDR bd_addr, UINT16 min_int, UINT16 max_int,
1759 UINT16 latency, UINT16 timeout)
1760 {
1761 tBTA_DM_API_UPDATE_CONN_PARAM *p_msg =
1762 (tBTA_DM_API_UPDATE_CONN_PARAM *)osi_calloc(sizeof(tBTA_DM_API_UPDATE_CONN_PARAM));
1763
1764 p_msg->hdr.event = BTA_DM_API_UPDATE_CONN_PARAM_EVT;
1765 bdcpy(p_msg->bd_addr, bd_addr);
1766 p_msg->min_int = min_int;
1767 p_msg->max_int = max_int;
1768 p_msg->latency = latency;
1769 p_msg->timeout = timeout;
1770
1771 bta_sys_sendmsg(p_msg);
1772 }
1773
1774 /*******************************************************************************
1775 **
1776 ** Function BTA_DmBleSetDataLength
1777 **
1778 ** Description This function is to set maximum LE data packet size
1779 **
1780 ** Returns void
1781 **
1782 **
1783 *******************************************************************************/
BTA_DmBleSetDataLength(BD_ADDR remote_device,UINT16 tx_data_length)1784 void BTA_DmBleSetDataLength(BD_ADDR remote_device, UINT16 tx_data_length)
1785 {
1786 tBTA_DM_API_BLE_SET_DATA_LENGTH *p_msg =
1787 (tBTA_DM_API_BLE_SET_DATA_LENGTH *)osi_malloc(sizeof(tBTA_DM_API_BLE_SET_DATA_LENGTH));
1788
1789 bdcpy(p_msg->remote_bda, remote_device);
1790 p_msg->hdr.event = BTA_DM_API_SET_DATA_LENGTH_EVT;
1791 p_msg->tx_data_length = tx_data_length;
1792
1793 bta_sys_sendmsg(p_msg);
1794 }
1795
1796 #endif
1797
1798 /*******************************************************************************
1799 **
1800 ** Function BTA_DmSetEncryption
1801 **
1802 ** Description This function is called to ensure that connection is
1803 ** encrypted. Should be called only on an open connection.
1804 ** Typically only needed for connections that first want to
1805 ** bring up unencrypted links, then later encrypt them.
1806 **
1807 ** Parameters: bd_addr - Address of the peer device
1808 ** transport - transport of the link to be encruypted
1809 ** p_callback - Pointer to callback function to indicat the
1810 ** link encryption status
1811 ** sec_act - This is the security action to indicate
1812 ** what knid of BLE security level is required for
1813 ** the BLE link if the BLE is supported
1814 ** Note: This parameter is ignored for the BR/EDR link
1815 ** or the BLE is not supported
1816 **
1817 ** Returns void
1818 **
1819 *******************************************************************************/
BTA_DmSetEncryption(BD_ADDR bd_addr,tBTA_TRANSPORT transport,tBTA_DM_ENCRYPT_CBACK * p_callback,tBTA_DM_BLE_SEC_ACT sec_act)1820 void BTA_DmSetEncryption(BD_ADDR bd_addr, tBTA_TRANSPORT transport, tBTA_DM_ENCRYPT_CBACK *p_callback,
1821 tBTA_DM_BLE_SEC_ACT sec_act)
1822 {
1823 tBTA_DM_API_SET_ENCRYPTION *p_msg = (tBTA_DM_API_SET_ENCRYPTION *)osi_calloc(sizeof(tBTA_DM_API_SET_ENCRYPTION));
1824
1825 APPL_TRACE_API("%s", __func__);
1826
1827 p_msg->hdr.event = BTA_DM_API_SET_ENCRYPTION_EVT;
1828 memcpy(p_msg->bd_addr, bd_addr, BD_ADDR_LEN);
1829 p_msg->transport = transport;
1830 p_msg->p_callback = p_callback;
1831 p_msg->sec_act = sec_act;
1832
1833 bta_sys_sendmsg(p_msg);
1834 }
1835
1836 /*******************************************************************************
1837 **
1838 ** Function BTA_DmCloseACL
1839 **
1840 ** Description This function force to close an ACL connection and remove the
1841 ** device from the security database list of known devices.
1842 **
1843 ** Parameters: bd_addr - Address of the peer device
1844 ** remove_dev - remove device or not after link down
1845 **
1846 ** Returns void
1847 **
1848 *******************************************************************************/
BTA_DmCloseACL(BD_ADDR bd_addr,BOOLEAN remove_dev,tBTA_TRANSPORT transport)1849 void BTA_DmCloseACL(BD_ADDR bd_addr, BOOLEAN remove_dev, tBTA_TRANSPORT transport)
1850 {
1851 tBTA_DM_API_REMOVE_ACL *p_msg =
1852 (tBTA_DM_API_REMOVE_ACL *)osi_calloc(sizeof(tBTA_DM_API_REMOVE_ACL));
1853
1854 APPL_TRACE_API("%s", __func__);
1855
1856 p_msg->hdr.event = BTA_DM_API_REMOVE_ACL_EVT;
1857 memcpy(p_msg->bd_addr, bd_addr, BD_ADDR_LEN);
1858 p_msg->remove_dev = remove_dev;
1859 p_msg->transport = transport;
1860
1861 bta_sys_sendmsg(p_msg);
1862 }
1863
1864 #if BLE_INCLUDED == TRUE
1865 /*******************************************************************************
1866 **
1867 ** Function BTA_DmBleObserve
1868 **
1869 ** Description This procedure keep the device listening for advertising
1870 ** events from a broadcast device.
1871 **
1872 ** Parameters start: start or stop observe.
1873 **
1874 ** Returns void
1875
1876 **
1877 ** Returns void.
1878 **
1879 *******************************************************************************/
BTA_DmBleObserve(BOOLEAN start,UINT8 duration,tBTA_DM_SEARCH_CBACK * p_results_cb)1880 extern void BTA_DmBleObserve(BOOLEAN start, UINT8 duration,
1881 tBTA_DM_SEARCH_CBACK *p_results_cb)
1882 {
1883 tBTA_DM_API_BLE_OBSERVE *p_msg =
1884 (tBTA_DM_API_BLE_OBSERVE *)osi_calloc(sizeof(tBTA_DM_API_BLE_OBSERVE));
1885
1886 APPL_TRACE_API("%s:start = %d ", __func__, start);
1887
1888 p_msg->hdr.event = BTA_DM_API_BLE_OBSERVE_EVT;
1889 p_msg->start = start;
1890 p_msg->duration = duration;
1891 p_msg->p_cback = p_results_cb;
1892
1893 bta_sys_sendmsg(p_msg);
1894 }
1895
1896 /*******************************************************************************
1897 **
1898 ** Function BTA_VendorInit
1899 **
1900 ** Description This function initializes vendor specific
1901 **
1902 ** Returns void
1903 **
1904 *******************************************************************************/
BTA_VendorInit(void)1905 void BTA_VendorInit (void)
1906 {
1907 APPL_TRACE_API("BTA_VendorInit");
1908 }
1909
1910 /*******************************************************************************
1911 **
1912 ** Function BTA_VendorCleanup
1913 **
1914 ** Description This function frees up Broadcom specific VS specific dynamic memory
1915 **
1916 ** Returns void
1917 **
1918 *******************************************************************************/
BTA_VendorCleanup(void)1919 void BTA_VendorCleanup (void)
1920 {
1921 tBTM_BLE_VSC_CB cmn_ble_vsc_cb;
1922 BTM_BleGetVendorCapabilities(&cmn_ble_vsc_cb);
1923
1924 #if (BLE_INCLUDED == TRUE && BLE_ANDROID_CONTROLLER_SCAN_FILTER == TRUE)
1925 if (cmn_ble_vsc_cb.max_filter > 0)
1926 {
1927 btm_ble_adv_filter_cleanup();
1928 #if BLE_PRIVACY_SPT == TRUE
1929 btm_ble_resolving_list_cleanup ();
1930 #endif
1931 }
1932
1933 if (cmn_ble_vsc_cb.tot_scan_results_strg > 0)
1934 btm_ble_batchscan_cleanup();
1935 #endif
1936
1937 if(cmn_ble_vsc_cb.adv_inst_max > 0)
1938 btm_ble_multi_adv_cleanup();
1939 }
1940
1941 #endif
1942