bta_dm_api.cc revision c2276b06572ab6fc1f900fbb1f41087e77d47e2a 
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
42static const tBTA_SYS_REG bta_dm_reg = {bta_dm_sm_execute, bta_dm_sm_disable};
43
44static 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 ******************************************************************************/
58tBTA_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 ******************************************************************************/
88tBTA_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 ******************************************************************************/
108tBTA_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 ******************************************************************************/
129void 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 ******************************************************************************/
148void 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 ******************************************************************************/
170void 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 ******************************************************************************/
196void 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 ******************************************************************************/
220void 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 ******************************************************************************/
238void BTA_DmDiscover(const bt_bdaddr_t& 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 ******************************************************************************/
263void BTA_DmDiscoverUUID(const bt_bdaddr_t& 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 ******************************************************************************/
293void BTA_DmBond(const bt_bdaddr_t& 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 ******************************************************************************/
315void BTA_DmBondByTransport(const bt_bdaddr_t& 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 ******************************************************************************/
338void BTA_DmBondCancel(const bt_bdaddr_t& 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 ******************************************************************************/
359void BTA_DmPinReply(const bt_bdaddr_t& 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 ******************************************************************************/
390void 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 ******************************************************************************/
408void BTA_DmConfirm(const bt_bdaddr_t& 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 ******************************************************************************/
430void BTA_DmAddDevice(const bt_bdaddr_t& 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 ******************************************************************************/
474tBTA_STATUS BTA_DmRemoveDevice(const bt_bdaddr_t& 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 ******************************************************************************/
498extern const uint16_t bta_service_id_to_uuid_lkup_tbl[];
499void 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 ******************************************************************************/
540uint16_t BTA_DmGetConnectionState(const bt_bdaddr_t& 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 ******************************************************************************/
557tBTA_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 ******************************************************************************/
589void 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 ******************************************************************************/
616void BTA_DmAddBleKey(const bt_bdaddr_t& 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 ******************************************************************************/
644void BTA_DmAddBleDevice(const bt_bdaddr_t& 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 ******************************************************************************/
671void BTA_DmBlePasskeyReply(const bt_bdaddr_t& 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 ******************************************************************************/
698void BTA_DmBleConfirmReply(const bt_bdaddr_t& 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 ******************************************************************************/
721void BTA_DmBleSecurityGrant(const bt_bdaddr_t& 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 ******************************************************************************/
752void BTA_DmSetBlePrefConnParams(const bt_bdaddr_t& 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 ******************************************************************************/
782void 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 */
796void 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 ******************************************************************************/
813static void bta_dm_discover_send_msg(const bt_bdaddr_t& 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 ******************************************************************************/
858void BTA_DmDiscoverByTransport(const bt_bdaddr_t& 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 ******************************************************************************/
880void BTA_DmDiscoverExt(const bt_bdaddr_t& 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 ******************************************************************************/
907void 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 ******************************************************************************/
953void BTA_DmBleUpdateConnectionParam(const bt_bdaddr_t& bd_addr,
954                                    uint16_t min_int, uint16_t max_int,
955                                    uint16_t latency, 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 ******************************************************************************/
981void 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 ******************************************************************************/
1006void 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 ******************************************************************************/
1036void BTA_DmBleUpdateConnectionParams(const bt_bdaddr_t& 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 ******************************************************************************/
1063void BTA_DmBleSetDataLength(const bt_bdaddr_t& 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 ******************************************************************************/
1098void BTA_DmSetEncryption(const bt_bdaddr_t& 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 ******************************************************************************/
1128void BTA_DmCloseACL(const bt_bdaddr_t& 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 ******************************************************************************/
1158extern 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 ******************************************************************************/
1182void 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 ******************************************************************************/
1194void 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}
1209