bta/dm/bta_dm_api.cc

   1 /******************************************************************************
   2  *
   3  *  Copyright (C) 2003-2014 Broadcom Corporation
   4  *
   5  *  Licensed under the Apache License, Version 2.0 (the "License");
   6  *  you may not use this file except in compliance with the License.
   7  *  You may obtain a copy of the License at:
   8  *
   9  *  http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  *  Unless required by applicable law or agreed to in writing, software
  12  *  distributed under the License is distributed on an "AS IS" BASIS,
  13  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  *  See the License for the specific language governing permissions and
  15  *  limitations under the License.
  16  *
  17  ******************************************************************************/
  18
  19 /******************************************************************************
  20  *
  21  *  This is the API implementation file for the BTA device manager.
  22  *
  23  ******************************************************************************/
  24 #include <base/bind_helpers.h>
  25 #include <string.h>
  26
  27 #include "bt_common.h"
  28 #include "bta_api.h"
  29 #include "bta_closure_api.h"
  30 #include "bta_dm_int.h"
  31 #include "bta_sys.h"
  32 #include "bta_sys_int.h"
  33 #include "btm_api.h"
  34 #include "btm_int.h"
  35 #include "osi/include/osi.h"
  36 #include "utl.h"
  37
  38 /*****************************************************************************
  39  *  Constants
  40  ****************************************************************************/
  41
  42 static const tBTA_SYS_REG bta_dm_reg = {bta_dm_sm_execute, bta_dm_sm_disable};
  43
  44 static const tBTA_SYS_REG bta_dm_search_reg = {bta_dm_search_sm_execute,
  45                                                bta_dm_search_sm_disable};
  46
  47 /*******************************************************************************
  48  *
  49  * Function         BTA_EnableBluetooth
  50  *
  51  * Description      Enables bluetooth service.  This function must be
  52  *                  called before any other functions in the BTA API are called.
  53  *
  54  *
  55  * Returns          tBTA_STATUS
  56  *
  57  ******************************************************************************/
  58 tBTA_STATUS BTA_EnableBluetooth(tBTA_DM_SEC_CBACK* p_cback) {
  59   /* Bluetooth disabling is in progress */
  60   if (bta_dm_cb.disabling) return BTA_FAILURE;
  61
  62   bta_sys_register(BTA_ID_DM, &bta_dm_reg);
  63   bta_sys_register(BTA_ID_DM_SEARCH, &bta_dm_search_reg);
  64
  65   /* if UUID list is not provided as static data */
  66   bta_sys_eir_register(bta_dm_eir_update_uuid);
  67
  68   tBTA_DM_API_ENABLE* p_msg =
  69       (tBTA_DM_API_ENABLE*)osi_malloc(sizeof(tBTA_DM_API_ENABLE));
  70   p_msg->hdr.event = BTA_DM_API_ENABLE_EVT;
  71   p_msg->p_sec_cback = p_cback;
  72
  73   bta_sys_sendmsg(p_msg);
  74
  75   return BTA_SUCCESS;
  76 }
  77
  78 /*******************************************************************************
  79  *
  80  * Function         BTA_DisableBluetooth
  81  *
  82  * Description      Disables bluetooth service.  This function is called when
  83  *                  the application no longer needs bluetooth service
  84  *
  85  * Returns          void
  86  *
  87  ******************************************************************************/
  88 tBTA_STATUS BTA_DisableBluetooth(void) {
  89   BT_HDR* p_msg = (BT_HDR*)osi_malloc(sizeof(BT_HDR));
  90
  91   p_msg->event = BTA_DM_API_DISABLE_EVT;
  92
  93   bta_sys_sendmsg(p_msg);
  94
  95   return BTA_SUCCESS;
  96 }
  97
  98 /*******************************************************************************
  99  *
 100  * Function         BTA_EnableTestMode
 101  *
 102  * Description      Enables bluetooth device under test mode
 103  *
 104  *
 105  * Returns          tBTA_STATUS
 106  *
 107  ******************************************************************************/
 108 tBTA_STATUS BTA_EnableTestMode(void) {
 109   BT_HDR* p_msg = (BT_HDR*)osi_malloc(sizeof(BT_HDR));
 110
 111   APPL_TRACE_API("%s", __func__);
 112
 113   p_msg->event = BTA_DM_API_ENABLE_TEST_MODE_EVT;
 114   bta_sys_sendmsg(p_msg);
 115
 116   return BTA_SUCCESS;
 117 }
 118
 119 /*******************************************************************************
 120  *
 121  * Function         BTA_DisableTestMode
 122  *
 123  * Description      Disable bluetooth device under test mode
 124  *
 125  *
 126  * Returns          None
 127  *
 128  ******************************************************************************/
 129 void BTA_DisableTestMode(void) {
 130   BT_HDR* p_msg = (BT_HDR*)osi_malloc(sizeof(BT_HDR));
 131
 132   APPL_TRACE_API("%s", __func__);
 133
 134   p_msg->event = BTA_DM_API_DISABLE_TEST_MODE_EVT;
 135   bta_sys_sendmsg(p_msg);
 136 }
 137
 138 /*******************************************************************************
 139  *
 140  * Function         BTA_DmSetDeviceName
 141  *
 142  * Description      This function sets the Bluetooth name of local device
 143  *
 144  *
 145  * Returns          void
 146  *
 147  ******************************************************************************/
 148 void BTA_DmSetDeviceName(char* p_name) {
 149   tBTA_DM_API_SET_NAME* p_msg =
 150       (tBTA_DM_API_SET_NAME*)osi_malloc(sizeof(tBTA_DM_API_SET_NAME));
 151
 152   p_msg->hdr.event = BTA_DM_API_SET_NAME_EVT;
 153   strlcpy((char*)p_msg->name, p_name, BD_NAME_LEN);
 154
 155   bta_sys_sendmsg(p_msg);
 156 }
 157
 158 /*******************************************************************************
 159  *
 160  * Function         BTA_DmSetVisibility
 161  *
 162  * Description      This function sets the Bluetooth connectable,
 163  *                  discoverable, pairable and conn paired only modes of local
 164  *                  device
 165  *
 166  *
 167  * Returns          void
 168  *
 169  ******************************************************************************/
 170 void BTA_DmSetVisibility(tBTA_DM_DISC disc_mode, tBTA_DM_CONN conn_mode,
 171                          uint8_t pairable_mode, uint8_t conn_filter) {
 172   tBTA_DM_API_SET_VISIBILITY* p_msg =
 173       (tBTA_DM_API_SET_VISIBILITY*)osi_malloc(sizeof(tBTA_DM_MSG));
 174
 175   p_msg->hdr.event = BTA_DM_API_SET_VISIBILITY_EVT;
 176   p_msg->disc_mode = disc_mode;
 177   p_msg->conn_mode = conn_mode;
 178   p_msg->pair_mode = pairable_mode;
 179   p_msg->conn_paired_only = conn_filter;
 180
 181   bta_sys_sendmsg(p_msg);
 182 }
 183
 184 /*******************************************************************************
 185  *
 186  * Function         BTA_DmSearch
 187  *
 188  * Description      This function searches for peer Bluetooth devices. It
 189  *                  performs an inquiry and gets the remote name for devices.
 190  *                  Service discovery is done if services is non zero
 191  *
 192  *
 193  * Returns          void
 194  *
 195  ******************************************************************************/
 196 void BTA_DmSearch(tBTA_DM_INQ* p_dm_inq, tBTA_SERVICE_MASK services,
 197                   tBTA_DM_SEARCH_CBACK* p_cback) {
 198   tBTA_DM_API_SEARCH* p_msg =
 199       (tBTA_DM_API_SEARCH*)osi_calloc(sizeof(tBTA_DM_API_SEARCH));
 200
 201   p_msg->hdr.event = BTA_DM_API_SEARCH_EVT;
 202   memcpy(&p_msg->inq_params, p_dm_inq, sizeof(tBTA_DM_INQ));
 203   p_msg->services = services;
 204   p_msg->p_cback = p_cback;
 205   p_msg->rs_res = BTA_DM_RS_NONE;
 206
 207   bta_sys_sendmsg(p_msg);
 208 }
 209
 210 /*******************************************************************************
 211  *
 212  * Function         BTA_DmSearchCancel
 213  *
 214  * Description      This function  cancels a search initiated by BTA_DmSearch
 215  *
 216  *
 217  * Returns          void
 218  *
 219  ******************************************************************************/
 220 void BTA_DmSearchCancel(void) {
 221   BT_HDR* p_msg = (BT_HDR*)osi_malloc(sizeof(BT_HDR));
 222
 223   p_msg->event = BTA_DM_API_SEARCH_CANCEL_EVT;
 224   bta_sys_sendmsg(p_msg);
 225 }
 226
 227 /*******************************************************************************
 228  *
 229  * Function         BTA_DmDiscover
 230  *
 231  * Description      This function does service discovery for services of a
 232  *                  peer device
 233  *
 234  *
 235  * Returns          void
 236  *
 237  ******************************************************************************/
 238 void BTA_DmDiscover(const RawAddress& bd_addr, tBTA_SERVICE_MASK services,
 239                     tBTA_DM_SEARCH_CBACK* p_cback, bool sdp_search) {
 240   tBTA_DM_API_DISCOVER* p_msg =
 241       (tBTA_DM_API_DISCOVER*)osi_calloc(sizeof(tBTA_DM_API_DISCOVER));
 242
 243   p_msg->hdr.event = BTA_DM_API_DISCOVER_EVT;
 244   p_msg->bd_addr = bd_addr;
 245   p_msg->services = services;
 246   p_msg->p_cback = p_cback;
 247   p_msg->sdp_search = sdp_search;
 248
 249   bta_sys_sendmsg(p_msg);
 250 }
 251
 252 /*******************************************************************************
 253  *
 254  * Function         BTA_DmDiscoverUUID
 255  *
 256  * Description      This function does service discovery for services of a
 257  *                  peer device
 258  *
 259  *
 260  * Returns          void
 261  *
 262  ******************************************************************************/
 263 void BTA_DmDiscoverUUID(const RawAddress& bd_addr, tSDP_UUID* uuid,
 264                         tBTA_DM_SEARCH_CBACK* p_cback, bool sdp_search) {
 265   tBTA_DM_API_DISCOVER* p_msg =
 266       (tBTA_DM_API_DISCOVER*)osi_malloc(sizeof(tBTA_DM_API_DISCOVER));
 267
 268   p_msg->hdr.event = BTA_DM_API_DISCOVER_EVT;
 269   p_msg->bd_addr = bd_addr;
 270   p_msg->services = BTA_USER_SERVICE_MASK;  // Not exposed at API level
 271   p_msg->p_cback = p_cback;
 272   p_msg->sdp_search = sdp_search;
 273
 274   p_msg->num_uuid = 0;
 275   p_msg->p_uuid = NULL;
 276
 277   memcpy(&p_msg->uuid, uuid, sizeof(tSDP_UUID));
 278
 279   bta_sys_sendmsg(p_msg);
 280 }
 281
 282 /*******************************************************************************
 283  *
 284  * Function         BTA_DmBond
 285  *
 286  * Description      This function initiates a bonding procedure with a peer
 287  *                  device
 288  *
 289  *
 290  * Returns          void
 291  *
 292  ******************************************************************************/
 293 void BTA_DmBond(const RawAddress& bd_addr) {
 294   tBTA_DM_API_BOND* p_msg =
 295       (tBTA_DM_API_BOND*)osi_malloc(sizeof(tBTA_DM_API_BOND));
 296
 297   p_msg->hdr.event = BTA_DM_API_BOND_EVT;
 298   p_msg->bd_addr = bd_addr;
 299   p_msg->transport = BTA_TRANSPORT_UNKNOWN;
 300
 301   bta_sys_sendmsg(p_msg);
 302 }
 303
 304 /*******************************************************************************
 305  *
 306  * Function         BTA_DmBondByTransports
 307  *
 308  * Description      This function initiates a bonding procedure with a peer
 309  *                  device
 310  *
 311  *
 312  * Returns          void
 313  *
 314  ******************************************************************************/
 315 void BTA_DmBondByTransport(const RawAddress& bd_addr,
 316                            tBTA_TRANSPORT transport) {
 317   tBTA_DM_API_BOND* p_msg =
 318       (tBTA_DM_API_BOND*)osi_malloc(sizeof(tBTA_DM_API_BOND));
 319
 320   p_msg->hdr.event = BTA_DM_API_BOND_EVT;
 321   p_msg->bd_addr = bd_addr;
 322   p_msg->transport = transport;
 323
 324   bta_sys_sendmsg(p_msg);
 325 }
 326
 327 /*******************************************************************************
 328  *
 329  * Function         BTA_DmBondCancel
 330  *
 331  * Description      This function cancels the bonding procedure with a peer
 332  *                  device
 333  *
 334  *
 335  * Returns          void
 336  *
 337  ******************************************************************************/
 338 void BTA_DmBondCancel(const RawAddress& bd_addr) {
 339   tBTA_DM_API_BOND_CANCEL* p_msg =
 340       (tBTA_DM_API_BOND_CANCEL*)osi_malloc(sizeof(tBTA_DM_API_BOND_CANCEL));
 341
 342   p_msg->hdr.event = BTA_DM_API_BOND_CANCEL_EVT;
 343   p_msg->bd_addr = bd_addr;
 344
 345   bta_sys_sendmsg(p_msg);
 346 }
 347
 348 /*******************************************************************************
 349  *
 350  * Function         BTA_DmPinReply
 351  *
 352  * Description      This function provides a pincode for a remote device when
 353  *                  one is requested by DM through BTA_DM_PIN_REQ_EVT
 354  *
 355  *
 356  * Returns          void
 357  *
 358  ******************************************************************************/
 359 void BTA_DmPinReply(const RawAddress& bd_addr, bool accept, uint8_t pin_len,
 360                     uint8_t* p_pin)
 361
 362 {
 363   tBTA_DM_API_PIN_REPLY* p_msg =
 364       (tBTA_DM_API_PIN_REPLY*)osi_malloc(sizeof(tBTA_DM_API_PIN_REPLY));
 365
 366   p_msg->hdr.event = BTA_DM_API_PIN_REPLY_EVT;
 367   p_msg->bd_addr = bd_addr;
 368   p_msg->accept = accept;
 369   if (accept) {
 370     p_msg->pin_len = pin_len;
 371     memcpy(p_msg->p_pin, p_pin, pin_len);
 372   }
 373
 374   bta_sys_sendmsg(p_msg);
 375 }
 376
 377 /*******************************************************************************
 378  *
 379  * Function         BTA_DmLocalOob
 380  *
 381  * Description      This function retrieves the OOB data from local controller.
 382  *                  The result is reported by:
 383  *                  - bta_dm_co_loc_oob_ext() if device supports secure
 384  *                    connections (SC)
 385  *                  - bta_dm_co_loc_oob() if device doesn't support SC
 386  *
 387  * Returns          void
 388  *
 389  ******************************************************************************/
 390 void BTA_DmLocalOob(void) {
 391   tBTA_DM_API_LOC_OOB* p_msg =
 392       (tBTA_DM_API_LOC_OOB*)osi_malloc(sizeof(tBTA_DM_API_LOC_OOB));
 393
 394   p_msg->hdr.event = BTA_DM_API_LOC_OOB_EVT;
 395   bta_sys_sendmsg(p_msg);
 396 }
 397
 398 /*******************************************************************************
 399  *
 400  * Function         BTA_DmConfirm
 401  *
 402  * Description      This function accepts or rejects the numerical value of the
 403  *                  Simple Pairing process on BTA_DM_SP_CFM_REQ_EVT
 404  *
 405  * Returns          void
 406  *
 407  ******************************************************************************/
 408 void BTA_DmConfirm(const RawAddress& bd_addr, bool accept) {
 409   tBTA_DM_API_CONFIRM* p_msg =
 410       (tBTA_DM_API_CONFIRM*)osi_malloc(sizeof(tBTA_DM_API_CONFIRM));
 411
 412   p_msg->hdr.event = BTA_DM_API_CONFIRM_EVT;
 413   p_msg->bd_addr = bd_addr;
 414   p_msg->accept = accept;
 415
 416   bta_sys_sendmsg(p_msg);
 417 }
 418
 419 /*******************************************************************************
 420  *
 421  * Function         BTA_DmAddDevice
 422  *
 423  * Description      This function adds a device to the security database list of
 424  *                  peer device
 425  *
 426  *
 427  * Returns          void
 428  *
 429  ******************************************************************************/
 430 void BTA_DmAddDevice(const RawAddress& bd_addr, DEV_CLASS dev_class,
 431                      LINK_KEY link_key, tBTA_SERVICE_MASK trusted_mask,
 432                      bool is_trusted, uint8_t key_type, tBTA_IO_CAP io_cap,
 433                      uint8_t pin_length) {
 434   tBTA_DM_API_ADD_DEVICE* p_msg =
 435       (tBTA_DM_API_ADD_DEVICE*)osi_calloc(sizeof(tBTA_DM_API_ADD_DEVICE));
 436
 437   p_msg->hdr.event = BTA_DM_API_ADD_DEVICE_EVT;
 438   p_msg->bd_addr = bd_addr;
 439   p_msg->tm = trusted_mask;
 440   p_msg->is_trusted = is_trusted;
 441   p_msg->io_cap = io_cap;
 442
 443   if (link_key) {
 444     p_msg->link_key_known = true;
 445     p_msg->key_type = key_type;
 446     memcpy(p_msg->link_key, link_key, LINK_KEY_LEN);
 447   }
 448
 449   /* Load device class if specified */
 450   if (dev_class) {
 451     p_msg->dc_known = true;
 452     memcpy(p_msg->dc, dev_class, DEV_CLASS_LEN);
 453   }
 454
 455   memset(p_msg->bd_name, 0, BD_NAME_LEN + 1);
 456   memset(p_msg->features, 0, sizeof(p_msg->features));
 457   p_msg->pin_length = pin_length;
 458
 459   bta_sys_sendmsg(p_msg);
 460 }
 461
 462 /*******************************************************************************
 463  *
 464  * Function         BTA_DmRemoveDevice
 465  *
 466  * Description      This function removes a device fromthe security database
 467  *                  list of peer device. It manages unpairing even while
 468  *                  connected.
 469  *
 470  *
 471  * Returns          void
 472  *
 473  ******************************************************************************/
 474 tBTA_STATUS BTA_DmRemoveDevice(const RawAddress& bd_addr) {
 475   tBTA_DM_API_REMOVE_DEVICE* p_msg =
 476       (tBTA_DM_API_REMOVE_DEVICE*)osi_calloc(sizeof(tBTA_DM_API_REMOVE_DEVICE));
 477
 478   p_msg->hdr.event = BTA_DM_API_REMOVE_DEVICE_EVT;
 479   p_msg->bd_addr = bd_addr;
 480
 481   bta_sys_sendmsg(p_msg);
 482
 483   return BTA_SUCCESS;
 484 }
 485
 486 /*******************************************************************************
 487  *
 488  * Function         BTA_GetEirService
 489  *
 490  * Description      This function is called to get BTA service mask from EIR.
 491  *
 492  * Parameters       p_eir - pointer of EIR significant part
 493  *                  p_services - return the BTA service mask
 494  *
 495  * Returns          None
 496  *
 497  ******************************************************************************/
 498 extern const uint16_t bta_service_id_to_uuid_lkup_tbl[];
 499 void BTA_GetEirService(uint8_t* p_eir, size_t eir_len,
 500                        tBTA_SERVICE_MASK* p_services) {
 501   uint8_t xx, yy;
 502   uint8_t num_uuid, max_num_uuid = 32;
 503   uint8_t uuid_list[32 * LEN_UUID_16];
 504   uint16_t* p_uuid16 = (uint16_t*)uuid_list;
 505   tBTA_SERVICE_MASK mask;
 506
 507   BTM_GetEirUuidList(p_eir, eir_len, LEN_UUID_16, &num_uuid, uuid_list,
 508                      max_num_uuid);
 509   for (xx = 0; xx < num_uuid; xx++) {
 510     mask = 1;
 511     for (yy = 0; yy < BTA_MAX_SERVICE_ID; yy++) {
 512       if (*(p_uuid16 + xx) == bta_service_id_to_uuid_lkup_tbl[yy]) {
 513         *p_services |= mask;
 514         break;
 515       }
 516       mask <<= 1;
 517     }
 518
 519     /* for HSP v1.2 only device */
 520     if (*(p_uuid16 + xx) == UUID_SERVCLASS_HEADSET_HS)
 521       *p_services |= BTA_HSP_SERVICE_MASK;
 522
 523     if (*(p_uuid16 + xx) == UUID_SERVCLASS_HDP_SOURCE)
 524       *p_services |= BTA_HL_SERVICE_MASK;
 525
 526     if (*(p_uuid16 + xx) == UUID_SERVCLASS_HDP_SINK)
 527       *p_services |= BTA_HL_SERVICE_MASK;
 528   }
 529 }
 530
 531 /*******************************************************************************
 532  *
 533  * Function         BTA_DmGetConnectionState
 534  *
 535  * Description      Returns whether the remote device is currently connected.
 536  *
 537  * Returns          0 if the device is NOT connected.
 538  *
 539  ******************************************************************************/
 540 uint16_t BTA_DmGetConnectionState(const RawAddress& bd_addr) {
 541   tBTA_DM_PEER_DEVICE* p_dev = bta_dm_find_peer_device(bd_addr);
 542   return (p_dev && p_dev->conn_state == BTA_DM_CONNECTED);
 543 }
 544
 545 /*******************************************************************************
 546  *                   Device Identification (DI) Server Functions
 547  ******************************************************************************/
 548 /*******************************************************************************
 549  *
 550  * Function         BTA_DmSetLocalDiRecord
 551  *
 552  * Description      This function adds a DI record to the local SDP database.
 553  *
 554  * Returns          BTA_SUCCESS if record set sucessfully, otherwise error code.
 555  *
 556  ******************************************************************************/
 557 tBTA_STATUS BTA_DmSetLocalDiRecord(tBTA_DI_RECORD* p_device_info,
 558                                    uint32_t* p_handle) {
 559   tBTA_STATUS status = BTA_FAILURE;
 560
 561   if (bta_dm_di_cb.di_num < BTA_DI_NUM_MAX) {
 562     if (SDP_SetLocalDiRecord((tSDP_DI_RECORD*)p_device_info, p_handle) ==
 563         SDP_SUCCESS) {
 564       if (!p_device_info->primary_record) {
 565         bta_dm_di_cb.di_handle[bta_dm_di_cb.di_num] = *p_handle;
 566         bta_dm_di_cb.di_num++;
 567       }
 568
 569       bta_sys_add_uuid(UUID_SERVCLASS_PNP_INFORMATION);
 570       status = BTA_SUCCESS;
 571     }
 572   }
 573
 574   return status;
 575 }
 576
 577 /*******************************************************************************
 578  *
 579  * Function         bta_dmexecutecallback
 580  *
 581  * Description      This function will request BTA to execute a call back in the
 582  *                  context of BTU task.
 583  *                  This API was named in lower case because it is only intended
 584  *                  for the internal customers(like BTIF).
 585  *
 586  * Returns          void
 587  *
 588  ******************************************************************************/
 589 void bta_dmexecutecallback(tBTA_DM_EXEC_CBACK* p_callback, void* p_param) {
 590   tBTA_DM_API_EXECUTE_CBACK* p_msg =
 591       (tBTA_DM_API_EXECUTE_CBACK*)osi_malloc(sizeof(tBTA_DM_MSG));
 592
 593   p_msg->hdr.event = BTA_DM_API_EXECUTE_CBACK_EVT;
 594   p_msg->p_param = p_param;
 595   p_msg->p_exec_cback = p_callback;
 596
 597   bta_sys_sendmsg(p_msg);
 598 }
 599
 600 /*******************************************************************************
 601  *
 602  * Function         BTA_DmAddBleKey
 603  *
 604  * Description      Add/modify LE device information.  This function will be
 605  *                  normally called during host startup to restore all required
 606  *                  information stored in the NVRAM.
 607  *
 608  * Parameters:      bd_addr          - BD address of the peer
 609  *                  p_le_key         - LE key values.
 610  *                  key_type         - LE SMP key type.
 611  *
 612  * Returns          BTA_SUCCESS if successful
 613  *                  BTA_FAIL if operation failed.
 614  *
 615  ******************************************************************************/
 616 void BTA_DmAddBleKey(const RawAddress& bd_addr, tBTA_LE_KEY_VALUE* p_le_key,
 617                      tBTA_LE_KEY_TYPE key_type) {
 618   tBTA_DM_API_ADD_BLEKEY* p_msg =
 619       (tBTA_DM_API_ADD_BLEKEY*)osi_calloc(sizeof(tBTA_DM_API_ADD_BLEKEY));
 620
 621   p_msg->hdr.event = BTA_DM_API_ADD_BLEKEY_EVT;
 622   p_msg->key_type = key_type;
 623   p_msg->bd_addr = bd_addr;
 624   memcpy(&p_msg->blekey, p_le_key, sizeof(tBTA_LE_KEY_VALUE));
 625
 626   bta_sys_sendmsg(p_msg);
 627 }
 628
 629 /*******************************************************************************
 630  *
 631  * Function         BTA_DmAddBleDevice
 632  *
 633  * Description      Add a BLE device.  This function will be normally called
 634  *                  during host startup to restore all required information
 635  *                  for a LE device stored in the NVRAM.
 636  *
 637  * Parameters:      bd_addr          - BD address of the peer
 638  *                  dev_type         - Remote device's device type.
 639  *                  addr_type        - LE device address type.
 640  *
 641  * Returns          void
 642  *
 643  ******************************************************************************/
 644 void BTA_DmAddBleDevice(const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type,
 645                         tBT_DEVICE_TYPE dev_type) {
 646   tBTA_DM_API_ADD_BLE_DEVICE* p_msg = (tBTA_DM_API_ADD_BLE_DEVICE*)osi_calloc(
 647       sizeof(tBTA_DM_API_ADD_BLE_DEVICE));
 648
 649   p_msg->hdr.event = BTA_DM_API_ADD_BLEDEVICE_EVT;
 650   p_msg->bd_addr = bd_addr;
 651   p_msg->addr_type = addr_type;
 652   p_msg->dev_type = dev_type;
 653
 654   bta_sys_sendmsg(p_msg);
 655 }
 656
 657 /*******************************************************************************
 658  *
 659  * Function         BTA_DmBlePasskeyReply
 660  *
 661  * Description      Send BLE SMP passkey reply.
 662  *
 663  * Parameters:      bd_addr          - BD address of the peer
 664  *                  accept           - passkey entry sucessful or declined.
 665  *                  passkey          - passkey value, must be a 6 digit number,
 666  *                                     can be lead by 0.
 667  *
 668  * Returns          void
 669  *
 670  ******************************************************************************/
 671 void BTA_DmBlePasskeyReply(const RawAddress& bd_addr, bool accept,
 672                            uint32_t passkey) {
 673   tBTA_DM_API_PASSKEY_REPLY* p_msg =
 674       (tBTA_DM_API_PASSKEY_REPLY*)osi_calloc(sizeof(tBTA_DM_API_PASSKEY_REPLY));
 675
 676   p_msg->hdr.event = BTA_DM_API_BLE_PASSKEY_REPLY_EVT;
 677   p_msg->bd_addr = bd_addr;
 678   p_msg->accept = accept;
 679
 680   if (accept) p_msg->passkey = passkey;
 681
 682   bta_sys_sendmsg(p_msg);
 683 }
 684
 685 /*******************************************************************************
 686  *
 687  * Function         BTA_DmBleConfirmReply
 688  *
 689  * Description      Send BLE SMP SC user confirmation reply.
 690  *
 691  * Parameters:      bd_addr          - BD address of the peer
 692  *                  accept           - numbers to compare are the same or
 693  *                                     different.
 694  *
 695  * Returns          void
 696  *
 697  ******************************************************************************/
 698 void BTA_DmBleConfirmReply(const RawAddress& bd_addr, bool accept) {
 699   tBTA_DM_API_CONFIRM* p_msg =
 700       (tBTA_DM_API_CONFIRM*)osi_calloc(sizeof(tBTA_DM_API_CONFIRM));
 701
 702   p_msg->hdr.event = BTA_DM_API_BLE_CONFIRM_REPLY_EVT;
 703   p_msg->bd_addr = bd_addr;
 704   p_msg->accept = accept;
 705
 706   bta_sys_sendmsg(p_msg);
 707 }
 708
 709 /*******************************************************************************
 710  *
 711  * Function         BTA_DmBleSecurityGrant
 712  *
 713  * Description      Grant security request access.
 714  *
 715  * Parameters:      bd_addr          - BD address of the peer
 716  *                  res              - security grant status.
 717  *
 718  * Returns          void
 719  *
 720  ******************************************************************************/
 721 void BTA_DmBleSecurityGrant(const RawAddress& bd_addr,
 722                             tBTA_DM_BLE_SEC_GRANT res) {
 723   tBTA_DM_API_BLE_SEC_GRANT* p_msg =
 724       (tBTA_DM_API_BLE_SEC_GRANT*)osi_calloc(sizeof(tBTA_DM_API_BLE_SEC_GRANT));
 725
 726   p_msg->hdr.event = BTA_DM_API_BLE_SEC_GRANT_EVT;
 727   p_msg->bd_addr = bd_addr;
 728   p_msg->res = res;
 729
 730   bta_sys_sendmsg(p_msg);
 731 }
 732
 733 /*******************************************************************************
 734  *
 735  * Function         BTA_DmSetBlePrefConnParams
 736  *
 737  * Description      This function is called to set the preferred connection
 738  *                  parameters when default connection parameter is not desired.
 739  *
 740  * Parameters:      bd_addr          - BD address of the peripheral
 741  *                  scan_interval    - scan interval
 742  *                  scan_window      - scan window
 743  *                  min_conn_int     - minimum preferred connection interval
 744  *                  max_conn_int     - maximum preferred connection interval
 745  *                  slave_latency    - preferred slave latency
 746  *                  supervision_tout - preferred supervision timeout
 747  *
 748  *
 749  * Returns          void
 750  *
 751  ******************************************************************************/
 752 void BTA_DmSetBlePrefConnParams(const RawAddress& bd_addr,
 753                                 uint16_t min_conn_int, uint16_t max_conn_int,
 754                                 uint16_t slave_latency,
 755                                 uint16_t supervision_tout) {
 756   tBTA_DM_API_BLE_CONN_PARAMS* p_msg = (tBTA_DM_API_BLE_CONN_PARAMS*)osi_calloc(
 757       sizeof(tBTA_DM_API_BLE_CONN_PARAMS));
 758
 759   p_msg->hdr.event = BTA_DM_API_BLE_CONN_PARAM_EVT;
 760   p_msg->peer_bda = bd_addr;
 761   p_msg->conn_int_max = max_conn_int;
 762   p_msg->conn_int_min = min_conn_int;
 763   p_msg->slave_latency = slave_latency;
 764   p_msg->supervision_tout = supervision_tout;
 765
 766   bta_sys_sendmsg(p_msg);
 767 }
 768
 769 /*******************************************************************************
 770  *
 771  * Function         BTA_DmSetBleConnScanParams
 772  *
 773  * Description      This function is called to set scan parameters used in
 774  *                  BLE connection request
 775  *
 776  * Parameters:      scan_interval    - scan interval
 777  *                  scan_window      - scan window
 778  *
 779  * Returns          void
 780  *
 781  ******************************************************************************/
 782 void BTA_DmSetBleConnScanParams(uint32_t scan_interval, uint32_t scan_window) {
 783   tBTA_DM_API_BLE_SCAN_PARAMS* p_msg = (tBTA_DM_API_BLE_SCAN_PARAMS*)osi_calloc(
 784       sizeof(tBTA_DM_API_BLE_SCAN_PARAMS));
 785
 786   p_msg->hdr.event = BTA_DM_API_BLE_CONN_SCAN_PARAM_EVT;
 787   p_msg->scan_int = scan_interval;
 788   p_msg->scan_window = scan_window;
 789
 790   bta_sys_sendmsg(p_msg);
 791 }
 792
 793 /**
 794  * Set BLE connectable mode to auto connect
 795  */
 796 void BTA_DmBleStartAutoConn() {
 797   tBTA_DM_API_SET_NAME* p_msg =
 798       (tBTA_DM_API_SET_NAME*)osi_calloc(sizeof(tBTA_DM_API_SET_NAME));
 799
 800   p_msg->hdr.event = BTA_DM_API_BLE_SET_BG_CONN_TYPE;
 801   bta_sys_sendmsg(p_msg);
 802 }
 803
 804 /*******************************************************************************
 805  *
 806  * Function         bta_dm_discover_send_msg
 807  *
 808  * Description      This function send discover message to BTA task.
 809  *
 810  * Returns          void
 811  *
 812  ******************************************************************************/
 813 static void bta_dm_discover_send_msg(const RawAddress& bd_addr,
 814                                      tBTA_SERVICE_MASK_EXT* p_services,
 815                                      tBTA_DM_SEARCH_CBACK* p_cback,
 816                                      bool sdp_search,
 817                                      tBTA_TRANSPORT transport) {
 818   const size_t len = p_services ? (sizeof(tBTA_DM_API_DISCOVER) +
 819                                    sizeof(tBT_UUID) * p_services->num_uuid)
 820                                 : sizeof(tBTA_DM_API_DISCOVER);
 821   tBTA_DM_API_DISCOVER* p_msg = (tBTA_DM_API_DISCOVER*)osi_calloc(len);
 822
 823   p_msg->hdr.event = BTA_DM_API_DISCOVER_EVT;
 824   p_msg->bd_addr = bd_addr;
 825   p_msg->p_cback = p_cback;
 826   p_msg->sdp_search = sdp_search;
 827   p_msg->transport = transport;
 828
 829   if (p_services != NULL) {
 830     p_msg->services = p_services->srvc_mask;
 831     p_msg->num_uuid = p_services->num_uuid;
 832     if (p_services->num_uuid != 0) {
 833       p_msg->p_uuid = (tBT_UUID*)(p_msg + 1);
 834       memcpy(p_msg->p_uuid, p_services->p_uuid,
 835              sizeof(tBT_UUID) * p_services->num_uuid);
 836     }
 837   }
 838
 839   bta_sys_sendmsg(p_msg);
 840 }
 841
 842 /*******************************************************************************
 843  *
 844  * Function         BTA_DmDiscoverByTransport
 845  *
 846  * Description      This function does service discovery on particular transport
 847  *                  for services of a
 848  *                  peer device. When services.num_uuid is 0, it indicates all
 849  *                  GATT based services are to be searched; otherwise a list of
 850  *                  UUID of interested services should be provided through
 851  *                  p_services->p_uuid.
 852  *
 853  *
 854  *
 855  * Returns          void
 856  *
 857  ******************************************************************************/
 858 void BTA_DmDiscoverByTransport(const RawAddress& bd_addr,
 859                                tBTA_SERVICE_MASK_EXT* p_services,
 860                                tBTA_DM_SEARCH_CBACK* p_cback, bool sdp_search,
 861                                tBTA_TRANSPORT transport) {
 862   bta_dm_discover_send_msg(bd_addr, p_services, p_cback, sdp_search, transport);
 863 }
 864
 865 /*******************************************************************************
 866  *
 867  * Function         BTA_DmDiscoverExt
 868  *
 869  * Description      This function does service discovery for services of a
 870  *                  peer device. When services.num_uuid is 0, it indicates all
 871  *                  GATT based services are to be searched; other wise a list of
 872  *                  UUID of interested services should be provided through
 873  *                  p_services->p_uuid.
 874  *
 875  *
 876  *
 877  * Returns          void
 878  *
 879  ******************************************************************************/
 880 void BTA_DmDiscoverExt(const RawAddress& bd_addr,
 881                        tBTA_SERVICE_MASK_EXT* p_services,
 882                        tBTA_DM_SEARCH_CBACK* p_cback, bool sdp_search) {
 883   bta_dm_discover_send_msg(bd_addr, p_services, p_cback, sdp_search,
 884                            BTA_TRANSPORT_UNKNOWN);
 885 }
 886
 887 /*******************************************************************************
 888  *
 889  * Function         BTA_DmSearchExt
 890  *
 891  * Description      This function searches for peer Bluetooth devices. It
 892  *                  performs an inquiry and gets the remote name for devices.
 893  *                  Service discovery is done if services is non zero
 894  *
 895  * Parameters       p_dm_inq: inquiry conditions
 896  *                  p_services: if service is not empty, service discovery will
 897  *                              be done. For all GATT based service conditions,
 898  *                              put num_uuid, and p_uuid is the pointer to the
 899  *                              list of UUID values.
 900  *                  p_cback: callback function when search is completed.
 901  *
 902  *
 903  *
 904  * Returns          void
 905  *
 906  ******************************************************************************/
 907 void BTA_DmSearchExt(tBTA_DM_INQ* p_dm_inq, tBTA_SERVICE_MASK_EXT* p_services,
 908                      tBTA_DM_SEARCH_CBACK* p_cback) {
 909   const size_t len = p_services ? (sizeof(tBTA_DM_API_SEARCH) +
 910                                    sizeof(tBT_UUID) * p_services->num_uuid)
 911                                 : sizeof(tBTA_DM_API_SEARCH);
 912   tBTA_DM_API_SEARCH* p_msg = (tBTA_DM_API_SEARCH*)osi_calloc(len);
 913
 914   p_msg->hdr.event = BTA_DM_API_SEARCH_EVT;
 915   memcpy(&p_msg->inq_params, p_dm_inq, sizeof(tBTA_DM_INQ));
 916   p_msg->p_cback = p_cback;
 917   p_msg->rs_res = BTA_DM_RS_NONE;
 918
 919   if (p_services != NULL) {
 920     p_msg->services = p_services->srvc_mask;
 921     p_msg->num_uuid = p_services->num_uuid;
 922
 923     if (p_services->num_uuid != 0) {
 924       p_msg->p_uuid = (tBT_UUID*)(p_msg + 1);
 925       memcpy(p_msg->p_uuid, p_services->p_uuid,
 926              sizeof(tBT_UUID) * p_services->num_uuid);
 927     } else {
 928       p_msg->p_uuid = NULL;
 929     }
 930   }
 931
 932   bta_sys_sendmsg(p_msg);
 933 }
 934
 935 /*******************************************************************************
 936  *
 937  * Function         BTA_DmBleUpdateConnectionParam
 938  *
 939  * Description      Update connection parameters, can only be used when
 940  *                  connection is up.
 941  *
 942  * Parameters:      bd_addr          - BD address of the peer
 943  *                  min_int   -     minimum connection interval,
 944  *                                  [0x0004 ~ 0x4000]
 945  *                  max_int   -     maximum connection interval,
 946  *                                  [0x0004 ~ 0x4000]
 947  *                  latency   -     slave latency [0 ~ 500]
 948  *                  timeout   -     supervision timeout [0x000a ~ 0xc80]
 949  *
 950  * Returns          void
 951  *
 952  ******************************************************************************/
 953 void BTA_DmBleUpdateConnectionParam(const RawAddress& bd_addr, uint16_t min_int,
 954                                     uint16_t max_int, uint16_t latency,
 955                                     uint16_t timeout) {
 956   tBTA_DM_API_UPDATE_CONN_PARAM* p_msg =
 957       (tBTA_DM_API_UPDATE_CONN_PARAM*)osi_calloc(
 958           sizeof(tBTA_DM_API_UPDATE_CONN_PARAM));
 959
 960   p_msg->hdr.event = BTA_DM_API_UPDATE_CONN_PARAM_EVT;
 961   p_msg->bd_addr = bd_addr;
 962   p_msg->min_int = min_int;
 963   p_msg->max_int = max_int;
 964   p_msg->latency = latency;
 965   p_msg->timeout = timeout;
 966
 967   bta_sys_sendmsg(p_msg);
 968 }
 969
 970 /*******************************************************************************
 971  *
 972  * Function         BTA_DmBleConfigLocalPrivacy
 973  *
 974  * Description      Enable/disable privacy on the local device
 975  *
 976  * Parameters:      privacy_enable   - enable/disabe privacy on remote device.
 977  *
 978  * Returns          void
 979  *
 980  ******************************************************************************/
 981 void BTA_DmBleConfigLocalPrivacy(bool privacy_enable) {
 982 #if (BLE_PRIVACY_SPT == TRUE)
 983   tBTA_DM_API_LOCAL_PRIVACY* p_msg = (tBTA_DM_API_LOCAL_PRIVACY*)osi_calloc(
 984       sizeof(tBTA_DM_API_ENABLE_PRIVACY));
 985
 986   p_msg->hdr.event = BTA_DM_API_LOCAL_PRIVACY_EVT;
 987   p_msg->privacy_enable = privacy_enable;
 988
 989   bta_sys_sendmsg(p_msg);
 990 #else
 991   UNUSED(privacy_enable);
 992 #endif
 993 }
 994
 995 /*******************************************************************************
 996  *
 997  * Function         BTA_DmBleGetEnergyInfo
 998  *
 999  * Description      This function is called to obtain the energy info
1000  *
1001  * Parameters       p_cmpl_cback - Command complete callback
1002  *
1003  * Returns          void
1004  *
1005  ******************************************************************************/
1006 void BTA_DmBleGetEnergyInfo(tBTA_BLE_ENERGY_INFO_CBACK* p_cmpl_cback) {
1007   const size_t len = sizeof(tBTA_DM_API_ENERGY_INFO) + sizeof(tBLE_BD_ADDR);
1008   tBTA_DM_API_ENERGY_INFO* p_msg = (tBTA_DM_API_ENERGY_INFO*)osi_calloc(len);
1009
1010   APPL_TRACE_API("%s", __func__);
1011
1012   p_msg->hdr.event = BTA_DM_API_BLE_ENERGY_INFO_EVT;
1013   p_msg->p_energy_info_cback = p_cmpl_cback;
1014
1015   bta_sys_sendmsg(p_msg);
1016 }
1017
1018 /*******************************************************************************
1019  *
1020  * Function         BTA_DmBleUpdateConnectionParams
1021  *
1022  * Description      Update connection parameters, can only be used when
1023  *                  connection is up.
1024  *
1025  * Parameters:      bd_addr   - BD address of the peer
1026  *                  min_int   -     minimum connection interval,
1027  *                                  [0x0004 ~ 0x4000]
1028  *                  max_int   -     maximum connection interval,
1029  *                                  [0x0004 ~ 0x4000]
1030  *                  latency   -     slave latency [0 ~ 500]
1031  *                  timeout   -     supervision timeout [0x000a ~ 0xc80]
1032  *
1033  * Returns          void
1034  *
1035  ******************************************************************************/
1036 void BTA_DmBleUpdateConnectionParams(const RawAddress& bd_addr,
1037                                      uint16_t min_int, uint16_t max_int,
1038                                      uint16_t latency, uint16_t timeout) {
1039   tBTA_DM_API_UPDATE_CONN_PARAM* p_msg =
1040       (tBTA_DM_API_UPDATE_CONN_PARAM*)osi_calloc(
1041           sizeof(tBTA_DM_API_UPDATE_CONN_PARAM));
1042
1043   p_msg->hdr.event = BTA_DM_API_UPDATE_CONN_PARAM_EVT;
1044   p_msg->bd_addr = bd_addr;
1045   p_msg->min_int = min_int;
1046   p_msg->max_int = max_int;
1047   p_msg->latency = latency;
1048   p_msg->timeout = timeout;
1049
1050   bta_sys_sendmsg(p_msg);
1051 }
1052
1053 /*******************************************************************************
1054  *
1055  * Function         BTA_DmBleSetDataLength
1056  *
1057  * Description      This function is to set maximum LE data packet size
1058  *
1059  * Returns          void
1060  *
1061  *
1062  ******************************************************************************/
1063 void BTA_DmBleSetDataLength(const RawAddress& remote_device,
1064                             uint16_t tx_data_length) {
1065   tBTA_DM_API_BLE_SET_DATA_LENGTH* p_msg =
1066       (tBTA_DM_API_BLE_SET_DATA_LENGTH*)osi_malloc(
1067           sizeof(tBTA_DM_API_BLE_SET_DATA_LENGTH));
1068
1069   p_msg->remote_bda = remote_device;
1070   p_msg->hdr.event = BTA_DM_API_SET_DATA_LENGTH_EVT;
1071   p_msg->tx_data_length = tx_data_length;
1072
1073   bta_sys_sendmsg(p_msg);
1074 }
1075
1076 /*******************************************************************************
1077  *
1078  * Function         BTA_DmSetEncryption
1079  *
1080  * Description      This function is called to ensure that connection is
1081  *                  encrypted.  Should be called only on an open connection.
1082  *                  Typically only needed for connections that first want to
1083  *                  bring up unencrypted links, then later encrypt them.
1084  *
1085  * Parameters:      bd_addr       - Address of the peer device
1086  *                  transport     - transport of the link to be encruypted
1087  *                  p_callback    - Pointer to callback function to indicat the
1088  *                                  link encryption status
1089  *                  sec_act       - This is the security action to indicate
1090  *                                  what kind of BLE security level is required
1091  *                                  for the BLE link if BLE is supported.
1092  *                                  Note: This parameter is ignored for the
1093  *                                        BR/EDR or if BLE is not supported.
1094  *
1095  * Returns          void
1096  *
1097  ******************************************************************************/
1098 void BTA_DmSetEncryption(const RawAddress& bd_addr, tBTA_TRANSPORT transport,
1099                          tBTA_DM_ENCRYPT_CBACK* p_callback,
1100                          tBTA_DM_BLE_SEC_ACT sec_act) {
1101   tBTA_DM_API_SET_ENCRYPTION* p_msg = (tBTA_DM_API_SET_ENCRYPTION*)osi_calloc(
1102       sizeof(tBTA_DM_API_SET_ENCRYPTION));
1103
1104   APPL_TRACE_API("%s", __func__);
1105
1106   p_msg->hdr.event = BTA_DM_API_SET_ENCRYPTION_EVT;
1107   p_msg->bd_addr = bd_addr;
1108   p_msg->transport = transport;
1109   p_msg->p_callback = p_callback;
1110   p_msg->sec_act = sec_act;
1111
1112   bta_sys_sendmsg(p_msg);
1113 }
1114
1115 /*******************************************************************************
1116  *
1117  * Function         BTA_DmCloseACL
1118  *
1119  * Description      This function force to close an ACL connection and remove
1120  *                  the device from the security database list of known devices.
1121  *
1122  * Parameters:      bd_addr       - Address of the peer device
1123  *                  remove_dev    - remove device or not after link down
1124  *
1125  * Returns          void
1126  *
1127  ******************************************************************************/
1128 void BTA_DmCloseACL(const RawAddress& bd_addr, bool remove_dev,
1129                     tBTA_TRANSPORT transport) {
1130   tBTA_DM_API_REMOVE_ACL* p_msg =
1131       (tBTA_DM_API_REMOVE_ACL*)osi_calloc(sizeof(tBTA_DM_API_REMOVE_ACL));
1132
1133   APPL_TRACE_API("%s", __func__);
1134
1135   p_msg->hdr.event = BTA_DM_API_REMOVE_ACL_EVT;
1136   p_msg->bd_addr = bd_addr;
1137   p_msg->remove_dev = remove_dev;
1138   p_msg->transport = transport;
1139
1140   bta_sys_sendmsg(p_msg);
1141 }
1142
1143 /*******************************************************************************
1144  *
1145  * Function         BTA_DmBleObserve
1146  *
1147  * Description      This procedure keep the device listening for advertising
1148  *                  events from a broadcast device.
1149  *
1150  * Parameters       start: start or stop observe.
1151  *
1152  * Returns          void
1153
1154  *
1155  * Returns          void.
1156  *
1157  ******************************************************************************/
1158 extern void BTA_DmBleObserve(bool start, uint8_t duration,
1159                              tBTA_DM_SEARCH_CBACK* p_results_cb) {
1160   tBTA_DM_API_BLE_OBSERVE* p_msg =
1161       (tBTA_DM_API_BLE_OBSERVE*)osi_calloc(sizeof(tBTA_DM_API_BLE_OBSERVE));
1162
1163   APPL_TRACE_API("%s:start = %d ", __func__, start);
1164
1165   p_msg->hdr.event = BTA_DM_API_BLE_OBSERVE_EVT;
1166   p_msg->start = start;
1167   p_msg->duration = duration;
1168   p_msg->p_cback = p_results_cb;
1169
1170   bta_sys_sendmsg(p_msg);
1171 }
1172
1173 /*******************************************************************************
1174  *
1175  * Function         BTA_VendorInit
1176  *
1177  * Description      This function initializes vendor specific
1178  *
1179  * Returns          void
1180  *
1181  ******************************************************************************/
1182 void BTA_VendorInit(void) { APPL_TRACE_API("BTA_VendorInit"); }
1183
1184 /*******************************************************************************
1185  *
1186  * Function         BTA_VendorCleanup
1187  *
1188  * Description      This function frees up Broadcom specific VS specific dynamic
1189  *                  memory
1190  *
1191  * Returns          void
1192  *
1193  ******************************************************************************/
1194 void BTA_VendorCleanup(void) {
1195   tBTM_BLE_VSC_CB cmn_ble_vsc_cb;
1196   BTM_BleGetVendorCapabilities(&cmn_ble_vsc_cb);
1197
1198   if (cmn_ble_vsc_cb.max_filter > 0) {
1199     btm_ble_adv_filter_cleanup();
1200 #if (BLE_PRIVACY_SPT == TRUE)
1201     btm_ble_resolving_list_cleanup();
1202 #endif
1203   }
1204
1205   if (cmn_ble_vsc_cb.tot_scan_results_strg > 0) btm_ble_batchscan_cleanup();
1206
1207   if (cmn_ble_vsc_cb.adv_inst_max > 0) btm_ble_multi_adv_cleanup();
1208 }