1/****************************************************************************** 2 * 3 * Copyright (C) 2003-2012 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 "gki.h" 26#include "bd.h" 27#include "bta_sys.h" 28#include "bta_api.h" 29#include "bta_dm_int.h" 30#include "bta_sys_int.h" 31#include "btm_api.h" 32#include "btm_int.h" 33#include <string.h> 34 35/***************************************************************************** 36** Constants 37*****************************************************************************/ 38 39static const tBTA_SYS_REG bta_dm_reg = 40{ 41 bta_dm_sm_execute, 42 bta_dm_sm_disable 43}; 44 45static 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*******************************************************************************/ 62tBTA_STATUS BTA_EnableBluetooth(tBTA_DM_SEC_CBACK *p_cback) 63{ 64 65 tBTA_DM_API_ENABLE *p_msg; 66 67 /* Bluetooth disabling is in progress */ 68 if (bta_dm_cb.disabling) 69 return BTA_FAILURE; 70 71 memset(&bta_dm_cb, 0, sizeof(bta_dm_cb)); 72 73 GKI_sched_lock(); 74 bta_sys_register (BTA_ID_DM, &bta_dm_reg ); 75 bta_sys_register (BTA_ID_DM_SEARCH, &bta_dm_search_reg ); 76 77 /* if UUID list is not provided as static data */ 78 bta_sys_eir_register(bta_dm_eir_update_uuid); 79 80 GKI_sched_unlock(); 81 82 if ((p_msg = (tBTA_DM_API_ENABLE *) GKI_getbuf(sizeof(tBTA_DM_API_ENABLE))) != NULL) 83 { 84 p_msg->hdr.event = BTA_DM_API_ENABLE_EVT; 85 p_msg->p_sec_cback = p_cback; 86 bta_sys_sendmsg(p_msg); 87 return BTA_SUCCESS; 88 } 89 return BTA_FAILURE; 90 91} 92 93/******************************************************************************* 94** 95** Function BTA_DisableBluetooth 96** 97** Description Disables bluetooth service. This function is called when 98** the application no longer needs bluetooth service 99** 100** Returns void 101** 102*******************************************************************************/ 103tBTA_STATUS BTA_DisableBluetooth(void) 104{ 105 106 BT_HDR *p_msg; 107 108 if ((p_msg = (BT_HDR *) GKI_getbuf(sizeof(BT_HDR))) != NULL) 109 { 110 p_msg->event = BTA_DM_API_DISABLE_EVT; 111 bta_sys_sendmsg(p_msg); 112 } 113 else 114 { 115 return BTA_FAILURE; 116 } 117 118 return BTA_SUCCESS; 119} 120 121/******************************************************************************* 122** 123** Function BTA_EnableTestMode 124** 125** Description Enables bluetooth device under test mode 126** 127** 128** Returns tBTA_STATUS 129** 130*******************************************************************************/ 131tBTA_STATUS BTA_EnableTestMode(void) 132{ 133 BT_HDR *p_msg; 134 135 APPL_TRACE_API0("BTA_EnableTestMode"); 136 137 if ((p_msg = (BT_HDR *) GKI_getbuf(sizeof(BT_HDR))) != NULL) 138 { 139 p_msg->event = BTA_DM_API_ENABLE_TEST_MODE_EVT; 140 bta_sys_sendmsg(p_msg); 141 return BTA_SUCCESS; 142 } 143 return BTA_FAILURE; 144} 145 146/******************************************************************************* 147** 148** Function BTA_DisableTestMode 149** 150** Description Disable bluetooth device under test mode 151** 152** 153** Returns None 154** 155*******************************************************************************/ 156void BTA_DisableTestMode(void) 157{ 158 BT_HDR *p_msg; 159 160 APPL_TRACE_API0("BTA_DisableTestMode"); 161 162 if ((p_msg = (BT_HDR *) GKI_getbuf(sizeof(BT_HDR))) != NULL) 163 { 164 p_msg->event = BTA_DM_API_DISABLE_TEST_MODE_EVT; 165 bta_sys_sendmsg(p_msg); 166 } 167} 168 169/******************************************************************************* 170** 171** Function BTA_DmIsDeviceUp 172** 173** Description Called during startup to check whether the bluetooth module 174** is up and ready 175** 176** Returns BOOLEAN 177** 178*******************************************************************************/ 179BOOLEAN BTA_DmIsDeviceUp(void) 180{ 181 182 BOOLEAN status; 183 184 GKI_sched_lock(); 185 status = BTM_IsDeviceUp(); 186 GKI_sched_unlock(); 187 return status; 188 189} 190 191/******************************************************************************* 192** 193** Function BTA_DmSetDeviceName 194** 195** Description This function sets the Bluetooth name of local device 196** 197** 198** Returns void 199** 200*******************************************************************************/ 201void BTA_DmSetDeviceName(char *p_name) 202{ 203 204 tBTA_DM_API_SET_NAME *p_msg; 205 206 if ((p_msg = (tBTA_DM_API_SET_NAME *) GKI_getbuf(sizeof(tBTA_DM_API_SET_NAME))) != NULL) 207 { 208 p_msg->hdr.event = BTA_DM_API_SET_NAME_EVT; 209 /* truncate the name if needed */ 210 BCM_STRNCPY_S(p_msg->name, sizeof(p_msg->name), p_name, BD_NAME_LEN-1); 211 p_msg->name[BD_NAME_LEN-1]=0; 212 213 bta_sys_sendmsg(p_msg); 214 } 215 216 217} 218 219/******************************************************************************* 220** 221** Function BTA_DmSetVisibility 222** 223** Description This function sets the Bluetooth connectable, 224** discoverable, pairable and conn paired only modes of local device 225** 226** 227** Returns void 228** 229*******************************************************************************/ 230void BTA_DmSetVisibility(tBTA_DM_DISC disc_mode, tBTA_DM_CONN conn_mode, UINT8 pairable_mode, UINT8 conn_filter ) 231{ 232 233 tBTA_DM_API_SET_VISIBILITY *p_msg; 234 235 if ((p_msg = (tBTA_DM_API_SET_VISIBILITY *) GKI_getbuf(sizeof(tBTA_DM_MSG))) != NULL) 236 { 237 p_msg->hdr.event = BTA_DM_API_SET_VISIBILITY_EVT; 238 p_msg->disc_mode = disc_mode; 239 p_msg->conn_mode = conn_mode; 240 p_msg->pair_mode = pairable_mode; 241 p_msg->conn_paired_only = conn_filter; 242 243 244 bta_sys_sendmsg(p_msg); 245 } 246 247 248} 249 250/******************************************************************************* 251** 252** Function BTA_DmSetScanParam 253** 254** Description This function sets the parameters for page scan and 255** inquiry scan. 256** 257** 258** Returns void 259** 260*******************************************************************************/ 261void BTA_DmSetScanParam (UINT16 page_scan_interval, UINT16 page_scan_window, 262 UINT16 inquiry_scan_interval, UINT16 inquiry_scan_window) 263{ 264 APPL_TRACE_API4 ("BTA_DmSetScanParam: %d, %d, %d, %d", 265 page_scan_interval, page_scan_window, 266 inquiry_scan_interval, inquiry_scan_window); 267 268 bta_dm_cb.page_scan_interval = page_scan_interval; 269 bta_dm_cb.page_scan_window = page_scan_window; 270 bta_dm_cb.inquiry_scan_interval = inquiry_scan_interval; 271 bta_dm_cb.inquiry_scan_window = inquiry_scan_window; 272} 273 274/******************************************************************************* 275** 276** Function BTA_DmSetAfhChannels 277** 278** Description This function sets the AFH first and 279** last disable channel, so channels within 280** that range are disabled. 281** 282** Returns void 283** 284*******************************************************************************/ 285void BTA_DmSetAfhChannels(UINT8 first, UINT8 last) 286{ 287 288 tBTA_DM_API_SET_AFH_CHANNELS_EVT *p_msg; 289 290 if ((p_msg = (tBTA_DM_API_SET_AFH_CHANNELS_EVT *) GKI_getbuf(sizeof(tBTA_DM_MSG))) != NULL) 291 { 292 p_msg->hdr.event = BTA_DM_API_SET_AFH_CHANNELS_EVT; 293 p_msg->first = first; 294 p_msg->last = last; 295 bta_sys_sendmsg(p_msg); 296 } 297 298 299} 300 301/******************************************************************************* 302** 303** Function BTA_SetAfhChannelAssessment 304** 305** Description This function is called to set the channel assessment mode on or off 306** 307** Returns status 308** 309*******************************************************************************/ 310void BTA_DmSetAfhChannelAssessment (BOOLEAN enable_or_disable) 311{ 312 tBTA_DM_API_SET_AFH_CHANNEL_ASSESSMENT *p_msg; 313 314 if ((p_msg = (tBTA_DM_API_SET_AFH_CHANNEL_ASSESSMENT *) GKI_getbuf(sizeof(tBTA_DM_API_SET_AFH_CHANNEL_ASSESSMENT))) != NULL) 315 { 316 p_msg->hdr.event = BTA_DM_API_SET_AFH_CHANNEL_ASSESMENT_EVT; 317 p_msg->enable_or_disable = enable_or_disable; 318 bta_sys_sendmsg(p_msg); 319 } 320} 321 322/******************************************************************************* 323** 324** Function BTA_DmVendorSpecificCommand 325** 326** Description This function sends the vendor specific command 327** to the controller 328** 329** 330** Returns tBTA_STATUS 331** 332*******************************************************************************/ 333tBTA_STATUS BTA_DmVendorSpecificCommand (UINT16 opcode, UINT8 param_len, 334 UINT8 *p_param_buf, 335 tBTA_VENDOR_CMPL_CBACK *p_cback) 336{ 337 338 tBTA_DM_API_VENDOR_SPECIFIC_COMMAND *p_msg; 339 UINT16 size; 340 341 /* If p_cback is NULL, Notify application */ 342 if (p_cback == NULL) 343 { 344 return (BTA_FAILURE); 345 } 346 else 347 { 348 size = sizeof (tBTA_DM_API_VENDOR_SPECIFIC_COMMAND) + param_len; 349 if ((p_msg = (tBTA_DM_API_VENDOR_SPECIFIC_COMMAND *) GKI_getbuf(size)) != NULL) 350 { 351 p_msg->hdr.event = BTA_DM_API_VENDOR_SPECIFIC_COMMAND_EVT; 352 p_msg->opcode = opcode; 353 p_msg->p_param_buf = (UINT8 *)(p_msg + 1); 354 p_msg->p_cback = p_cback; 355 356 if (p_param_buf && param_len) 357 { 358 memcpy (p_msg->p_param_buf, p_param_buf, param_len); 359 p_msg->param_len = param_len; 360 } 361 else 362 { 363 p_msg->param_len = 0; 364 p_msg->p_param_buf = NULL; 365 366 } 367 368 bta_sys_sendmsg(p_msg); 369 } 370 return (BTA_SUCCESS); 371 } 372} 373/******************************************************************************* 374** 375** Function BTA_DmSearch 376** 377** Description This function searches for peer Bluetooth devices. It performs 378** an inquiry and gets the remote name for devices. Service 379** discovery is done if services is non zero 380** 381** 382** Returns void 383** 384*******************************************************************************/ 385void BTA_DmSearch(tBTA_DM_INQ *p_dm_inq, tBTA_SERVICE_MASK services, tBTA_DM_SEARCH_CBACK *p_cback) 386{ 387 388 tBTA_DM_API_SEARCH *p_msg; 389 390 if ((p_msg = (tBTA_DM_API_SEARCH *) GKI_getbuf(sizeof(tBTA_DM_API_SEARCH))) != NULL) 391 { 392 memset(p_msg, 0, sizeof(tBTA_DM_API_SEARCH)); 393 394 p_msg->hdr.event = BTA_DM_API_SEARCH_EVT; 395 memcpy(&p_msg->inq_params, p_dm_inq, sizeof(tBTA_DM_INQ)); 396 p_msg->services = services; 397 p_msg->p_cback = p_cback; 398 p_msg->rs_res = BTA_DM_RS_NONE; 399 bta_sys_sendmsg(p_msg); 400 } 401 402} 403 404 405/******************************************************************************* 406** 407** Function BTA_DmSearchCancel 408** 409** Description This function cancels a search initiated by BTA_DmSearch 410** 411** 412** Returns void 413** 414*******************************************************************************/ 415void BTA_DmSearchCancel(void) 416{ 417 BT_HDR *p_msg; 418 419 if ((p_msg = (BT_HDR *) GKI_getbuf(sizeof(BT_HDR))) != NULL) 420 { 421 p_msg->event = BTA_DM_API_SEARCH_CANCEL_EVT; 422 bta_sys_sendmsg(p_msg); 423 } 424 425} 426 427/******************************************************************************* 428** 429** Function BTA_DmDiscover 430** 431** Description This function does service discovery for services of a 432** peer device 433** 434** 435** Returns void 436** 437*******************************************************************************/ 438void BTA_DmDiscover(BD_ADDR bd_addr, tBTA_SERVICE_MASK services, 439 tBTA_DM_SEARCH_CBACK *p_cback, BOOLEAN sdp_search) 440{ 441 tBTA_DM_API_DISCOVER *p_msg; 442 443 if ((p_msg = (tBTA_DM_API_DISCOVER *) GKI_getbuf(sizeof(tBTA_DM_API_DISCOVER))) != NULL) 444 { 445 memset(p_msg, 0, sizeof(tBTA_DM_API_DISCOVER)); 446 447 p_msg->hdr.event = BTA_DM_API_DISCOVER_EVT; 448 bdcpy(p_msg->bd_addr, bd_addr); 449 p_msg->services = services; 450 p_msg->p_cback = p_cback; 451 p_msg->sdp_search = sdp_search; 452 bta_sys_sendmsg(p_msg); 453 } 454 455} 456 457/******************************************************************************* 458** 459** Function BTA_DmDiscoverUUID 460** 461** Description This function does service discovery for services of a 462** peer device 463** 464** 465** Returns void 466** 467*******************************************************************************/ 468void BTA_DmDiscoverUUID(BD_ADDR bd_addr, tSDP_UUID *uuid, 469 tBTA_DM_SEARCH_CBACK *p_cback, BOOLEAN sdp_search) 470{ 471 tBTA_DM_API_DISCOVER *p_msg; 472 473 if ((p_msg = (tBTA_DM_API_DISCOVER *) GKI_getbuf(sizeof(tBTA_DM_API_DISCOVER))) != NULL) 474 { 475 p_msg->hdr.event = BTA_DM_API_DISCOVER_EVT; 476 bdcpy(p_msg->bd_addr, bd_addr); 477 p_msg->services = BTA_USER_SERVICE_MASK; //Not exposed at API level 478 p_msg->p_cback = p_cback; 479 p_msg->sdp_search = sdp_search; 480 481#if BLE_INCLUDED == TRUE && BTA_GATT_INCLUDED == TRUE 482 p_msg->num_uuid = 0; 483 p_msg->p_uuid = NULL; 484#endif 485 memcpy( &p_msg->uuid, uuid, sizeof(tSDP_UUID) ); 486 bta_sys_sendmsg(p_msg); 487 } 488 489} 490/******************************************************************************* 491** 492** Function BTA_DmIsMaster 493** 494** Description This function checks if the local device is the master of 495** the link to the given device 496** 497** Returns TRUE if master. 498** FALSE if not. 499** 500*******************************************************************************/ 501BOOLEAN BTA_DmIsMaster(BD_ADDR bd_addr) 502{ 503 BOOLEAN is_master = FALSE; 504 UINT8 link_role; 505 506 BTM_GetRole(bd_addr, &link_role); 507 APPL_TRACE_API1("BTA_DmIsMaster role:x%x", link_role); 508 if(link_role == BTM_ROLE_MASTER) 509 { 510 is_master = TRUE; 511 } 512 return is_master; 513} 514 515/******************************************************************************* 516** 517** Function BTA_DmBond 518** 519** Description This function initiates a bonding procedure with a peer 520** device 521** 522** 523** Returns void 524** 525*******************************************************************************/ 526void BTA_DmBond(BD_ADDR bd_addr) 527{ 528 tBTA_DM_API_BOND *p_msg; 529 530 if ((p_msg = (tBTA_DM_API_BOND *) GKI_getbuf(sizeof(tBTA_DM_API_BOND))) != NULL) 531 { 532 p_msg->hdr.event = BTA_DM_API_BOND_EVT; 533 bdcpy(p_msg->bd_addr, bd_addr); 534 bta_sys_sendmsg(p_msg); 535 } 536 537 538} 539 540/******************************************************************************* 541** 542** Function BTA_DmBondCancel 543** 544** Description This function cancels the bonding procedure with a peer 545** device 546** 547** 548** Returns void 549** 550*******************************************************************************/ 551void BTA_DmBondCancel(BD_ADDR bd_addr) 552{ 553 tBTA_DM_API_BOND_CANCEL *p_msg; 554 555 if ((p_msg = (tBTA_DM_API_BOND_CANCEL *) GKI_getbuf(sizeof(tBTA_DM_API_BOND_CANCEL))) != NULL) 556 { 557 p_msg->hdr.event = BTA_DM_API_BOND_CANCEL_EVT; 558 bdcpy(p_msg->bd_addr, bd_addr); 559 bta_sys_sendmsg(p_msg); 560 } 561 562 563} 564 565/******************************************************************************* 566** 567** Function BTA_DmPinReply 568** 569** Description This function provides a pincode for a remote device when 570** one is requested by DM through BTA_DM_PIN_REQ_EVT 571** 572** 573** Returns void 574** 575*******************************************************************************/ 576void BTA_DmPinReply(BD_ADDR bd_addr, BOOLEAN accept, UINT8 pin_len, UINT8 *p_pin) 577 578{ 579 tBTA_DM_API_PIN_REPLY *p_msg; 580 581 if ((p_msg = (tBTA_DM_API_PIN_REPLY *) GKI_getbuf(sizeof(tBTA_DM_API_PIN_REPLY))) != NULL) 582 { 583 p_msg->hdr.event = BTA_DM_API_PIN_REPLY_EVT; 584 bdcpy(p_msg->bd_addr, bd_addr); 585 p_msg->accept = accept; 586 if(accept) 587 { 588 p_msg->pin_len = pin_len; 589 memcpy(p_msg->p_pin, p_pin, pin_len); 590 } 591 bta_sys_sendmsg(p_msg); 592 } 593 594} 595 596/******************************************************************************* 597** 598** Function BTA_DmLinkPolicy 599** 600** Description This function sets/clears the link policy mask to the given 601** bd_addr. 602** If clearing the sniff or park mode mask, the link is put 603** in active mode. 604** 605** Returns void 606** 607*******************************************************************************/ 608void BTA_DmLinkPolicy(BD_ADDR bd_addr, tBTA_DM_LP_MASK policy_mask, 609 BOOLEAN set) 610{ 611 tBTA_DM_API_LINK_POLICY *p_msg; 612 613 if ((p_msg = (tBTA_DM_API_LINK_POLICY *) GKI_getbuf(sizeof(tBTA_DM_API_LINK_POLICY))) != NULL) 614 { 615 p_msg->hdr.event = BTA_DM_API_LINK_POLICY_EVT; 616 bdcpy(p_msg->bd_addr, bd_addr); 617 p_msg->policy_mask = policy_mask; 618 p_msg->set = set; 619 bta_sys_sendmsg(p_msg); 620 } 621} 622 623 624#if (BTM_OOB_INCLUDED == TRUE) 625/******************************************************************************* 626** 627** Function BTA_DmLocalOob 628** 629** Description This function retrieves the OOB data from local controller. 630** The result is reported by bta_dm_co_loc_oob(). 631** 632** Returns void 633** 634*******************************************************************************/ 635void BTA_DmLocalOob(void) 636{ 637 tBTA_DM_API_LOC_OOB *p_msg; 638 639 if ((p_msg = (tBTA_DM_API_LOC_OOB *) GKI_getbuf(sizeof(tBTA_DM_API_LOC_OOB))) != NULL) 640 { 641 p_msg->hdr.event = BTA_DM_API_LOC_OOB_EVT; 642 bta_sys_sendmsg(p_msg); 643 } 644} 645#endif /* BTM_OOB_INCLUDED */ 646/******************************************************************************* 647** 648** Function BTA_DmConfirm 649** 650** Description This function accepts or rejects the numerical value of the 651** Simple Pairing process on BTA_DM_SP_CFM_REQ_EVT 652** 653** Returns void 654** 655*******************************************************************************/ 656void BTA_DmConfirm(BD_ADDR bd_addr, BOOLEAN accept) 657{ 658 tBTA_DM_API_CONFIRM *p_msg; 659 660 if ((p_msg = (tBTA_DM_API_CONFIRM *) GKI_getbuf(sizeof(tBTA_DM_API_CONFIRM))) != NULL) 661 { 662 p_msg->hdr.event = BTA_DM_API_CONFIRM_EVT; 663 bdcpy(p_msg->bd_addr, bd_addr); 664 p_msg->accept = accept; 665 bta_sys_sendmsg(p_msg); 666 } 667} 668 669/******************************************************************************* 670** 671** Function BTA_DmPasskeyCancel 672** 673** Description This function is called to cancel the simple pairing process 674** reported by BTA_DM_SP_KEY_NOTIF_EVT 675** 676** Returns void 677** 678*******************************************************************************/ 679#if (BTM_LOCAL_IO_CAPS != BTM_IO_CAP_NONE) 680void BTA_DmPasskeyCancel(BD_ADDR bd_addr) 681{ 682 tBTA_DM_API_PASKY_CANCEL *p_msg; 683 684 if ((p_msg = (tBTA_DM_API_PASKY_CANCEL *) \ 685 GKI_getbuf(sizeof(tBTA_DM_API_PASKY_CANCEL))) != NULL) 686 { 687 p_msg->hdr.event = BTA_DM_API_PASKY_CANCEL_EVT; 688 bdcpy(p_msg->bd_addr, bd_addr); 689 bta_sys_sendmsg(p_msg); 690 } 691} 692#endif 693 694 695/******************************************************************************* 696** 697** Function BTA_DmAddDevice 698** 699** Description This function adds a device to the security database list of 700** peer device 701** 702** 703** Returns void 704** 705*******************************************************************************/ 706void BTA_DmAddDevice(BD_ADDR bd_addr, DEV_CLASS dev_class, LINK_KEY link_key, 707 tBTA_SERVICE_MASK trusted_mask, BOOLEAN is_trusted, 708 UINT8 key_type, tBTA_IO_CAP io_cap) 709{ 710 711 tBTA_DM_API_ADD_DEVICE *p_msg; 712 713 if ((p_msg = (tBTA_DM_API_ADD_DEVICE *) GKI_getbuf(sizeof(tBTA_DM_API_ADD_DEVICE))) != NULL) 714 { 715 memset (p_msg, 0, sizeof(tBTA_DM_API_ADD_DEVICE)); 716 717 p_msg->hdr.event = BTA_DM_API_ADD_DEVICE_EVT; 718 bdcpy(p_msg->bd_addr, bd_addr); 719 p_msg->tm = trusted_mask; 720 p_msg->is_trusted = is_trusted; 721 p_msg->io_cap = io_cap; 722 723 if (link_key) 724 { 725 p_msg->link_key_known = TRUE; 726 p_msg->key_type = key_type; 727 memcpy(p_msg->link_key, link_key, LINK_KEY_LEN); 728 } 729 730 /* Load device class if specified */ 731 if (dev_class) 732 { 733 p_msg->dc_known = TRUE; 734 memcpy (p_msg->dc, dev_class, DEV_CLASS_LEN); 735 } 736 737 memset (p_msg->bd_name, 0, BD_NAME_LEN); 738 memset (p_msg->features, 0, sizeof (p_msg->features)); 739 740 bta_sys_sendmsg(p_msg); 741 } 742} 743 744 745/******************************************************************************* 746** 747** Function BTA_DmRemoveDevice 748** 749** Description This function removes a device fromthe security database list of 750** peer device 751** 752** 753** Returns void 754** 755*******************************************************************************/ 756tBTA_STATUS BTA_DmRemoveDevice(BD_ADDR bd_addr) 757{ 758 tBTA_DM_API_REMOVE_DEVICE *p_msg; 759 760 if ((p_msg = (tBTA_DM_API_REMOVE_DEVICE *) GKI_getbuf(sizeof(tBTA_DM_API_REMOVE_DEVICE))) != NULL) 761 { 762 memset (p_msg, 0, sizeof(tBTA_DM_API_REMOVE_DEVICE)); 763 764 p_msg->hdr.event = BTA_DM_API_REMOVE_DEVICE_EVT; 765 bdcpy(p_msg->bd_addr, bd_addr); 766 bta_sys_sendmsg(p_msg); 767 } 768 else 769 { 770 return BTA_FAILURE; 771 } 772 773 return BTA_SUCCESS; 774} 775 776/******************************************************************************* 777** 778** Function BTA_DmAddDevWithName 779** 780** Description This function is newer version of BTA_DmAddDevice() 781** which added bd_name and features as input parameters. 782** 783** 784** Returns void 785** 786*******************************************************************************/ 787void BTA_DmAddDevWithName (BD_ADDR bd_addr, DEV_CLASS dev_class, 788 BD_NAME bd_name, UINT8 *features, 789 LINK_KEY link_key, tBTA_SERVICE_MASK trusted_mask, 790 BOOLEAN is_trusted, UINT8 key_type, tBTA_IO_CAP io_cap) 791{ 792 tBTA_DM_API_ADD_DEVICE *p_msg; 793 794 if ((p_msg = (tBTA_DM_API_ADD_DEVICE *) GKI_getbuf(sizeof(tBTA_DM_API_ADD_DEVICE))) != NULL) 795 { 796 memset (p_msg, 0, sizeof(tBTA_DM_API_ADD_DEVICE)); 797 798 p_msg->hdr.event = BTA_DM_API_ADD_DEVICE_EVT; 799 bdcpy(p_msg->bd_addr, bd_addr); 800 p_msg->tm = trusted_mask; 801 p_msg->is_trusted = is_trusted; 802 p_msg->io_cap = io_cap; 803 804 if (link_key) 805 { 806 p_msg->link_key_known = TRUE; 807 p_msg->key_type = key_type; 808 memcpy(p_msg->link_key, link_key, LINK_KEY_LEN); 809 } 810 811 /* Load device class if specified */ 812 if (dev_class) 813 { 814 p_msg->dc_known = TRUE; 815 memcpy (p_msg->dc, dev_class, DEV_CLASS_LEN); 816 } 817 818 if (bd_name) 819 memcpy(p_msg->bd_name, bd_name, BD_NAME_LEN); 820 821 if (features) 822 memcpy(p_msg->features, features, sizeof(p_msg->features)); 823 824 bta_sys_sendmsg(p_msg); 825 } 826} 827 828/******************************************************************************* 829** 830** Function BTA_DmAuthorizeReply 831** 832** Description This function provides an authorization reply when authorization 833** is requested by BTA through BTA_DM_AUTHORIZE_EVT 834** 835** 836** Returns tBTA_STATUS 837** 838*******************************************************************************/ 839void BTA_DmAuthorizeReply(BD_ADDR bd_addr, tBTA_SERVICE_ID service, tBTA_AUTH_RESP response) 840{ 841 842 tBTA_DM_API_AUTH_REPLY *p_msg; 843 844 if ((p_msg = (tBTA_DM_API_AUTH_REPLY *) GKI_getbuf(sizeof(tBTA_DM_API_AUTH_REPLY))) != NULL) 845 { 846 p_msg->hdr.event = BTA_DM_API_AUTH_REPLY_EVT; 847 bdcpy(p_msg->bd_addr, bd_addr); 848 p_msg->service = service; 849 p_msg->response = response; 850 851 bta_sys_sendmsg(p_msg); 852 } 853 854} 855 856/******************************************************************************* 857** 858** Function BTA_DmSignalStrength 859** 860** Description This function initiates RSSI and channnel quality 861** measurments. BTA_DM_SIG_STRENGTH_EVT is sent to 862** application with the values of RSSI and channel 863** quality 864** 865** 866** Returns void 867** 868*******************************************************************************/ 869void BTA_DmSignalStrength(tBTA_SIG_STRENGTH_MASK mask, UINT16 period, BOOLEAN start) 870{ 871 872 tBTA_API_DM_SIG_STRENGTH *p_msg; 873 874 if ((p_msg = (tBTA_API_DM_SIG_STRENGTH *) GKI_getbuf(sizeof(tBTA_API_DM_SIG_STRENGTH))) != NULL) 875 { 876 p_msg->hdr.event = BTA_API_DM_SIG_STRENGTH_EVT; 877 p_msg->mask = mask; 878 p_msg->period = period; 879 p_msg->start = start; 880 881 bta_sys_sendmsg(p_msg); 882 } 883 884 885} 886 887/******************************************************************************* 888** 889** Function BTA_DmWriteInqTxPower 890** 891** Description This command is used to write the inquiry transmit power level 892** used to transmit the inquiry (ID) data packets. 893** 894** Parameters tx_power - tx inquiry power to use, valid value is -70 ~ 20 895 896** Returns void 897** 898*******************************************************************************/ 899void BTA_DmWriteInqTxPower(INT8 tx_power) 900{ 901 902 tBTA_API_DM_TX_INQPWR *p_msg; 903 904 if ((p_msg = (tBTA_API_DM_TX_INQPWR *) GKI_getbuf(sizeof(tBTA_API_DM_TX_INQPWR))) != NULL) 905 { 906 p_msg->hdr.event = BTA_DM_API_TX_INQPWR_EVT; 907 p_msg->tx_power = tx_power; 908 909 bta_sys_sendmsg(p_msg); 910 } 911} 912 913 914/******************************************************************************* 915** 916** Function BTA_DmEirAddUUID 917** 918** Description This function is called to add UUID into EIR. 919** 920** Parameters tBT_UUID - UUID 921** 922** Returns None 923** 924*******************************************************************************/ 925void BTA_DmEirAddUUID (tBT_UUID *p_uuid) 926{ 927#if ( BTM_EIR_SERVER_INCLUDED == TRUE )&&( BTA_EIR_CANNED_UUID_LIST != TRUE )&&(BTA_EIR_SERVER_NUM_CUSTOM_UUID > 0) 928 tBTA_DM_API_UPDATE_EIR_UUID *p_msg; 929 930 if ((p_msg = (tBTA_DM_API_UPDATE_EIR_UUID *) GKI_getbuf(sizeof(tBTA_DM_API_UPDATE_EIR_UUID))) != NULL) 931 { 932 p_msg->hdr.event = BTA_DM_API_UPDATE_EIR_UUID_EVT; 933 p_msg->is_add = TRUE; 934 memcpy (&(p_msg->uuid), p_uuid, sizeof(tBT_UUID)); 935 936 bta_sys_sendmsg(p_msg); 937 } 938#endif 939} 940 941/******************************************************************************* 942** 943** Function BTA_DmEirRemoveUUID 944** 945** Description This function is called to remove UUID from EIR. 946** 947** Parameters tBT_UUID - UUID 948** 949** Returns None 950** 951*******************************************************************************/ 952void BTA_DmEirRemoveUUID (tBT_UUID *p_uuid) 953{ 954#if ( BTM_EIR_SERVER_INCLUDED == TRUE )&&( BTA_EIR_CANNED_UUID_LIST != TRUE )&&(BTA_EIR_SERVER_NUM_CUSTOM_UUID > 0) 955 tBTA_DM_API_UPDATE_EIR_UUID *p_msg; 956 957 if ((p_msg = (tBTA_DM_API_UPDATE_EIR_UUID *) GKI_getbuf(sizeof(tBTA_DM_API_UPDATE_EIR_UUID))) != NULL) 958 { 959 p_msg->hdr.event = BTA_DM_API_UPDATE_EIR_UUID_EVT; 960 p_msg->is_add = FALSE; 961 memcpy (&(p_msg->uuid), p_uuid, sizeof(tBT_UUID)); 962 963 bta_sys_sendmsg(p_msg); 964 } 965#endif 966} 967 968/******************************************************************************* 969** 970** Function BTA_DmSetEIRConfig 971** 972** Description This function is called to override the BTA default EIR parameters. 973** This funciton is only valid in a system where BTU & App task 974** are in the same memory space. 975** 976** Parameters Pointer to User defined EIR config 977** 978** Returns None 979** 980*******************************************************************************/ 981void BTA_DmSetEIRConfig (tBTA_DM_EIR_CONF *p_eir_cfg) 982{ 983#if (BTM_EIR_SERVER_INCLUDED == TRUE) 984 tBTA_DM_API_SET_EIR_CONFIG *p_msg; 985 986 if ((p_msg = (tBTA_DM_API_SET_EIR_CONFIG *) GKI_getbuf(sizeof(tBTA_DM_API_SET_EIR_CONFIG))) != NULL) 987 { 988 p_msg->hdr.event = BTA_DM_API_SET_EIR_CONFIG_EVT; 989 p_msg->p_eir_cfg = p_eir_cfg; 990 991 bta_sys_sendmsg(p_msg); 992 } 993#endif 994} 995 996/******************************************************************************* 997** 998** Function BTA_CheckEirData 999** 1000** Description This function is called to get EIR data from significant part. 1001** 1002** Parameters p_eir - pointer of EIR significant part 1003** type - finding EIR data type 1004** p_length - return the length of EIR data 1005** 1006** Returns pointer of EIR data 1007** 1008*******************************************************************************/ 1009UINT8 *BTA_CheckEirData( UINT8 *p_eir, UINT8 type, UINT8 *p_length ) 1010{ 1011#if ( BTM_EIR_CLIENT_INCLUDED == TRUE ) 1012 return BTM_CheckEirData( p_eir, type, p_length ); 1013#else 1014 return NULL; 1015#endif 1016} 1017 1018/******************************************************************************* 1019** 1020** Function BTA_GetEirService 1021** 1022** Description This function is called to get BTA service mask from EIR. 1023** 1024** Parameters p_eir - pointer of EIR significant part 1025** p_services - return the BTA service mask 1026** 1027** Returns None 1028** 1029*******************************************************************************/ 1030extern const UINT16 bta_service_id_to_uuid_lkup_tbl []; 1031void BTA_GetEirService( UINT8 *p_eir, tBTA_SERVICE_MASK *p_services ) 1032{ 1033#if ( BTM_EIR_CLIENT_INCLUDED == TRUE ) 1034 UINT8 xx, yy; 1035 UINT8 num_uuid, max_num_uuid = 32; 1036 UINT8 uuid_list[32*LEN_UUID_16]; 1037 UINT16 *p_uuid16 = (UINT16 *)uuid_list; 1038 tBTA_SERVICE_MASK mask; 1039 1040 BTM_GetEirUuidList( p_eir, LEN_UUID_16, &num_uuid, uuid_list, max_num_uuid); 1041 for( xx = 0; xx < num_uuid; xx++ ) 1042 { 1043 mask = 1; 1044 for( yy = 0; yy < BTA_MAX_SERVICE_ID; yy++ ) 1045 { 1046 if( *(p_uuid16 + xx) == bta_service_id_to_uuid_lkup_tbl[yy] ) 1047 { 1048 *p_services |= mask; 1049 break; 1050 } 1051 mask <<= 1; 1052 } 1053 1054 /* for HSP v1.2 only device */ 1055 if (*(p_uuid16 + xx) == UUID_SERVCLASS_HEADSET_HS) 1056 *p_services |= BTA_HSP_SERVICE_MASK; 1057 1058 if (*(p_uuid16 + xx) == UUID_SERVCLASS_HDP_SOURCE) 1059 *p_services |= BTA_HL_SERVICE_MASK; 1060 1061 if (*(p_uuid16 + xx) == UUID_SERVCLASS_HDP_SINK) 1062 *p_services |= BTA_HL_SERVICE_MASK; 1063 } 1064#endif 1065} 1066 1067/******************************************************************************* 1068** 1069** Function BTA_DmUseSsr 1070** 1071** Description This function is called to check if the connected peer device 1072** supports SSR or not. 1073** 1074** Returns TRUE, if SSR is supported 1075** 1076*******************************************************************************/ 1077BOOLEAN BTA_DmUseSsr( BD_ADDR bd_addr ) 1078{ 1079 BOOLEAN use_ssr = FALSE; 1080 tBTA_DM_PEER_DEVICE * p_dev = bta_dm_find_peer_device(bd_addr); 1081 if(p_dev && (p_dev->info & BTA_DM_DI_USE_SSR) ) 1082 use_ssr = TRUE; 1083 return use_ssr; 1084} 1085 1086/******************************************************************************* 1087** Device Identification (DI) Server Functions 1088*******************************************************************************/ 1089/******************************************************************************* 1090** 1091** Function BTA_DmSetLocalDiRecord 1092** 1093** Description This function adds a DI record to the local SDP database. 1094** 1095** Returns BTA_SUCCESS if record set sucessfully, otherwise error code. 1096** 1097*******************************************************************************/ 1098tBTA_STATUS BTA_DmSetLocalDiRecord( tBTA_DI_RECORD *p_device_info, 1099 UINT32 *p_handle ) 1100{ 1101 tBTA_STATUS status = BTA_FAILURE; 1102 1103 if(bta_dm_di_cb.di_num < BTA_DI_NUM_MAX) 1104 { 1105 if(SDP_SetLocalDiRecord((tSDP_DI_RECORD *)p_device_info, p_handle) == SDP_SUCCESS) 1106 { 1107 if(!p_device_info->primary_record) 1108 { 1109 bta_dm_di_cb.di_handle[bta_dm_di_cb.di_num] = *p_handle; 1110 bta_dm_di_cb.di_num ++; 1111 } 1112 1113 bta_sys_add_uuid(UUID_SERVCLASS_PNP_INFORMATION); 1114 status = BTA_SUCCESS; 1115 } 1116 } 1117 1118 return status; 1119} 1120 1121/******************************************************************************* 1122** 1123** Function BTA_DmGetLocalDiRecord 1124** 1125** Description Get a specified DI record to the local SDP database. If no 1126** record handle is provided, the primary DI record will be 1127** returned. 1128** 1129** Fills in the device information of the record 1130** p_handle - if p_handle == 0, the primary record is returned 1131** 1132** Returns BTA_SUCCESS if record set sucessfully, otherwise error code. 1133** 1134*******************************************************************************/ 1135tBTA_STATUS BTA_DmGetLocalDiRecord( tBTA_DI_GET_RECORD *p_device_info, 1136 UINT32 *p_handle ) 1137{ 1138 UINT16 status; 1139 1140 status = SDP_GetLocalDiRecord(p_device_info, p_handle); 1141 1142 if (status == SDP_SUCCESS) 1143 return BTA_SUCCESS; 1144 else 1145 return BTA_FAILURE; 1146 1147} 1148 1149/******************************************************************************* 1150** Device Identification (DI) Client Functions 1151*******************************************************************************/ 1152/******************************************************************************* 1153** 1154** Function BTA_DmDiDiscover 1155** 1156** Description This function queries a remote device for DI information. 1157** 1158** 1159** Returns None. 1160** 1161*******************************************************************************/ 1162void BTA_DmDiDiscover( BD_ADDR remote_device, tBTA_DISCOVERY_DB *p_db, 1163 UINT32 len, tBTA_DM_SEARCH_CBACK *p_cback ) 1164{ 1165 tBTA_DM_API_DI_DISC *p_msg; 1166 1167 if ((p_msg = (tBTA_DM_API_DI_DISC *) GKI_getbuf(sizeof(tBTA_DM_API_DI_DISC))) != NULL) 1168 { 1169 bdcpy(p_msg->bd_addr, remote_device); 1170 p_msg->hdr.event = BTA_DM_API_DI_DISCOVER_EVT; 1171 p_msg->p_sdp_db = p_db; 1172 p_msg->len = len; 1173 p_msg->p_cback = p_cback; 1174 1175 bta_sys_sendmsg(p_msg); 1176 } 1177} 1178 1179/******************************************************************************* 1180** 1181** Function BTA_DmGetDiRecord 1182** 1183** Description This function retrieves a remote device's DI record from 1184** the specified database. 1185** 1186** Returns BTA_SUCCESS if Get DI record is succeed. 1187** BTA_FAILURE if Get DI record failed. 1188** 1189*******************************************************************************/ 1190tBTA_STATUS BTA_DmGetDiRecord( UINT8 get_record_index, tBTA_DI_GET_RECORD *p_device_info, 1191 tBTA_DISCOVERY_DB *p_db ) 1192{ 1193 if (SDP_GetDiRecord(get_record_index, p_device_info, p_db) != SDP_SUCCESS) 1194 return BTA_FAILURE; 1195 else 1196 return BTA_SUCCESS; 1197} 1198 1199/******************************************************************************* 1200** 1201** Function BTA_SysFeatures 1202** 1203** Description This function is called to set system features. 1204** 1205** Returns void 1206** 1207*******************************************************************************/ 1208void BTA_SysFeatures (UINT16 sys_features) 1209{ 1210 bta_sys_cb.sys_features = sys_features; 1211 1212 APPL_TRACE_API1("BTA_SysFeatures: sys_features = %d", sys_features); 1213} 1214 1215/******************************************************************************* 1216** 1217** Function bta_dmexecutecallback 1218** 1219** Description This function will request BTA to execute a call back in the context of BTU task 1220** This API was named in lower case because it is only intended 1221** for the internal customers(like BTIF). 1222** 1223** Returns void 1224** 1225*******************************************************************************/ 1226void bta_dmexecutecallback (tBTA_DM_EXEC_CBACK* p_callback, void * p_param) 1227{ 1228 tBTA_DM_API_EXECUTE_CBACK *p_msg; 1229 1230 if ((p_msg = (tBTA_DM_API_EXECUTE_CBACK *) GKI_getbuf(sizeof(tBTA_DM_MSG))) != NULL) 1231 { 1232 p_msg->hdr.event = BTA_DM_API_EXECUTE_CBACK_EVT; 1233 p_msg->p_param= p_param; 1234 p_msg->p_exec_cback= p_callback; 1235 bta_sys_sendmsg(p_msg); 1236 } 1237} 1238 1239/******************************************************************************* 1240** 1241** Function BTA_DmAddBleKey 1242** 1243** Description Add/modify LE device information. This function will be 1244** normally called during host startup to restore all required 1245** information stored in the NVRAM. 1246** 1247** Parameters: bd_addr - BD address of the peer 1248** p_le_key - LE key values. 1249** key_type - LE SMP key type. 1250** 1251** Returns void 1252** 1253*******************************************************************************/ 1254void BTA_DmAddBleKey (BD_ADDR bd_addr, tBTA_LE_KEY_VALUE *p_le_key, tBTA_LE_KEY_TYPE key_type) 1255{ 1256#if BLE_INCLUDED == TRUE 1257 1258 tBTA_DM_API_ADD_BLEKEY *p_msg; 1259 1260 if ((p_msg = (tBTA_DM_API_ADD_BLEKEY *) GKI_getbuf(sizeof(tBTA_DM_API_ADD_BLEKEY))) != NULL) 1261 { 1262 memset (p_msg, 0, sizeof(tBTA_DM_API_ADD_BLEKEY)); 1263 1264 p_msg->hdr.event = BTA_DM_API_ADD_BLEKEY_EVT; 1265 p_msg->key_type = key_type; 1266 bdcpy(p_msg->bd_addr, bd_addr); 1267 memcpy(&p_msg->blekey, p_le_key, sizeof(tBTA_LE_KEY_VALUE)); 1268 1269 bta_sys_sendmsg(p_msg); 1270 } 1271 1272#endif 1273} 1274 1275/******************************************************************************* 1276** 1277** Function BTA_DmAddBleDevice 1278** 1279** Description Add a BLE device. This function will be normally called 1280** during host startup to restore all required information 1281** for a LE device stored in the NVRAM. 1282** 1283** Parameters: bd_addr - BD address of the peer 1284** dev_type - Remote device's device type. 1285** addr_type - LE device address type. 1286** 1287** Returns void 1288** 1289*******************************************************************************/ 1290void BTA_DmAddBleDevice(BD_ADDR bd_addr, tBLE_ADDR_TYPE addr_type, tBT_DEVICE_TYPE dev_type) 1291{ 1292#if BLE_INCLUDED == TRUE 1293 tBTA_DM_API_ADD_BLE_DEVICE *p_msg; 1294 1295 if ((p_msg = (tBTA_DM_API_ADD_BLE_DEVICE *) GKI_getbuf(sizeof(tBTA_DM_API_ADD_BLE_DEVICE))) != NULL) 1296 { 1297 memset (p_msg, 0, sizeof(tBTA_DM_API_ADD_BLE_DEVICE)); 1298 1299 p_msg->hdr.event = BTA_DM_API_ADD_BLEDEVICE_EVT; 1300 bdcpy(p_msg->bd_addr, bd_addr); 1301 p_msg->addr_type = addr_type; 1302 p_msg->dev_type = dev_type; 1303 1304 bta_sys_sendmsg(p_msg); 1305 } 1306#endif 1307} 1308/******************************************************************************* 1309** 1310** Function BTA_DmBlePasskeyReply 1311** 1312** Description Send BLE SMP passkey reply. 1313** 1314** Parameters: bd_addr - BD address of the peer 1315** accept - passkey entry sucessful or declined. 1316** passkey - passkey value, must be a 6 digit number, 1317** can be lead by 0. 1318** 1319** Returns void 1320** 1321*******************************************************************************/ 1322void BTA_DmBlePasskeyReply(BD_ADDR bd_addr, BOOLEAN accept, UINT32 passkey) 1323{ 1324#if BLE_INCLUDED == TRUE 1325 tBTA_DM_API_PASSKEY_REPLY *p_msg; 1326 1327 if ((p_msg = (tBTA_DM_API_PASSKEY_REPLY *) GKI_getbuf(sizeof(tBTA_DM_API_PASSKEY_REPLY))) != NULL) 1328 { 1329 memset(p_msg, 0, sizeof(tBTA_DM_API_PASSKEY_REPLY)); 1330 1331 p_msg->hdr.event = BTA_DM_API_BLE_PASSKEY_REPLY_EVT; 1332 bdcpy(p_msg->bd_addr, bd_addr); 1333 p_msg->accept = accept; 1334 1335 if(accept) 1336 { 1337 p_msg->passkey = passkey; 1338 } 1339 bta_sys_sendmsg(p_msg); 1340 } 1341#endif 1342} 1343/******************************************************************************* 1344** 1345** Function BTA_DmBleSecurityGrant 1346** 1347** Description Grant security request access. 1348** 1349** Parameters: bd_addr - BD address of the peer 1350** res - security grant status. 1351** 1352** Returns void 1353** 1354*******************************************************************************/ 1355void BTA_DmBleSecurityGrant(BD_ADDR bd_addr, tBTA_DM_BLE_SEC_GRANT res) 1356{ 1357#if BLE_INCLUDED == TRUE 1358 tBTA_DM_API_BLE_SEC_GRANT *p_msg; 1359 1360 if ((p_msg = (tBTA_DM_API_BLE_SEC_GRANT *) GKI_getbuf(sizeof(tBTA_DM_API_BLE_SEC_GRANT))) != NULL) 1361 { 1362 memset(p_msg, 0, sizeof(tBTA_DM_API_BLE_SEC_GRANT)); 1363 1364 p_msg->hdr.event = BTA_DM_API_BLE_SEC_GRANT_EVT; 1365 bdcpy(p_msg->bd_addr, bd_addr); 1366 p_msg->res = res; 1367 1368 bta_sys_sendmsg(p_msg); 1369 } 1370#endif 1371} 1372/******************************************************************************* 1373** 1374** Function BTA_DmSetBlePrefConnParams 1375** 1376** Description This function is called to set the preferred connection 1377** parameters when default connection parameter is not desired. 1378** 1379** Parameters: bd_addr - BD address of the peripheral 1380** scan_interval - scan interval 1381** scan_window - scan window 1382** min_conn_int - minimum preferred connection interval 1383** max_conn_int - maximum preferred connection interval 1384** slave_latency - preferred slave latency 1385** supervision_tout - preferred supervision timeout 1386** 1387** 1388** Returns void 1389** 1390*******************************************************************************/ 1391void BTA_DmSetBlePrefConnParams(BD_ADDR bd_addr, 1392 UINT16 min_conn_int, UINT16 max_conn_int, 1393 UINT16 slave_latency, UINT16 supervision_tout ) 1394{ 1395#if BLE_INCLUDED == TRUE 1396 tBTA_DM_API_BLE_CONN_PARAMS *p_msg; 1397 1398 if ((p_msg = (tBTA_DM_API_BLE_CONN_PARAMS *) GKI_getbuf(sizeof(tBTA_DM_API_BLE_CONN_PARAMS))) != NULL) 1399 { 1400 memset(p_msg, 0, sizeof(tBTA_DM_API_BLE_CONN_PARAMS)); 1401 1402 p_msg->hdr.event = BTA_DM_API_BLE_CONN_PARAM_EVT; 1403 1404 memcpy(p_msg->peer_bda, bd_addr, BD_ADDR_LEN); 1405 1406 p_msg->conn_int_max = max_conn_int; 1407 p_msg->conn_int_min = min_conn_int; 1408 p_msg->slave_latency = slave_latency; 1409 p_msg->supervision_tout = supervision_tout; 1410 1411 bta_sys_sendmsg(p_msg); 1412 } 1413#endif 1414} 1415 1416/******************************************************************************* 1417** 1418** Function BTA_DmSetBleConnScanParams 1419** 1420** Description This function is called to set scan parameters used in 1421** BLE connection request 1422** 1423** Parameters: scan_interval - scan interval 1424** scan_window - scan window 1425** 1426** Returns void 1427** 1428*******************************************************************************/ 1429void BTA_DmSetBleConnScanParams(UINT16 scan_interval, UINT16 scan_window ) 1430{ 1431#if BLE_INCLUDED == TRUE 1432 tBTA_DM_API_BLE_SCAN_PARAMS *p_msg; 1433 1434 if ((p_msg = (tBTA_DM_API_BLE_SCAN_PARAMS *) GKI_getbuf(sizeof(tBTA_DM_API_BLE_SCAN_PARAMS))) != NULL) 1435 { 1436 memset(p_msg, 0, sizeof(tBTA_DM_API_BLE_SCAN_PARAMS)); 1437 1438 p_msg->hdr.event = BTA_DM_API_BLE_SCAN_PARAM_EVT; 1439 1440 p_msg->scan_int = scan_interval; 1441 p_msg->scan_window = scan_window; 1442 1443 bta_sys_sendmsg(p_msg); 1444 } 1445#endif 1446} 1447 1448/******************************************************************************* 1449** 1450** Function BTA_DmSetBleAdvParams 1451** 1452** Description This function sets the advertising parameters BLE functionality. 1453** It is to be called when device act in peripheral or broadcaster 1454** role. 1455** 1456** 1457** Returns void 1458** 1459*******************************************************************************/ 1460void BTA_DmSetBleAdvParams (UINT16 adv_int_min, UINT16 adv_int_max, 1461 tBLE_BD_ADDR *p_dir_bda) 1462{ 1463#if BLE_INCLUDED == TRUE 1464 tBTA_DM_API_BLE_ADV_PARAMS *p_msg; 1465 1466 APPL_TRACE_API2 ("BTA_DmSetBleAdvParam: %d, %d", adv_int_min, adv_int_max); 1467 1468 if ((p_msg = (tBTA_DM_API_BLE_ADV_PARAMS *) GKI_getbuf(sizeof(tBTA_DM_API_BLE_ADV_PARAMS))) != NULL) 1469 { 1470 memset(p_msg, 0, sizeof(tBTA_DM_API_BLE_ADV_PARAMS)); 1471 1472 p_msg->hdr.event = BTA_DM_API_BLE_ADV_PARAM_EVT; 1473 1474 p_msg->adv_int_min = adv_int_min; 1475 p_msg->adv_int_max = adv_int_max; 1476 1477 if (p_dir_bda != NULL) 1478 { 1479 p_msg->p_dir_bda = (tBLE_BD_ADDR *)(p_msg + 1); 1480 memcpy(p_msg->p_dir_bda, p_dir_bda, sizeof(tBLE_BD_ADDR)); 1481 } 1482 1483 bta_sys_sendmsg(p_msg); 1484 } 1485#endif 1486} 1487 1488#if BLE_INCLUDED == TRUE 1489/******************************************************************************* 1490** 1491** Function BTA_DmBleSetAdvConfig 1492** 1493** Description This function is called to override the BTA default ADV parameters. 1494** 1495** Parameters Pointer to User defined ADV data structure 1496** 1497** Returns None 1498** 1499*******************************************************************************/ 1500void BTA_DmBleSetAdvConfig (tBTA_BLE_AD_MASK data_mask, tBTA_BLE_ADV_DATA *p_adv_cfg) 1501{ 1502 tBTA_DM_API_SET_ADV_CONFIG *p_msg; 1503 1504 if ((p_msg = (tBTA_DM_API_SET_ADV_CONFIG *) GKI_getbuf(sizeof(tBTA_DM_API_SET_ADV_CONFIG))) != NULL) 1505 { 1506 p_msg->hdr.event = BTA_DM_API_BLE_SET_ADV_CONFIG_EVT; 1507 p_msg->data_mask = data_mask; 1508 p_msg->p_adv_cfg = p_adv_cfg; 1509 1510 bta_sys_sendmsg(p_msg); 1511 } 1512} 1513#endif 1514/******************************************************************************* 1515** 1516** Function BTA_DmBleSetBgConnType 1517** 1518** Description This function is called to set BLE connectable mode for a 1519** peripheral device. 1520** 1521** Parameters bg_conn_type: it can be auto connection, or selective connection. 1522** p_select_cback: callback function when selective connection procedure 1523** is being used. 1524** 1525** Returns void 1526** 1527*******************************************************************************/ 1528void BTA_DmBleSetBgConnType(tBTA_DM_BLE_CONN_TYPE bg_conn_type, tBTA_DM_BLE_SEL_CBACK *p_select_cback) 1529{ 1530#if BLE_INCLUDED == TRUE 1531 tBTA_DM_API_BLE_SET_BG_CONN_TYPE *p_msg; 1532 1533 if ((p_msg = (tBTA_DM_API_BLE_SET_BG_CONN_TYPE *) GKI_getbuf(sizeof(tBTA_DM_API_BLE_SET_BG_CONN_TYPE))) != NULL) 1534 { 1535 memset(p_msg, 0, sizeof(tBTA_DM_API_BLE_SET_BG_CONN_TYPE)); 1536 1537 p_msg->hdr.event = BTA_DM_API_BLE_SET_BG_CONN_TYPE; 1538 p_msg->bg_conn_type = bg_conn_type; 1539 p_msg->p_select_cback = p_select_cback; 1540 1541 bta_sys_sendmsg(p_msg); 1542 } 1543#endif 1544} 1545/******************************************************************************* 1546** 1547** Function BTA_DmDiscoverExt 1548** 1549** Description This function does service discovery for services of a 1550** peer device. When services.num_uuid is 0, it indicates all 1551** GATT based services are to be searched; other wise a list of 1552** UUID of interested services should be provided through 1553** p_services->p_uuid. 1554** 1555** 1556** 1557** Returns void 1558** 1559*******************************************************************************/ 1560void BTA_DmDiscoverExt(BD_ADDR bd_addr, tBTA_SERVICE_MASK_EXT *p_services, 1561 tBTA_DM_SEARCH_CBACK *p_cback, BOOLEAN sdp_search) 1562{ 1563#if BLE_INCLUDED == TRUE && BTA_GATT_INCLUDED == TRUE 1564 tBTA_DM_API_DISCOVER *p_msg; 1565 UINT16 len = p_services ? (sizeof(tBTA_DM_API_DISCOVER) + sizeof(tBT_UUID) * p_services->num_uuid) : 1566 sizeof(tBTA_DM_API_DISCOVER); 1567 1568 if ((p_msg = (tBTA_DM_API_DISCOVER *) GKI_getbuf(len)) != NULL) 1569 { 1570 memset(p_msg, 0, len); 1571 1572 p_msg->hdr.event = BTA_DM_API_DISCOVER_EVT; 1573 bdcpy(p_msg->bd_addr, bd_addr); 1574 p_msg->p_cback = p_cback; 1575 p_msg->sdp_search = sdp_search; 1576 1577 if (p_services != NULL) 1578 { 1579 p_msg->services = p_services->srvc_mask; 1580 p_msg->num_uuid = p_services->num_uuid; 1581 1582 if (p_services->num_uuid != 0) 1583 { 1584 p_msg->p_uuid = (tBT_UUID *)(p_msg + 1); 1585 memcpy(p_msg->p_uuid, p_services->p_uuid, sizeof(tBT_UUID) * p_services->num_uuid); 1586 } 1587 } 1588 1589 bta_sys_sendmsg(p_msg); 1590 } 1591#endif 1592 1593} 1594 1595/******************************************************************************* 1596** 1597** Function BTA_DmSearchExt 1598** 1599** Description This function searches for peer Bluetooth devices. It performs 1600** an inquiry and gets the remote name for devices. Service 1601** discovery is done if services is non zero 1602** 1603** Parameters p_dm_inq: inquiry conditions 1604** p_services: if service is not empty, service discovery will be done. 1605** for all GATT based service condition, put num_uuid, and 1606** p_uuid is the pointer to the list of UUID values. 1607** p_cback: callback functino when search is completed. 1608** 1609** 1610** 1611** Returns void 1612** 1613*******************************************************************************/ 1614void BTA_DmSearchExt(tBTA_DM_INQ *p_dm_inq, tBTA_SERVICE_MASK_EXT *p_services, tBTA_DM_SEARCH_CBACK *p_cback) 1615{ 1616#if BLE_INCLUDED == TRUE && BTA_GATT_INCLUDED == TRUE 1617 tBTA_DM_API_SEARCH *p_msg; 1618 UINT16 len = p_services ? (sizeof(tBTA_DM_API_SEARCH) + sizeof(tBT_UUID) * p_services->num_uuid) : 1619 sizeof(tBTA_DM_API_SEARCH); 1620 1621 if ((p_msg = (tBTA_DM_API_SEARCH *) GKI_getbuf(len)) != NULL) 1622 { 1623 memset(p_msg, 0, len); 1624 1625 p_msg->hdr.event = BTA_DM_API_SEARCH_EVT; 1626 memcpy(&p_msg->inq_params, p_dm_inq, sizeof(tBTA_DM_INQ)); 1627 p_msg->p_cback = p_cback; 1628 p_msg->rs_res = BTA_DM_RS_NONE; 1629 1630 1631 if (p_services != NULL) 1632 { 1633 p_msg->services = p_services->srvc_mask; 1634 p_msg->num_uuid = p_services->num_uuid; 1635 1636 if (p_services->num_uuid != 0) 1637 { 1638 p_msg->p_uuid = (tBT_UUID *)(p_msg + 1); 1639 memcpy(p_msg->p_uuid, p_services->p_uuid, sizeof(tBT_UUID) * p_services->num_uuid); 1640 } 1641 else 1642 p_msg->p_uuid = NULL; 1643 } 1644 1645 bta_sys_sendmsg(p_msg); 1646 } 1647#endif 1648} 1649 1650/******************************************************************************* 1651** 1652** Function BTA_DmBleEnableRemotePrivacy 1653** 1654** Description Enable/disable privacy on a remote device 1655** 1656** Parameters: bd_addr - BD address of the peer 1657** privacy_enable - enable/disabe privacy on remote device. 1658** 1659** Returns void 1660** 1661*******************************************************************************/ 1662void BTA_DmBleEnableRemotePrivacy(BD_ADDR bd_addr, BOOLEAN privacy_enable) 1663{ 1664#if BLE_INCLUDED == TRUE 1665#endif 1666} 1667 1668 1669/******************************************************************************* 1670** 1671** Function BTA_DmBleConfigLocalPrivacy 1672** 1673** Description Enable/disable privacy on the local device 1674** 1675** Parameters: privacy_enable - enable/disabe privacy on remote device. 1676** 1677** Returns void 1678** 1679*******************************************************************************/ 1680void BTA_DmBleConfigLocalPrivacy(BOOLEAN privacy_enable) 1681{ 1682#if BLE_INCLUDED == TRUE 1683#endif 1684} 1685 1686 1687/******************************************************************************* 1688** 1689** Function BTA_DmSetEncryption 1690** 1691** Description This function is called to ensure that connection is 1692** encrypted. Should be called only on an open connection. 1693** Typically only needed for connections that first want to 1694** bring up unencrypted links, then later encrypt them. 1695** 1696** Parameters: bd_addr - Address of the peer device 1697** p_callback - Pointer to callback function to indicat the 1698** link encryption status 1699** sec_act - This is the security action to indicate 1700** what knid of BLE security level is required for 1701** the BLE link if the BLE is supported 1702** Note: This parameter is ignored for the BR/EDR link 1703** or the BLE is not supported 1704** 1705** Returns void 1706** 1707*******************************************************************************/ 1708void BTA_DmSetEncryption(BD_ADDR bd_addr, tBTA_DM_ENCRYPT_CBACK *p_callback, 1709 tBTA_DM_BLE_SEC_ACT sec_act) 1710{ 1711 tBTA_DM_API_SET_ENCRYPTION *p_msg; 1712 1713 APPL_TRACE_API0("BTA_DmSetEncryption"); //todo 1714 if ((p_msg = (tBTA_DM_API_SET_ENCRYPTION *) GKI_getbuf(sizeof(tBTA_DM_API_SET_ENCRYPTION))) != NULL) 1715 { 1716 memset(p_msg, 0, sizeof(tBTA_DM_API_SET_ENCRYPTION)); 1717 1718 p_msg->hdr.event = BTA_DM_API_SET_ENCRYPTION_EVT; 1719 1720 memcpy(p_msg->bd_addr, bd_addr, BD_ADDR_LEN); 1721 p_msg->p_callback = p_callback; 1722 p_msg->sec_act = sec_act; 1723 1724 bta_sys_sendmsg(p_msg); 1725 } 1726} 1727 1728/******************************************************************************* 1729** 1730** Function BTA_DmCloseACL 1731** 1732** Description This function force to close an ACL connection and remove the 1733** device from the security database list of known devices. 1734** 1735** Parameters: bd_addr - Address of the peer device 1736** remove_dev - remove device or not after link down 1737** 1738** Returns void 1739** 1740*******************************************************************************/ 1741void BTA_DmCloseACL(BD_ADDR bd_addr, BOOLEAN remove_dev) 1742{ 1743 tBTA_DM_API_REMOVE_ACL *p_msg; 1744 1745 APPL_TRACE_API0("BTA_DmCloseACL"); 1746 1747 if ((p_msg = (tBTA_DM_API_REMOVE_ACL *) GKI_getbuf(sizeof(tBTA_DM_API_REMOVE_ACL))) != NULL) 1748 { 1749 memset(p_msg, 0, sizeof(tBTA_DM_API_REMOVE_ACL)); 1750 1751 p_msg->hdr.event = BTA_DM_API_REMOVE_ACL_EVT; 1752 1753 memcpy(p_msg->bd_addr, bd_addr, BD_ADDR_LEN); 1754 p_msg->remove_dev = remove_dev; 1755 1756 bta_sys_sendmsg(p_msg); 1757 } 1758} 1759 1760/******************************************************************************* 1761** 1762** Function BTA_DmBleObserve 1763** 1764** Description This procedure keep the device listening for advertising 1765** events from a broadcast device. 1766** 1767** Parameters start: start or stop observe. 1768** 1769** Returns void 1770 1771** 1772** Returns void. 1773** 1774*******************************************************************************/ 1775BTA_API extern void BTA_DmBleObserve(BOOLEAN start, UINT8 duration, 1776 tBTA_DM_SEARCH_CBACK *p_results_cb) 1777{ 1778#if BLE_INCLUDED == TRUE 1779 1780 tBTA_DM_API_BLE_OBSERVE *p_msg; 1781 1782 APPL_TRACE_API1("BTA_DmBleObserve:start = %d ", start); 1783 1784 if ((p_msg = (tBTA_DM_API_BLE_OBSERVE *) GKI_getbuf(sizeof(tBTA_DM_API_BLE_OBSERVE))) != NULL) 1785 { 1786 memset(p_msg, 0, sizeof(tBTA_DM_API_BLE_OBSERVE)); 1787 1788 p_msg->hdr.event = BTA_DM_API_BLE_OBSERVE_EVT; 1789 p_msg->start = start; 1790 p_msg->duration = duration; 1791 p_msg->p_cback = p_results_cb; 1792 1793 bta_sys_sendmsg(p_msg); 1794 } 1795#endif 1796} 1797 1798 1799