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 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 *******************************************************************************/ 62 tBTA_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 *******************************************************************************/ 103 tBTA_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 *******************************************************************************/ 131 tBTA_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 *******************************************************************************/ 156 void 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 *******************************************************************************/ 179 BOOLEAN 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 *******************************************************************************/ 201 void 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 *******************************************************************************/ 230 void 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 *******************************************************************************/ 261 void 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 *******************************************************************************/ 285 void 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 *******************************************************************************/ 310 void 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 *******************************************************************************/ 333 tBTA_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 *******************************************************************************/ 385 void 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 *******************************************************************************/ 415 void 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 *******************************************************************************/ 438 void 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 *******************************************************************************/ 468 void 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 *******************************************************************************/ 501 BOOLEAN 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 *******************************************************************************/ 526 void 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 *******************************************************************************/ 551 void 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 *******************************************************************************/ 576 void 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 *******************************************************************************/ 608 void 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 *******************************************************************************/ 635 void 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 *******************************************************************************/ 656 void 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) 680 void 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 *******************************************************************************/ 706 void 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 *******************************************************************************/ 756 tBTA_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 *******************************************************************************/ 787 void 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 *******************************************************************************/ 839 void 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 *******************************************************************************/ 869 void 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 *******************************************************************************/ 899 void 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 *******************************************************************************/ 925 void 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 *******************************************************************************/ 952 void 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 *******************************************************************************/ 981 void 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 *******************************************************************************/ 1009 UINT8 *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 *******************************************************************************/ 1030 extern const UINT16 bta_service_id_to_uuid_lkup_tbl []; 1031 void 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 *******************************************************************************/ 1077 BOOLEAN 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 *******************************************************************************/ 1098 tBTA_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 *******************************************************************************/ 1135 tBTA_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 *******************************************************************************/ 1162 void 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 *******************************************************************************/ 1190 tBTA_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 *******************************************************************************/ 1208 void 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 *******************************************************************************/ 1226 void 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 *******************************************************************************/ 1254 void 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 *******************************************************************************/ 1290 void 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 *******************************************************************************/ 1322 void 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 *******************************************************************************/ 1355 void 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 *******************************************************************************/ 1391 void 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 *******************************************************************************/ 1429 void 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 *******************************************************************************/ 1460 void 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 *******************************************************************************/ 1500 void 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 *******************************************************************************/ 1528 void 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 *******************************************************************************/ 1560 void 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 *******************************************************************************/ 1614 void 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 *******************************************************************************/ 1662 void 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 *******************************************************************************/ 1680 void 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 *******************************************************************************/ 1708 void 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 *******************************************************************************/ 1741 void 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 *******************************************************************************/ 1775 BTA_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
