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