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