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 
25 #include "gki.h"
26 #include "bta_sys.h"
27 #include "bta_api.h"
28 #include "bta_dm_int.h"
29 #include "bta_sys_int.h"
30 #include "btm_api.h"
31 #include "btm_int.h"
32 #include <string.h>
33 #include "utl.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     bta_sys_register (BTA_ID_DM, &bta_dm_reg );
74     bta_sys_register (BTA_ID_DM_SEARCH, &bta_dm_search_reg );
75 
76     /* if UUID list is not provided as static data */
77     bta_sys_eir_register(bta_dm_eir_update_uuid);
78 
79     if ((p_msg = (tBTA_DM_API_ENABLE *) GKI_getbuf(sizeof(tBTA_DM_API_ENABLE))) != NULL)
80     {
81         p_msg->hdr.event = BTA_DM_API_ENABLE_EVT;
82         p_msg->p_sec_cback = p_cback;
83         bta_sys_sendmsg(p_msg);
84         return BTA_SUCCESS;
85     }
86     return BTA_FAILURE;
87 
88 }
89 
90 /*******************************************************************************
91 **
92 ** Function         BTA_DisableBluetooth
93 **
94 ** Description      Disables bluetooth service.  This function is called when
95 **                  the application no longer needs bluetooth service
96 **
97 ** Returns          void
98 **
99 *******************************************************************************/
BTA_DisableBluetooth(void)100 tBTA_STATUS BTA_DisableBluetooth(void)
101 {
102 
103     BT_HDR    *p_msg;
104 
105     if ((p_msg = (BT_HDR *) GKI_getbuf(sizeof(BT_HDR))) != NULL)
106     {
107         p_msg->event = BTA_DM_API_DISABLE_EVT;
108         bta_sys_sendmsg(p_msg);
109     }
110     else
111     {
112         return BTA_FAILURE;
113     }
114 
115     return BTA_SUCCESS;
116 }
117 
118 /*******************************************************************************
119 **
120 ** Function         BTA_EnableTestMode
121 **
122 ** Description      Enables bluetooth device under test mode
123 **
124 **
125 ** Returns          tBTA_STATUS
126 **
127 *******************************************************************************/
BTA_EnableTestMode(void)128 tBTA_STATUS BTA_EnableTestMode(void)
129 {
130     BT_HDR    *p_msg;
131 
132     APPL_TRACE_API("BTA_EnableTestMode");
133 
134     if ((p_msg = (BT_HDR *) GKI_getbuf(sizeof(BT_HDR))) != NULL)
135     {
136         p_msg->event = BTA_DM_API_ENABLE_TEST_MODE_EVT;
137         bta_sys_sendmsg(p_msg);
138         return BTA_SUCCESS;
139     }
140     return BTA_FAILURE;
141 }
142 
143 /*******************************************************************************
144 **
145 ** Function         BTA_DisableTestMode
146 **
147 ** Description      Disable bluetooth device under test mode
148 **
149 **
150 ** Returns          None
151 **
152 *******************************************************************************/
BTA_DisableTestMode(void)153 void BTA_DisableTestMode(void)
154 {
155     BT_HDR    *p_msg;
156 
157     APPL_TRACE_API("BTA_DisableTestMode");
158 
159     if ((p_msg = (BT_HDR *) GKI_getbuf(sizeof(BT_HDR))) != NULL)
160     {
161         p_msg->event = BTA_DM_API_DISABLE_TEST_MODE_EVT;
162         bta_sys_sendmsg(p_msg);
163     }
164 }
165 
166 /*******************************************************************************
167 **
168 ** Function         BTA_DmSetDeviceName
169 **
170 ** Description      This function sets the Bluetooth name of local device
171 **
172 **
173 ** Returns          void
174 **
175 *******************************************************************************/
BTA_DmSetDeviceName(char * p_name)176 void BTA_DmSetDeviceName(char *p_name)
177 {
178 
179     tBTA_DM_API_SET_NAME    *p_msg;
180 
181     if ((p_msg = (tBTA_DM_API_SET_NAME *) GKI_getbuf(sizeof(tBTA_DM_API_SET_NAME))) != NULL)
182     {
183         p_msg->hdr.event = BTA_DM_API_SET_NAME_EVT;
184         /* truncate the name if needed */
185         BCM_STRNCPY_S((char*)p_msg->name, sizeof(p_msg->name), p_name, BD_NAME_LEN-1);
186         p_msg->name[BD_NAME_LEN-1]=0;
187 
188         bta_sys_sendmsg(p_msg);
189     }
190 
191 
192 }
193 
194 /*******************************************************************************
195 **
196 ** Function         BTA_DmSetVisibility
197 **
198 ** Description      This function sets the Bluetooth connectable,
199 **                  discoverable, pairable and conn paired only modes of local device
200 **
201 **
202 ** Returns          void
203 **
204 *******************************************************************************/
BTA_DmSetVisibility(tBTA_DM_DISC disc_mode,tBTA_DM_CONN conn_mode,UINT8 pairable_mode,UINT8 conn_filter)205 void BTA_DmSetVisibility(tBTA_DM_DISC disc_mode, tBTA_DM_CONN conn_mode, UINT8 pairable_mode, UINT8 conn_filter )
206 {
207 
208     tBTA_DM_API_SET_VISIBILITY    *p_msg;
209 
210     if ((p_msg = (tBTA_DM_API_SET_VISIBILITY *) GKI_getbuf(sizeof(tBTA_DM_MSG))) != NULL)
211     {
212         p_msg->hdr.event = BTA_DM_API_SET_VISIBILITY_EVT;
213         p_msg->disc_mode = disc_mode;
214         p_msg->conn_mode = conn_mode;
215         p_msg->pair_mode = pairable_mode;
216         p_msg->conn_paired_only = conn_filter;
217 
218 
219         bta_sys_sendmsg(p_msg);
220     }
221 
222 
223 }
224 
225 /*******************************************************************************
226 **
227 ** Function         BTA_DmSearch
228 **
229 ** Description      This function searches for peer Bluetooth devices. It performs
230 **                  an inquiry and gets the remote name for devices. Service
231 **                  discovery is done if services is non zero
232 **
233 **
234 ** Returns          void
235 **
236 *******************************************************************************/
BTA_DmSearch(tBTA_DM_INQ * p_dm_inq,tBTA_SERVICE_MASK services,tBTA_DM_SEARCH_CBACK * p_cback)237 void BTA_DmSearch(tBTA_DM_INQ *p_dm_inq, tBTA_SERVICE_MASK services, tBTA_DM_SEARCH_CBACK *p_cback)
238 {
239 
240     tBTA_DM_API_SEARCH    *p_msg;
241 
242     if ((p_msg = (tBTA_DM_API_SEARCH *) GKI_getbuf(sizeof(tBTA_DM_API_SEARCH))) != NULL)
243     {
244         memset(p_msg, 0, sizeof(tBTA_DM_API_SEARCH));
245 
246         p_msg->hdr.event = BTA_DM_API_SEARCH_EVT;
247         memcpy(&p_msg->inq_params, p_dm_inq, sizeof(tBTA_DM_INQ));
248         p_msg->services = services;
249         p_msg->p_cback = p_cback;
250         p_msg->rs_res  = BTA_DM_RS_NONE;
251         bta_sys_sendmsg(p_msg);
252     }
253 
254 }
255 
256 
257 /*******************************************************************************
258 **
259 ** Function         BTA_DmSearchCancel
260 **
261 ** Description      This function  cancels a search initiated by BTA_DmSearch
262 **
263 **
264 ** Returns          void
265 **
266 *******************************************************************************/
BTA_DmSearchCancel(void)267 void BTA_DmSearchCancel(void)
268 {
269     BT_HDR    *p_msg;
270 
271     if ((p_msg = (BT_HDR *) GKI_getbuf(sizeof(BT_HDR))) != NULL)
272     {
273         p_msg->event = BTA_DM_API_SEARCH_CANCEL_EVT;
274         bta_sys_sendmsg(p_msg);
275     }
276 
277 }
278 
279 /*******************************************************************************
280 **
281 ** Function         BTA_DmDiscover
282 **
283 ** Description      This function does service discovery for services of a
284 **                  peer device
285 **
286 **
287 ** Returns          void
288 **
289 *******************************************************************************/
BTA_DmDiscover(BD_ADDR bd_addr,tBTA_SERVICE_MASK services,tBTA_DM_SEARCH_CBACK * p_cback,BOOLEAN sdp_search)290 void BTA_DmDiscover(BD_ADDR bd_addr, tBTA_SERVICE_MASK services,
291                     tBTA_DM_SEARCH_CBACK *p_cback, BOOLEAN sdp_search)
292 {
293     tBTA_DM_API_DISCOVER    *p_msg;
294 
295     if ((p_msg = (tBTA_DM_API_DISCOVER *) GKI_getbuf(sizeof(tBTA_DM_API_DISCOVER))) != NULL)
296     {
297         memset(p_msg, 0, sizeof(tBTA_DM_API_DISCOVER));
298 
299         p_msg->hdr.event = BTA_DM_API_DISCOVER_EVT;
300         bdcpy(p_msg->bd_addr, bd_addr);
301         p_msg->services = services;
302         p_msg->p_cback = p_cback;
303         p_msg->sdp_search = sdp_search;
304         bta_sys_sendmsg(p_msg);
305     }
306 
307 }
308 
309 /*******************************************************************************
310 **
311 ** Function         BTA_DmDiscoverUUID
312 **
313 ** Description      This function does service discovery for services of a
314 **                  peer device
315 **
316 **
317 ** Returns          void
318 **
319 *******************************************************************************/
BTA_DmDiscoverUUID(BD_ADDR bd_addr,tSDP_UUID * uuid,tBTA_DM_SEARCH_CBACK * p_cback,BOOLEAN sdp_search)320 void BTA_DmDiscoverUUID(BD_ADDR bd_addr, tSDP_UUID *uuid,
321                     tBTA_DM_SEARCH_CBACK *p_cback, BOOLEAN sdp_search)
322 {
323     tBTA_DM_API_DISCOVER    *p_msg;
324 
325     if ((p_msg = (tBTA_DM_API_DISCOVER *) GKI_getbuf(sizeof(tBTA_DM_API_DISCOVER))) != NULL)
326     {
327         p_msg->hdr.event = BTA_DM_API_DISCOVER_EVT;
328         bdcpy(p_msg->bd_addr, bd_addr);
329         p_msg->services = BTA_USER_SERVICE_MASK; //Not exposed at API level
330         p_msg->p_cback = p_cback;
331         p_msg->sdp_search = sdp_search;
332 
333 #if BLE_INCLUDED == TRUE && BTA_GATT_INCLUDED == TRUE
334         p_msg->num_uuid = 0;
335         p_msg->p_uuid = NULL;
336 #endif
337         memcpy( &p_msg->uuid, uuid, sizeof(tSDP_UUID) );
338         bta_sys_sendmsg(p_msg);
339     }
340 
341 }
342 
343 /*******************************************************************************
344 **
345 ** Function         BTA_DmBond
346 **
347 ** Description      This function initiates a bonding procedure with a peer
348 **                  device
349 **
350 **
351 ** Returns          void
352 **
353 *******************************************************************************/
BTA_DmBond(BD_ADDR bd_addr)354 void BTA_DmBond(BD_ADDR bd_addr)
355 {
356     tBTA_DM_API_BOND    *p_msg;
357 
358     p_msg = (tBTA_DM_API_BOND *) GKI_getbuf(sizeof(tBTA_DM_API_BOND));
359     if (p_msg != NULL)
360     {
361         p_msg->hdr.event = BTA_DM_API_BOND_EVT;
362         bdcpy(p_msg->bd_addr, bd_addr);
363         p_msg->transport = BTA_TRANSPORT_UNKNOWN;
364         bta_sys_sendmsg(p_msg);
365     }
366 }
367 
368 /*******************************************************************************
369 **
370 ** Function         BTA_DmBondByTransports
371 **
372 ** Description      This function initiates a bonding procedure with a peer
373 **                  device
374 **
375 **
376 ** Returns          void
377 **
378 *******************************************************************************/
BTA_DmBondByTransport(BD_ADDR bd_addr,tBTA_TRANSPORT transport)379 void BTA_DmBondByTransport(BD_ADDR bd_addr, tBTA_TRANSPORT transport)
380 {
381     tBTA_DM_API_BOND    *p_msg;
382 
383     if ((p_msg = (tBTA_DM_API_BOND *) GKI_getbuf(sizeof(tBTA_DM_API_BOND))) != NULL)
384     {
385         p_msg->hdr.event = BTA_DM_API_BOND_EVT;
386         bdcpy(p_msg->bd_addr, bd_addr);
387         p_msg->transport = transport;
388         bta_sys_sendmsg(p_msg);
389     }
390 
391 
392 }
393 
394 /*******************************************************************************
395 **
396 ** Function         BTA_DmBondCancel
397 **
398 ** Description      This function cancels the bonding procedure with a peer
399 **                  device
400 **
401 **
402 ** Returns          void
403 **
404 *******************************************************************************/
BTA_DmBondCancel(BD_ADDR bd_addr)405 void BTA_DmBondCancel(BD_ADDR bd_addr)
406 {
407     tBTA_DM_API_BOND_CANCEL    *p_msg;
408 
409     if ((p_msg = (tBTA_DM_API_BOND_CANCEL *) GKI_getbuf(sizeof(tBTA_DM_API_BOND_CANCEL))) != NULL)
410     {
411         p_msg->hdr.event = BTA_DM_API_BOND_CANCEL_EVT;
412         bdcpy(p_msg->bd_addr, bd_addr);
413         bta_sys_sendmsg(p_msg);
414     }
415 
416 
417 }
418 
419 /*******************************************************************************
420 **
421 ** Function         BTA_DmPinReply
422 **
423 ** Description      This function provides a pincode for a remote device when
424 **                  one is requested by DM through BTA_DM_PIN_REQ_EVT
425 **
426 **
427 ** Returns          void
428 **
429 *******************************************************************************/
BTA_DmPinReply(BD_ADDR bd_addr,BOOLEAN accept,UINT8 pin_len,UINT8 * p_pin)430 void BTA_DmPinReply(BD_ADDR bd_addr, BOOLEAN accept, UINT8 pin_len, UINT8 *p_pin)
431 
432 {
433     tBTA_DM_API_PIN_REPLY    *p_msg;
434 
435     if ((p_msg = (tBTA_DM_API_PIN_REPLY *) GKI_getbuf(sizeof(tBTA_DM_API_PIN_REPLY))) != NULL)
436     {
437         p_msg->hdr.event = BTA_DM_API_PIN_REPLY_EVT;
438         bdcpy(p_msg->bd_addr, bd_addr);
439         p_msg->accept = accept;
440         if(accept)
441         {
442             p_msg->pin_len = pin_len;
443             memcpy(p_msg->p_pin, p_pin, pin_len);
444         }
445         bta_sys_sendmsg(p_msg);
446     }
447 
448 }
449 
450 #if (BTM_OOB_INCLUDED == TRUE)
451 /*******************************************************************************
452 **
453 ** Function         BTA_DmLocalOob
454 **
455 ** Description      This function retrieves the OOB data from local controller.
456 **                  The result is reported by:
457 **                  - bta_dm_co_loc_oob_ext() if device supports secure
458 **                    connections (SC)
459 **                  - bta_dm_co_loc_oob() if device doesn't support SC
460 **
461 ** Returns          void
462 **
463 *******************************************************************************/
BTA_DmLocalOob(void)464 void BTA_DmLocalOob(void)
465 {
466     tBTA_DM_API_LOC_OOB    *p_msg;
467 
468     if ((p_msg = (tBTA_DM_API_LOC_OOB *) GKI_getbuf(sizeof(tBTA_DM_API_LOC_OOB))) != NULL)
469     {
470         p_msg->hdr.event = BTA_DM_API_LOC_OOB_EVT;
471         bta_sys_sendmsg(p_msg);
472     }
473 }
474 #endif /* BTM_OOB_INCLUDED */
475 /*******************************************************************************
476 **
477 ** Function         BTA_DmConfirm
478 **
479 ** Description      This function accepts or rejects the numerical value of the
480 **                  Simple Pairing process on BTA_DM_SP_CFM_REQ_EVT
481 **
482 ** Returns          void
483 **
484 *******************************************************************************/
BTA_DmConfirm(BD_ADDR bd_addr,BOOLEAN accept)485 void BTA_DmConfirm(BD_ADDR bd_addr, BOOLEAN accept)
486 {
487     tBTA_DM_API_CONFIRM    *p_msg;
488 
489     if ((p_msg = (tBTA_DM_API_CONFIRM *) GKI_getbuf(sizeof(tBTA_DM_API_CONFIRM))) != NULL)
490     {
491         p_msg->hdr.event = BTA_DM_API_CONFIRM_EVT;
492         bdcpy(p_msg->bd_addr, bd_addr);
493         p_msg->accept = accept;
494         bta_sys_sendmsg(p_msg);
495     }
496 }
497 
498 /*******************************************************************************
499 **
500 ** Function         BTA_DmAddDevice
501 **
502 ** Description      This function adds a device to the security database list of
503 **                  peer device
504 **
505 **
506 ** Returns          void
507 **
508 *******************************************************************************/
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,UINT8 pin_length)509 void BTA_DmAddDevice(BD_ADDR bd_addr, DEV_CLASS dev_class, LINK_KEY link_key,
510                      tBTA_SERVICE_MASK trusted_mask, BOOLEAN is_trusted,
511                      UINT8 key_type, tBTA_IO_CAP io_cap, UINT8 pin_length)
512 {
513 
514     tBTA_DM_API_ADD_DEVICE *p_msg;
515 
516     if ((p_msg = (tBTA_DM_API_ADD_DEVICE *) GKI_getbuf(sizeof(tBTA_DM_API_ADD_DEVICE))) != NULL)
517     {
518         memset (p_msg, 0, sizeof(tBTA_DM_API_ADD_DEVICE));
519 
520         p_msg->hdr.event = BTA_DM_API_ADD_DEVICE_EVT;
521         bdcpy(p_msg->bd_addr, bd_addr);
522         p_msg->tm = trusted_mask;
523         p_msg->is_trusted = is_trusted;
524         p_msg->io_cap = io_cap;
525 
526         if (link_key)
527         {
528             p_msg->link_key_known = TRUE;
529             p_msg->key_type = key_type;
530             memcpy(p_msg->link_key, link_key, LINK_KEY_LEN);
531         }
532 
533         /* Load device class if specified */
534         if (dev_class)
535         {
536             p_msg->dc_known = TRUE;
537             memcpy (p_msg->dc, dev_class, DEV_CLASS_LEN);
538         }
539 
540         memset (p_msg->bd_name, 0, BD_NAME_LEN + 1);
541         memset (p_msg->features, 0, sizeof (p_msg->features));
542         p_msg->pin_length = pin_length;
543 
544         bta_sys_sendmsg(p_msg);
545     }
546 }
547 
548 
549 /*******************************************************************************
550 **
551 ** Function         BTA_DmRemoveDevice
552 **
553 ** Description      This function removes a device fromthe security database list of
554 **                  peer device. It manages unpairing even while connected.
555 **
556 **
557 ** Returns          void
558 **
559 *******************************************************************************/
BTA_DmRemoveDevice(BD_ADDR bd_addr)560 tBTA_STATUS BTA_DmRemoveDevice(BD_ADDR bd_addr)
561 {
562     tBTA_DM_API_REMOVE_DEVICE *p_msg;
563 
564     if ((p_msg = (tBTA_DM_API_REMOVE_DEVICE *) GKI_getbuf(sizeof(tBTA_DM_API_REMOVE_DEVICE))) != NULL)
565     {
566         memset (p_msg, 0, sizeof(tBTA_DM_API_REMOVE_DEVICE));
567 
568         p_msg->hdr.event = BTA_DM_API_REMOVE_DEVICE_EVT;
569         bdcpy(p_msg->bd_addr, bd_addr);
570         bta_sys_sendmsg(p_msg);
571     }
572     else
573     {
574         return BTA_FAILURE;
575     }
576 
577     return BTA_SUCCESS;
578 }
579 
580 /*******************************************************************************
581 **
582 ** Function         BTA_GetEirService
583 **
584 ** Description      This function is called to get BTA service mask from EIR.
585 **
586 ** Parameters       p_eir - pointer of EIR significant part
587 **                  p_services - return the BTA service mask
588 **
589 ** Returns          None
590 **
591 *******************************************************************************/
592 extern const UINT16 bta_service_id_to_uuid_lkup_tbl [];
BTA_GetEirService(UINT8 * p_eir,tBTA_SERVICE_MASK * p_services)593 void BTA_GetEirService( UINT8 *p_eir, tBTA_SERVICE_MASK *p_services )
594 {
595     UINT8 xx, yy;
596     UINT8 num_uuid, max_num_uuid = 32;
597     UINT8 uuid_list[32*LEN_UUID_16];
598     UINT16 *p_uuid16 = (UINT16 *)uuid_list;
599     tBTA_SERVICE_MASK mask;
600 
601     BTM_GetEirUuidList( p_eir, LEN_UUID_16, &num_uuid, uuid_list, max_num_uuid);
602     for( xx = 0; xx < num_uuid; xx++ )
603     {
604         mask = 1;
605         for( yy = 0; yy < BTA_MAX_SERVICE_ID; yy++ )
606         {
607             if( *(p_uuid16 + xx) == bta_service_id_to_uuid_lkup_tbl[yy] )
608             {
609                 *p_services |= mask;
610                 break;
611             }
612             mask <<= 1;
613         }
614 
615         /* for HSP v1.2 only device */
616         if (*(p_uuid16 + xx) == UUID_SERVCLASS_HEADSET_HS)
617             *p_services |= BTA_HSP_SERVICE_MASK;
618 
619        if (*(p_uuid16 + xx) == UUID_SERVCLASS_HDP_SOURCE)
620             *p_services |= BTA_HL_SERVICE_MASK;
621 
622         if (*(p_uuid16 + xx) == UUID_SERVCLASS_HDP_SINK)
623             *p_services |= BTA_HL_SERVICE_MASK;
624     }
625 }
626 
627 /*******************************************************************************
628 **
629 ** Function         BTA_DmGetConnectionState
630 **
631 ** Description      Returns whether the remote device is currently connected.
632 **
633 ** Returns          0 if the device is NOT connected.
634 **
635 *******************************************************************************/
BTA_DmGetConnectionState(BD_ADDR bd_addr)636 UINT16 BTA_DmGetConnectionState( BD_ADDR bd_addr )
637 {
638     tBTA_DM_PEER_DEVICE * p_dev = bta_dm_find_peer_device(bd_addr);
639     return (p_dev && p_dev->conn_state == BTA_DM_CONNECTED);
640 }
641 
642 
643 /*******************************************************************************
644 **                   Device Identification (DI) Server Functions
645 *******************************************************************************/
646 /*******************************************************************************
647 **
648 ** Function         BTA_DmSetLocalDiRecord
649 **
650 ** Description      This function adds a DI record to the local SDP database.
651 **
652 ** Returns          BTA_SUCCESS if record set sucessfully, otherwise error code.
653 **
654 *******************************************************************************/
BTA_DmSetLocalDiRecord(tBTA_DI_RECORD * p_device_info,UINT32 * p_handle)655 tBTA_STATUS BTA_DmSetLocalDiRecord( tBTA_DI_RECORD *p_device_info,
656                               UINT32 *p_handle )
657 {
658     tBTA_STATUS  status = BTA_FAILURE;
659 
660     if(bta_dm_di_cb.di_num < BTA_DI_NUM_MAX)
661     {
662         if(SDP_SetLocalDiRecord((tSDP_DI_RECORD *)p_device_info, p_handle) == SDP_SUCCESS)
663         {
664             if(!p_device_info->primary_record)
665             {
666                 bta_dm_di_cb.di_handle[bta_dm_di_cb.di_num] = *p_handle;
667                 bta_dm_di_cb.di_num ++;
668             }
669 
670             bta_sys_add_uuid(UUID_SERVCLASS_PNP_INFORMATION);
671             status =  BTA_SUCCESS;
672         }
673     }
674 
675     return status;
676 }
677 
678 /*******************************************************************************
679 **
680 ** Function         bta_dmexecutecallback
681 **
682 ** Description      This function will request BTA to execute a call back in the context of BTU task
683 **                  This API was named in lower case because it is only intended
684 **                  for the internal customers(like BTIF).
685 **
686 ** Returns          void
687 **
688 *******************************************************************************/
bta_dmexecutecallback(tBTA_DM_EXEC_CBACK * p_callback,void * p_param)689 void bta_dmexecutecallback (tBTA_DM_EXEC_CBACK* p_callback, void * p_param)
690 {
691     tBTA_DM_API_EXECUTE_CBACK *p_msg;
692 
693     if ((p_msg = (tBTA_DM_API_EXECUTE_CBACK *) GKI_getbuf(sizeof(tBTA_DM_MSG))) != NULL)
694     {
695         p_msg->hdr.event = BTA_DM_API_EXECUTE_CBACK_EVT;
696         p_msg->p_param= p_param;
697         p_msg->p_exec_cback= p_callback;
698         bta_sys_sendmsg(p_msg);
699     }
700 }
701 
702 /*******************************************************************************
703 **
704 ** Function         BTA_DmAddBleKey
705 **
706 ** Description      Add/modify LE device information.  This function will be
707 **                  normally called during host startup to restore all required
708 **                  information stored in the NVRAM.
709 **
710 ** Parameters:      bd_addr          - BD address of the peer
711 **                  p_le_key         - LE key values.
712 **                  key_type         - LE SMP key type.
713 **
714 ** Returns          BTA_SUCCESS if successful
715 **                  BTA_FAIL if operation failed.
716 **
717 *******************************************************************************/
BTA_DmAddBleKey(BD_ADDR bd_addr,tBTA_LE_KEY_VALUE * p_le_key,tBTA_LE_KEY_TYPE key_type)718 void BTA_DmAddBleKey (BD_ADDR bd_addr, tBTA_LE_KEY_VALUE *p_le_key, tBTA_LE_KEY_TYPE key_type)
719 {
720 #if BLE_INCLUDED == TRUE
721 
722     tBTA_DM_API_ADD_BLEKEY *p_msg;
723 
724     if ((p_msg = (tBTA_DM_API_ADD_BLEKEY *) GKI_getbuf(sizeof(tBTA_DM_API_ADD_BLEKEY))) != NULL)
725     {
726         memset (p_msg, 0, sizeof(tBTA_DM_API_ADD_BLEKEY));
727 
728         p_msg->hdr.event = BTA_DM_API_ADD_BLEKEY_EVT;
729         p_msg->key_type = key_type;
730         bdcpy(p_msg->bd_addr, bd_addr);
731         memcpy(&p_msg->blekey, p_le_key, sizeof(tBTA_LE_KEY_VALUE));
732 
733         bta_sys_sendmsg(p_msg);
734     }
735 
736 #endif
737 }
738 
739 /*******************************************************************************
740 **
741 ** Function         BTA_DmAddBleDevice
742 **
743 ** Description      Add a BLE device.  This function will be normally called
744 **                  during host startup to restore all required information
745 **                  for a LE device stored in the NVRAM.
746 **
747 ** Parameters:      bd_addr          - BD address of the peer
748 **                  dev_type         - Remote device's device type.
749 **                  addr_type        - LE device address type.
750 **
751 ** Returns          void
752 **
753 *******************************************************************************/
BTA_DmAddBleDevice(BD_ADDR bd_addr,tBLE_ADDR_TYPE addr_type,tBT_DEVICE_TYPE dev_type)754 void BTA_DmAddBleDevice(BD_ADDR bd_addr, tBLE_ADDR_TYPE addr_type, tBT_DEVICE_TYPE dev_type)
755 {
756 #if BLE_INCLUDED == TRUE
757     tBTA_DM_API_ADD_BLE_DEVICE *p_msg;
758 
759     if ((p_msg = (tBTA_DM_API_ADD_BLE_DEVICE *) GKI_getbuf(sizeof(tBTA_DM_API_ADD_BLE_DEVICE))) != NULL)
760     {
761         memset (p_msg, 0, sizeof(tBTA_DM_API_ADD_BLE_DEVICE));
762 
763         p_msg->hdr.event = BTA_DM_API_ADD_BLEDEVICE_EVT;
764         bdcpy(p_msg->bd_addr, bd_addr);
765         p_msg->addr_type = addr_type;
766         p_msg->dev_type = dev_type;
767 
768         bta_sys_sendmsg(p_msg);
769     }
770 #endif
771 }
772 /*******************************************************************************
773 **
774 ** Function         BTA_DmBlePasskeyReply
775 **
776 ** Description      Send BLE SMP passkey reply.
777 **
778 ** Parameters:      bd_addr          - BD address of the peer
779 **                  accept           - passkey entry sucessful or declined.
780 **                  passkey          - passkey value, must be a 6 digit number,
781 **                                     can be lead by 0.
782 **
783 ** Returns          void
784 **
785 *******************************************************************************/
BTA_DmBlePasskeyReply(BD_ADDR bd_addr,BOOLEAN accept,UINT32 passkey)786 void BTA_DmBlePasskeyReply(BD_ADDR bd_addr, BOOLEAN accept, UINT32 passkey)
787 {
788 #if BLE_INCLUDED == TRUE
789     tBTA_DM_API_PASSKEY_REPLY    *p_msg;
790 
791     if ((p_msg = (tBTA_DM_API_PASSKEY_REPLY *) GKI_getbuf(sizeof(tBTA_DM_API_PASSKEY_REPLY))) != NULL)
792     {
793         memset(p_msg, 0, sizeof(tBTA_DM_API_PASSKEY_REPLY));
794 
795         p_msg->hdr.event = BTA_DM_API_BLE_PASSKEY_REPLY_EVT;
796         bdcpy(p_msg->bd_addr, bd_addr);
797         p_msg->accept = accept;
798 
799         if(accept)
800         {
801             p_msg->passkey = passkey;
802         }
803         bta_sys_sendmsg(p_msg);
804     }
805 #endif
806 }
807 /*******************************************************************************
808 **
809 ** Function         BTA_DmBleConfirmReply
810 **
811 ** Description      Send BLE SMP SC user confirmation reply.
812 **
813 ** Parameters:      bd_addr          - BD address of the peer
814 **                  accept           - numbers to compare are the same or different.
815 **
816 ** Returns          void
817 **
818 *******************************************************************************/
BTA_DmBleConfirmReply(BD_ADDR bd_addr,BOOLEAN accept)819 void BTA_DmBleConfirmReply(BD_ADDR bd_addr, BOOLEAN accept)
820 {
821 #if BLE_INCLUDED == TRUE
822     tBTA_DM_API_CONFIRM *p_msg = (tBTA_DM_API_CONFIRM *)GKI_getbuf(sizeof(tBTA_DM_API_CONFIRM));
823     if (p_msg != NULL)
824     {
825         memset(p_msg, 0, sizeof(tBTA_DM_API_CONFIRM));
826         p_msg->hdr.event = BTA_DM_API_BLE_CONFIRM_REPLY_EVT;
827         bdcpy(p_msg->bd_addr, bd_addr);
828         p_msg->accept = accept;
829         bta_sys_sendmsg(p_msg);
830     }
831 #endif
832 }
833 
834 /*******************************************************************************
835 **
836 ** Function         BTA_DmBleSecurityGrant
837 **
838 ** Description      Grant security request access.
839 **
840 ** Parameters:      bd_addr          - BD address of the peer
841 **                  res              - security grant status.
842 **
843 ** Returns          void
844 **
845 *******************************************************************************/
BTA_DmBleSecurityGrant(BD_ADDR bd_addr,tBTA_DM_BLE_SEC_GRANT res)846 void BTA_DmBleSecurityGrant(BD_ADDR bd_addr, tBTA_DM_BLE_SEC_GRANT res)
847 {
848 #if BLE_INCLUDED == TRUE
849     tBTA_DM_API_BLE_SEC_GRANT    *p_msg;
850 
851     if ((p_msg = (tBTA_DM_API_BLE_SEC_GRANT *) GKI_getbuf(sizeof(tBTA_DM_API_BLE_SEC_GRANT))) != NULL)
852     {
853         memset(p_msg, 0, sizeof(tBTA_DM_API_BLE_SEC_GRANT));
854 
855         p_msg->hdr.event = BTA_DM_API_BLE_SEC_GRANT_EVT;
856         bdcpy(p_msg->bd_addr, bd_addr);
857         p_msg->res = res;
858 
859         bta_sys_sendmsg(p_msg);
860     }
861 #endif
862 }
863 /*******************************************************************************
864 **
865 ** Function         BTA_DmSetBlePrefConnParams
866 **
867 ** Description      This function is called to set the preferred connection
868 **                  parameters when default connection parameter is not desired.
869 **
870 ** Parameters:      bd_addr          - BD address of the peripheral
871 **                  scan_interval    - scan interval
872 **                  scan_window      - scan window
873 **                  min_conn_int     - minimum preferred connection interval
874 **                  max_conn_int     - maximum preferred connection interval
875 **                  slave_latency    - preferred slave latency
876 **                  supervision_tout - preferred supervision timeout
877 **
878 **
879 ** Returns          void
880 **
881 *******************************************************************************/
BTA_DmSetBlePrefConnParams(BD_ADDR bd_addr,UINT16 min_conn_int,UINT16 max_conn_int,UINT16 slave_latency,UINT16 supervision_tout)882 void BTA_DmSetBlePrefConnParams(BD_ADDR bd_addr,
883                                UINT16 min_conn_int, UINT16 max_conn_int,
884                                UINT16 slave_latency, UINT16 supervision_tout )
885 {
886 #if BLE_INCLUDED == TRUE
887     tBTA_DM_API_BLE_CONN_PARAMS    *p_msg;
888 
889     if ((p_msg = (tBTA_DM_API_BLE_CONN_PARAMS *) GKI_getbuf(sizeof(tBTA_DM_API_BLE_CONN_PARAMS))) != NULL)
890     {
891         memset(p_msg, 0, sizeof(tBTA_DM_API_BLE_CONN_PARAMS));
892 
893         p_msg->hdr.event = BTA_DM_API_BLE_CONN_PARAM_EVT;
894 
895         memcpy(p_msg->peer_bda, bd_addr, BD_ADDR_LEN);
896 
897         p_msg->conn_int_max     = max_conn_int;
898         p_msg->conn_int_min     = min_conn_int;
899         p_msg->slave_latency    = slave_latency;
900         p_msg->supervision_tout = supervision_tout;
901 
902         bta_sys_sendmsg(p_msg);
903     }
904 #endif
905 }
906 
907 /*******************************************************************************
908 **
909 ** Function         BTA_DmSetBleConnScanParams
910 **
911 ** Description      This function is called to set scan parameters used in
912 **                  BLE connection request
913 **
914 ** Parameters:      scan_interval    - scan interval
915 **                  scan_window      - scan window
916 **
917 ** Returns          void
918 **
919 *******************************************************************************/
BTA_DmSetBleConnScanParams(UINT32 scan_interval,UINT32 scan_window)920 void BTA_DmSetBleConnScanParams(UINT32 scan_interval, UINT32 scan_window)
921 {
922     tBTA_DM_API_BLE_SCAN_PARAMS  *p_msg;
923     if ((p_msg = (tBTA_DM_API_BLE_SCAN_PARAMS *)GKI_getbuf(sizeof(tBTA_DM_API_BLE_SCAN_PARAMS))) != NULL)
924     {
925         memset(p_msg, 0, sizeof(tBTA_DM_API_BLE_SCAN_PARAMS));
926         p_msg->hdr.event = BTA_DM_API_BLE_CONN_SCAN_PARAM_EVT;
927         p_msg->scan_int         = scan_interval;
928         p_msg->scan_window      = scan_window;
929         bta_sys_sendmsg(p_msg);
930     }
931 }
932 
933 /*******************************************************************************
934 **
935 ** Function         BTA_DmSetBleScanParams
936 **
937 ** Description      This function is called to set scan parameters
938 **
939 ** Parameters:      client_if - Client IF
940 **                  scan_interval - scan interval
941 **                  scan_window - scan window
942 **                  scan_mode - scan mode
943 **                  scan_param_setup_status_cback - Set scan param status callback
944 **
945 ** Returns          void
946 **
947 *******************************************************************************/
BTA_DmSetBleScanParams(tGATT_IF client_if,UINT32 scan_interval,UINT32 scan_window,tBLE_SCAN_MODE scan_mode,tBLE_SCAN_PARAM_SETUP_CBACK scan_param_setup_cback)948 void BTA_DmSetBleScanParams(tGATT_IF client_if, UINT32 scan_interval,
949                             UINT32 scan_window, tBLE_SCAN_MODE scan_mode,
950                             tBLE_SCAN_PARAM_SETUP_CBACK scan_param_setup_cback)
951 {
952     tBTA_DM_API_BLE_SCAN_PARAMS *p_msg;
953 
954     if ((p_msg = (tBTA_DM_API_BLE_SCAN_PARAMS *)GKI_getbuf(sizeof(tBTA_DM_API_BLE_SCAN_PARAMS))) != NULL)
955     {
956         memset(p_msg, 0, sizeof(tBTA_DM_API_BLE_SCAN_PARAMS));
957         p_msg->hdr.event = BTA_DM_API_BLE_SCAN_PARAM_EVT;
958         p_msg->client_if = client_if;
959         p_msg->scan_int = scan_interval;
960         p_msg->scan_window = scan_window;
961         p_msg->scan_mode = scan_mode;
962         p_msg->scan_param_setup_cback = scan_param_setup_cback;
963 
964         bta_sys_sendmsg(p_msg);
965     }
966 }
967 
968 /*******************************************************************************
969 **
970 ** Function         BTA_DmSetBleAdvParams
971 **
972 ** Description      This function sets the advertising parameters BLE functionality.
973 **                  It is to be called when device act in peripheral or broadcaster
974 **                  role.
975 **
976 **
977 ** Returns          void
978 **
979 *******************************************************************************/
BTA_DmSetBleAdvParams(UINT16 adv_int_min,UINT16 adv_int_max,tBLE_BD_ADDR * p_dir_bda)980 void BTA_DmSetBleAdvParams (UINT16 adv_int_min, UINT16 adv_int_max,
981                            tBLE_BD_ADDR *p_dir_bda)
982 {
983 #if BLE_INCLUDED == TRUE
984     tBTA_DM_API_BLE_ADV_PARAMS    *p_msg;
985 
986     APPL_TRACE_API ("BTA_DmSetBleAdvParam: %d, %d", adv_int_min, adv_int_max);
987 
988     if ((p_msg = (tBTA_DM_API_BLE_ADV_PARAMS *) GKI_getbuf(sizeof(tBTA_DM_API_BLE_ADV_PARAMS))) != NULL)
989     {
990         memset(p_msg, 0, sizeof(tBTA_DM_API_BLE_ADV_PARAMS));
991 
992         p_msg->hdr.event = BTA_DM_API_BLE_ADV_PARAM_EVT;
993 
994         p_msg->adv_int_min      = adv_int_min;
995         p_msg->adv_int_max      = adv_int_max;
996 
997         if (p_dir_bda != NULL)
998         {
999             p_msg->p_dir_bda = (tBLE_BD_ADDR *)(p_msg + 1);
1000             memcpy(p_msg->p_dir_bda, p_dir_bda, sizeof(tBLE_BD_ADDR));
1001         }
1002 
1003         bta_sys_sendmsg(p_msg);
1004     }
1005 #endif
1006 }
1007 /*******************************************************************************
1008 **                      BLE ADV data management API
1009 ********************************************************************************/
1010 
1011 #if BLE_INCLUDED == TRUE
1012 /*******************************************************************************
1013 **
1014 ** Function         BTA_DmBleSetAdvConfig
1015 **
1016 ** Description      This function is called to override the BTA default ADV parameters.
1017 **
1018 ** Parameters       data_mask: adv data mask.
1019 **                  p_adv_cfg: Pointer to User defined ADV data structure. This
1020 **                             memory space can not be freed until p_adv_data_cback
1021 **                             is received.
1022 **                  p_adv_data_cback: set adv data complete callback.
1023 **
1024 ** Returns          None
1025 **
1026 *******************************************************************************/
BTA_DmBleSetAdvConfig(tBTA_BLE_AD_MASK data_mask,tBTA_BLE_ADV_DATA * p_adv_cfg,tBTA_SET_ADV_DATA_CMPL_CBACK * p_adv_data_cback)1027 void BTA_DmBleSetAdvConfig (tBTA_BLE_AD_MASK data_mask, tBTA_BLE_ADV_DATA *p_adv_cfg,
1028                             tBTA_SET_ADV_DATA_CMPL_CBACK *p_adv_data_cback)
1029 {
1030     tBTA_DM_API_SET_ADV_CONFIG  *p_msg;
1031 
1032     if ((p_msg = (tBTA_DM_API_SET_ADV_CONFIG *)
1033         GKI_getbuf(sizeof(tBTA_DM_API_SET_ADV_CONFIG))) != NULL)
1034     {
1035         p_msg->hdr.event = BTA_DM_API_BLE_SET_ADV_CONFIG_EVT;
1036         p_msg->data_mask = data_mask;
1037         p_msg->p_adv_data_cback = p_adv_data_cback;
1038         p_msg->p_adv_cfg = p_adv_cfg;
1039 
1040         bta_sys_sendmsg(p_msg);
1041     }
1042 }
1043 
1044 /*******************************************************************************
1045 **
1046 ** Function         BTA_DmBleSetScanRsp
1047 **
1048 ** Description      This function is called to override the BTA scan response.
1049 **
1050 ** Parameters       Pointer to User defined ADV data structure
1051 **
1052 ** Returns          None
1053 **
1054 *******************************************************************************/
BTA_DmBleSetScanRsp(tBTA_BLE_AD_MASK data_mask,tBTA_BLE_ADV_DATA * p_adv_cfg,tBTA_SET_ADV_DATA_CMPL_CBACK * p_adv_data_cback)1055 extern void BTA_DmBleSetScanRsp (tBTA_BLE_AD_MASK data_mask, tBTA_BLE_ADV_DATA *p_adv_cfg,
1056                                  tBTA_SET_ADV_DATA_CMPL_CBACK *p_adv_data_cback)
1057 {
1058     tBTA_DM_API_SET_ADV_CONFIG  *p_msg;
1059 
1060     if ((p_msg = (tBTA_DM_API_SET_ADV_CONFIG *)
1061         GKI_getbuf(sizeof(tBTA_DM_API_SET_ADV_CONFIG))) != NULL)
1062     {
1063         p_msg->hdr.event = BTA_DM_API_BLE_SET_SCAN_RSP_EVT;
1064         p_msg->data_mask = data_mask;
1065         p_msg->p_adv_data_cback = p_adv_data_cback;
1066         p_msg->p_adv_cfg = p_adv_cfg;
1067 
1068         bta_sys_sendmsg(p_msg);
1069     }
1070 }
1071 
1072 /*******************************************************************************
1073 **
1074 ** Function         BTA_DmBleSetStorageParams
1075 **
1076 ** Description      This function is called to override the BTA scan response.
1077 **
1078 ** Parameters       batch_scan_full_max -Max storage space (in %) allocated to full scanning
1079 **                  batch_scan_trunc_max -Max storage space (in %) allocated to truncated scanning
1080 **                  batch_scan_notify_threshold -Setup notification level based on total space
1081 **                  p_setup_cback - Setup callback pointer
1082 **                  p_thres_cback - Threshold callback pointer
1083 **                  p_rep_cback - Reports callback pointer
1084 **                  ref_value - Ref value
1085 **
1086 ** Returns          None
1087 **
1088 *******************************************************************************/
BTA_DmBleSetStorageParams(UINT8 batch_scan_full_max,UINT8 batch_scan_trunc_max,UINT8 batch_scan_notify_threshold,tBTA_BLE_SCAN_SETUP_CBACK * p_setup_cback,tBTA_BLE_SCAN_THRESHOLD_CBACK * p_thres_cback,tBTA_BLE_SCAN_REP_CBACK * p_rep_cback,tBTA_DM_BLE_REF_VALUE ref_value)1089 extern void BTA_DmBleSetStorageParams(UINT8 batch_scan_full_max,
1090                                          UINT8 batch_scan_trunc_max,
1091                                          UINT8 batch_scan_notify_threshold,
1092                                          tBTA_BLE_SCAN_SETUP_CBACK *p_setup_cback,
1093                                          tBTA_BLE_SCAN_THRESHOLD_CBACK *p_thres_cback,
1094                                          tBTA_BLE_SCAN_REP_CBACK* p_rep_cback,
1095                                          tBTA_DM_BLE_REF_VALUE ref_value)
1096 {
1097     tBTA_DM_API_SET_STORAGE_CONFIG  *p_msg;
1098     bta_dm_cb.p_setup_cback = p_setup_cback;
1099     if ((p_msg = (tBTA_DM_API_SET_STORAGE_CONFIG *)
1100           GKI_getbuf(sizeof(tBTA_DM_API_SET_STORAGE_CONFIG))) != NULL)
1101     {
1102         p_msg->hdr.event = BTA_DM_API_BLE_SETUP_STORAGE_EVT;
1103         p_msg->p_setup_cback=bta_ble_scan_setup_cb;
1104         p_msg->p_thres_cback=p_thres_cback;
1105         p_msg->p_read_rep_cback=p_rep_cback;
1106         p_msg->ref_value = ref_value;
1107         p_msg->batch_scan_full_max = batch_scan_full_max;
1108         p_msg->batch_scan_trunc_max = batch_scan_trunc_max;
1109         p_msg->batch_scan_notify_threshold = batch_scan_notify_threshold;
1110         bta_sys_sendmsg(p_msg);
1111     }
1112 }
1113 
1114 /*******************************************************************************
1115 **
1116 ** Function         BTA_DmBleEnableBatchScan
1117 **
1118 ** Description      This function is called to enable the batch scan
1119 **
1120 ** Parameters       scan_mode -Batch scan mode
1121 **                  scan_interval - Scan interval
1122 **                  scan_window - Scan window
1123 **                  discard_rule -Discard rules
1124 **                  addr_type - Address type
1125 **                  ref_value - Reference value
1126 **
1127 ** Returns          None
1128 **
1129 *******************************************************************************/
BTA_DmBleEnableBatchScan(tBTA_BLE_BATCH_SCAN_MODE scan_mode,UINT32 scan_interval,UINT32 scan_window,tBTA_BLE_DISCARD_RULE discard_rule,tBLE_ADDR_TYPE addr_type,tBTA_DM_BLE_REF_VALUE ref_value)1130 extern void BTA_DmBleEnableBatchScan(tBTA_BLE_BATCH_SCAN_MODE scan_mode,
1131                                          UINT32 scan_interval, UINT32 scan_window,
1132                                          tBTA_BLE_DISCARD_RULE discard_rule,
1133                                          tBLE_ADDR_TYPE        addr_type,
1134                                          tBTA_DM_BLE_REF_VALUE ref_value)
1135 {
1136     tBTA_DM_API_ENABLE_SCAN  *p_msg;
1137 
1138     if ((p_msg = (tBTA_DM_API_ENABLE_SCAN *) GKI_getbuf(sizeof(tBTA_DM_API_ENABLE_SCAN))) != NULL)
1139     {
1140         p_msg->hdr.event = BTA_DM_API_BLE_ENABLE_BATCH_SCAN_EVT;
1141         p_msg->scan_mode = scan_mode;
1142         p_msg->scan_int = scan_interval;
1143         p_msg->scan_window = scan_window;
1144         p_msg->discard_rule = discard_rule;
1145         p_msg->addr_type = addr_type;
1146         p_msg->ref_value = ref_value;
1147         bta_sys_sendmsg(p_msg);
1148     }
1149 }
1150 
1151 /*******************************************************************************
1152 **
1153 ** Function         BTA_DmBleDisableBatchScan
1154 **
1155 ** Description      This function is called to disable the batch scan
1156 **
1157 ** Parameters       ref_value - Reference value
1158 **
1159 ** Returns          None
1160 **
1161 *******************************************************************************/
BTA_DmBleDisableBatchScan(tBTA_DM_BLE_REF_VALUE ref_value)1162 extern void BTA_DmBleDisableBatchScan(tBTA_DM_BLE_REF_VALUE ref_value)
1163 {
1164     tBTA_DM_API_DISABLE_SCAN  *p_msg;
1165 
1166     if ((p_msg = (tBTA_DM_API_DISABLE_SCAN *)
1167          GKI_getbuf(sizeof(tBTA_DM_API_DISABLE_SCAN))) != NULL)
1168     {
1169         p_msg->hdr.event = BTA_DM_API_BLE_DISABLE_BATCH_SCAN_EVT;
1170         p_msg->ref_value = ref_value;
1171         bta_sys_sendmsg(p_msg);
1172     }
1173 }
1174 
1175 /*******************************************************************************
1176 **
1177 ** Function         BTA_DmBleReadScanReports
1178 **
1179 ** Description      This function is called to read scan reports
1180 **
1181 ** Parameters       scan_type -Batch scan mode
1182 **                  ref_value - Reference value
1183 **
1184 ** Returns          None
1185 **
1186 *******************************************************************************/
BTA_DmBleReadScanReports(tBTA_BLE_BATCH_SCAN_MODE scan_type,tBTA_DM_BLE_REF_VALUE ref_value)1187 extern void BTA_DmBleReadScanReports(tBTA_BLE_BATCH_SCAN_MODE scan_type,
1188                                              tBTA_DM_BLE_REF_VALUE ref_value)
1189 {
1190     tBTA_DM_API_READ_SCAN_REPORTS  *p_msg;
1191 
1192     if ((p_msg = (tBTA_DM_API_READ_SCAN_REPORTS *)
1193           GKI_getbuf(sizeof(tBTA_DM_API_READ_SCAN_REPORTS))) != NULL)
1194     {
1195         p_msg->hdr.event = BTA_DM_API_BLE_READ_SCAN_REPORTS_EVT;
1196         p_msg->scan_type = scan_type;
1197         p_msg->ref_value = ref_value;
1198         bta_sys_sendmsg(p_msg);
1199     }
1200 }
1201 
1202 /*******************************************************************************
1203 **
1204 ** Function         BTA_DmBleTrackAdvertiser
1205 **
1206 ** Description      This function is called to track advertiser
1207 **
1208 ** Parameters       ref_value - Reference value
1209 **                  p_track_adv_cback - Track ADV callback
1210 **
1211 ** Returns          None
1212 **
1213 *******************************************************************************/
BTA_DmBleTrackAdvertiser(tBTA_DM_BLE_REF_VALUE ref_value,tBTA_BLE_TRACK_ADV_CBACK * p_track_adv_cback)1214 extern void BTA_DmBleTrackAdvertiser(tBTA_DM_BLE_REF_VALUE ref_value,
1215                             tBTA_BLE_TRACK_ADV_CBACK *p_track_adv_cback)
1216 {
1217     tBTA_DM_API_TRACK_ADVERTISER  *p_msg;
1218 
1219     if ((p_msg = (tBTA_DM_API_TRACK_ADVERTISER *)
1220          GKI_getbuf(sizeof(tBTA_DM_API_TRACK_ADVERTISER))) != NULL)
1221     {
1222         p_msg->hdr.event = BTA_DM_API_BLE_TRACK_ADVERTISER_EVT;
1223         p_msg->p_track_adv_cback = p_track_adv_cback;
1224         p_msg->ref_value = ref_value;
1225         bta_sys_sendmsg(p_msg);
1226     }
1227 }
1228 
1229 #endif
1230 
1231 /*******************************************************************************
1232 **                      BLE ADV data management API
1233 ********************************************************************************/
1234 #if BLE_INCLUDED == TRUE
1235 
1236 /*******************************************************************************
1237 **
1238 ** Function         BTA_DmBleBroadcast
1239 **
1240 ** Description      This function starts or stops LE broadcasting.
1241 **
1242 ** Parameters       start: start or stop broadcast.
1243 **
1244 ** Returns          None
1245 **
1246 *******************************************************************************/
BTA_DmBleBroadcast(BOOLEAN start)1247 extern void BTA_DmBleBroadcast (BOOLEAN start)
1248 {
1249     tBTA_DM_API_BLE_OBSERVE   *p_msg;
1250 
1251     APPL_TRACE_API("BTA_DmBleBroadcast: start = %d ", start);
1252 
1253     if ((p_msg = (tBTA_DM_API_BLE_OBSERVE *) GKI_getbuf(sizeof(tBTA_DM_API_BLE_OBSERVE))) != NULL)
1254     {
1255         memset(p_msg, 0, sizeof(tBTA_DM_API_BLE_OBSERVE));
1256 
1257         p_msg->hdr.event = BTA_DM_API_BLE_BROADCAST_EVT;
1258         p_msg->start = start;
1259 
1260         bta_sys_sendmsg(p_msg);
1261     }
1262 }
1263 
1264 #endif
1265 /*******************************************************************************
1266 **
1267 ** Function         BTA_DmBleSetBgConnType
1268 **
1269 ** Description      This function is called to set BLE connectable mode for a
1270 **                  peripheral device.
1271 **
1272 ** Parameters       bg_conn_type: it can be auto connection, or selective connection.
1273 **                  p_select_cback: callback function when selective connection procedure
1274 **                              is being used.
1275 **
1276 ** Returns          void
1277 **
1278 *******************************************************************************/
BTA_DmBleSetBgConnType(tBTA_DM_BLE_CONN_TYPE bg_conn_type,tBTA_DM_BLE_SEL_CBACK * p_select_cback)1279 void BTA_DmBleSetBgConnType(tBTA_DM_BLE_CONN_TYPE bg_conn_type, tBTA_DM_BLE_SEL_CBACK *p_select_cback)
1280 {
1281 #if BLE_INCLUDED == TRUE
1282     tBTA_DM_API_BLE_SET_BG_CONN_TYPE    *p_msg;
1283 
1284     if ((p_msg = (tBTA_DM_API_BLE_SET_BG_CONN_TYPE *) GKI_getbuf(sizeof(tBTA_DM_API_BLE_SET_BG_CONN_TYPE))) != NULL)
1285     {
1286         memset(p_msg, 0, sizeof(tBTA_DM_API_BLE_SET_BG_CONN_TYPE));
1287 
1288         p_msg->hdr.event        = BTA_DM_API_BLE_SET_BG_CONN_TYPE;
1289         p_msg->bg_conn_type     = bg_conn_type;
1290         p_msg->p_select_cback   = p_select_cback;
1291 
1292         bta_sys_sendmsg(p_msg);
1293     }
1294 #endif
1295 }
1296 
1297 /*******************************************************************************
1298 **
1299 ** Function         bta_dm_discover_send_msg
1300 **
1301 ** Description      This function send discover message to BTA task.
1302 **
1303 ** Returns          void
1304 **
1305 *******************************************************************************/
1306 #if BLE_INCLUDED == TRUE && BTA_GATT_INCLUDED == TRUE
bta_dm_discover_send_msg(BD_ADDR bd_addr,tBTA_SERVICE_MASK_EXT * p_services,tBTA_DM_SEARCH_CBACK * p_cback,BOOLEAN sdp_search,tBTA_TRANSPORT transport)1307 static void bta_dm_discover_send_msg(BD_ADDR bd_addr, tBTA_SERVICE_MASK_EXT *p_services,
1308                     tBTA_DM_SEARCH_CBACK *p_cback, BOOLEAN sdp_search,
1309                     tBTA_TRANSPORT transport)
1310 {
1311     tBTA_DM_API_DISCOVER    *p_msg;
1312     UINT16  len = p_services ? (sizeof(tBTA_DM_API_DISCOVER) +
1313                                 sizeof(tBT_UUID) * p_services->num_uuid) :
1314                                 sizeof(tBTA_DM_API_DISCOVER);
1315 
1316     if ((p_msg = (tBTA_DM_API_DISCOVER *) GKI_getbuf(len)) != NULL)
1317     {
1318         memset(p_msg, 0, len);
1319 
1320         p_msg->hdr.event = BTA_DM_API_DISCOVER_EVT;
1321         bdcpy(p_msg->bd_addr, bd_addr);
1322         p_msg->p_cback = p_cback;
1323         p_msg->sdp_search = sdp_search;
1324         p_msg->transport    = transport;
1325 
1326         if (p_services != NULL)
1327         {
1328 #if BLE_INCLUDED == TRUE && BTA_GATT_INCLUDED == TRUE
1329             p_msg->services = p_services->srvc_mask;
1330             p_msg->num_uuid = p_services->num_uuid;
1331             if (p_services->num_uuid != 0)
1332             {
1333                 p_msg->p_uuid = (tBT_UUID *)(p_msg + 1);
1334                 memcpy(p_msg->p_uuid, p_services->p_uuid, sizeof(tBT_UUID) * p_services->num_uuid);
1335             }
1336 #endif
1337         }
1338 
1339         bta_sys_sendmsg(p_msg);
1340     }
1341 }
1342 #endif
1343 /*******************************************************************************
1344 **
1345 ** Function         BTA_DmDiscoverByTransport
1346 **
1347 ** Description      This function does service discovery on particular transport
1348 **                  for services of a
1349 **                  peer device. When services.num_uuid is 0, it indicates all
1350 **                  GATT based services are to be searched; otherwise a list of
1351 **                  UUID of interested services should be provided through
1352 **                  p_services->p_uuid.
1353 **
1354 **
1355 **
1356 ** Returns          void
1357 **
1358 *******************************************************************************/
BTA_DmDiscoverByTransport(BD_ADDR bd_addr,tBTA_SERVICE_MASK_EXT * p_services,tBTA_DM_SEARCH_CBACK * p_cback,BOOLEAN sdp_search,tBTA_TRANSPORT transport)1359 void BTA_DmDiscoverByTransport(BD_ADDR bd_addr, tBTA_SERVICE_MASK_EXT *p_services,
1360                     tBTA_DM_SEARCH_CBACK *p_cback, BOOLEAN sdp_search,
1361                     tBTA_TRANSPORT transport)
1362 {
1363 #if BLE_INCLUDED == TRUE && BTA_GATT_INCLUDED == TRUE
1364     bta_dm_discover_send_msg(bd_addr, p_services, p_cback, sdp_search, transport);
1365 #endif
1366 }
1367 
1368 
1369 /*******************************************************************************
1370 **
1371 ** Function         BTA_DmDiscoverExt
1372 **
1373 ** Description      This function does service discovery for services of a
1374 **                  peer device. When services.num_uuid is 0, it indicates all
1375 **                  GATT based services are to be searched; other wise a list of
1376 **                  UUID of interested services should be provided through
1377 **                  p_services->p_uuid.
1378 **
1379 **
1380 **
1381 ** Returns          void
1382 **
1383 *******************************************************************************/
BTA_DmDiscoverExt(BD_ADDR bd_addr,tBTA_SERVICE_MASK_EXT * p_services,tBTA_DM_SEARCH_CBACK * p_cback,BOOLEAN sdp_search)1384 void BTA_DmDiscoverExt(BD_ADDR bd_addr, tBTA_SERVICE_MASK_EXT *p_services,
1385                     tBTA_DM_SEARCH_CBACK *p_cback, BOOLEAN sdp_search)
1386 {
1387 #if BLE_INCLUDED == TRUE && BTA_GATT_INCLUDED == TRUE
1388     bta_dm_discover_send_msg(bd_addr, p_services, p_cback, sdp_search, BTA_TRANSPORT_UNKNOWN);
1389 #endif
1390 
1391 }
1392 
1393 /*******************************************************************************
1394 **
1395 ** Function         BTA_DmSearchExt
1396 **
1397 ** Description      This function searches for peer Bluetooth devices. It performs
1398 **                  an inquiry and gets the remote name for devices. Service
1399 **                  discovery is done if services is non zero
1400 **
1401 ** Parameters       p_dm_inq: inquiry conditions
1402 **                  p_services: if service is not empty, service discovery will be done.
1403 **                            for all GATT based service condition, put num_uuid, and
1404 **                            p_uuid is the pointer to the list of UUID values.
1405 **                  p_cback: callback functino when search is completed.
1406 **
1407 **
1408 **
1409 ** Returns          void
1410 **
1411 *******************************************************************************/
BTA_DmSearchExt(tBTA_DM_INQ * p_dm_inq,tBTA_SERVICE_MASK_EXT * p_services,tBTA_DM_SEARCH_CBACK * p_cback)1412 void BTA_DmSearchExt(tBTA_DM_INQ *p_dm_inq, tBTA_SERVICE_MASK_EXT *p_services, tBTA_DM_SEARCH_CBACK *p_cback)
1413 {
1414 #if BLE_INCLUDED == TRUE && BTA_GATT_INCLUDED == TRUE
1415     tBTA_DM_API_SEARCH    *p_msg;
1416     UINT16  len = p_services ? (sizeof(tBTA_DM_API_SEARCH) + sizeof(tBT_UUID) * p_services->num_uuid) :
1417                     sizeof(tBTA_DM_API_SEARCH);
1418 
1419     if ((p_msg = (tBTA_DM_API_SEARCH *) GKI_getbuf(len)) != NULL)
1420     {
1421         memset(p_msg, 0, len);
1422 
1423         p_msg->hdr.event = BTA_DM_API_SEARCH_EVT;
1424         memcpy(&p_msg->inq_params, p_dm_inq, sizeof(tBTA_DM_INQ));
1425         p_msg->p_cback = p_cback;
1426         p_msg->rs_res  = BTA_DM_RS_NONE;
1427 
1428 
1429         if (p_services != NULL)
1430         {
1431             p_msg->services = p_services->srvc_mask;
1432             p_msg->num_uuid = p_services->num_uuid;
1433 
1434             if (p_services->num_uuid != 0)
1435             {
1436                 p_msg->p_uuid = (tBT_UUID *)(p_msg + 1);
1437                 memcpy(p_msg->p_uuid, p_services->p_uuid, sizeof(tBT_UUID) * p_services->num_uuid);
1438             }
1439             else
1440                 p_msg->p_uuid = NULL;
1441         }
1442 
1443         bta_sys_sendmsg(p_msg);
1444     }
1445 #else
1446     UNUSED(p_dm_inq);
1447     UNUSED(p_services);
1448     UNUSED(p_cback);
1449 #endif
1450 }
1451 /*******************************************************************************
1452 **
1453 ** Function         BTA_DmBleUpdateConnectionParam
1454 **
1455 ** Description      Update connection parameters, can only be used when connection is up.
1456 **
1457 ** Parameters:      bd_addr          - BD address of the peer
1458 **                  min_int   -     minimum connection interval, [0x0004~ 0x4000]
1459 **                  max_int   -     maximum connection interval, [0x0004~ 0x4000]
1460 **                  latency   -     slave latency [0 ~ 500]
1461 **                  timeout   -     supervision timeout [0x000a ~ 0xc80]
1462 **
1463 ** Returns          void
1464 **
1465 *******************************************************************************/
BTA_DmBleUpdateConnectionParam(BD_ADDR bd_addr,UINT16 min_int,UINT16 max_int,UINT16 latency,UINT16 timeout)1466 void BTA_DmBleUpdateConnectionParam(BD_ADDR bd_addr, UINT16 min_int,
1467                                     UINT16 max_int, UINT16 latency,
1468                                     UINT16 timeout)
1469 {
1470 #if BLE_INCLUDED == TRUE
1471     tBTA_DM_API_UPDATE_CONN_PARAM *p_msg;
1472 
1473     p_msg = (tBTA_DM_API_UPDATE_CONN_PARAM *) GKI_getbuf(sizeof(tBTA_DM_API_UPDATE_CONN_PARAM));
1474     if (p_msg != NULL)
1475     {
1476         memset(p_msg, 0, sizeof(tBTA_DM_API_UPDATE_CONN_PARAM));
1477 
1478         p_msg->hdr.event = BTA_DM_API_UPDATE_CONN_PARAM_EVT;
1479         bdcpy(p_msg->bd_addr, bd_addr);
1480         p_msg->min_int   = min_int;
1481         p_msg->max_int   = max_int;
1482         p_msg->latency   = latency;
1483         p_msg->timeout   = timeout;
1484 
1485         bta_sys_sendmsg(p_msg);
1486     }
1487 #endif
1488 }
1489 /*******************************************************************************
1490 **
1491 ** Function         BTA_DmBleConfigLocalPrivacy
1492 **
1493 ** Description      Enable/disable privacy on the local device
1494 **
1495 ** Parameters:      privacy_enable   - enable/disabe privacy on remote device.
1496 **
1497 ** Returns          void
1498 **
1499 *******************************************************************************/
BTA_DmBleConfigLocalPrivacy(BOOLEAN privacy_enable)1500 void BTA_DmBleConfigLocalPrivacy(BOOLEAN privacy_enable)
1501 {
1502 #if BLE_INCLUDED == TRUE && BLE_PRIVACY_SPT == TRUE
1503     tBTA_DM_API_LOCAL_PRIVACY *p_msg;
1504 
1505     if ((p_msg = (tBTA_DM_API_LOCAL_PRIVACY *) GKI_getbuf(sizeof(tBTA_DM_API_ENABLE_PRIVACY))) != NULL)
1506     {
1507         memset (p_msg, 0, sizeof(tBTA_DM_API_LOCAL_PRIVACY));
1508 
1509         p_msg->hdr.event = BTA_DM_API_LOCAL_PRIVACY_EVT;
1510         p_msg->privacy_enable   = privacy_enable;
1511 
1512         bta_sys_sendmsg(p_msg);
1513     }
1514 #else
1515     UNUSED (privacy_enable);
1516 #endif
1517 }
1518 
1519 #if BLE_INCLUDED == TRUE
1520 /*******************************************************************************
1521 **
1522 ** Function         BTA_BleEnableAdvInstance
1523 **
1524 ** Description      This function enable a Multi-ADV instance with the specififed
1525 **                  adv parameters
1526 **
1527 ** Parameters       p_params: pointer to the adv parameter structure.
1528 **                  p_cback: callback function associated to this adv instance.
1529 **                  p_ref: reference data pointer to this adv instance.
1530 **
1531 ** Returns          BTA_SUCCESS if command started sucessfully; otherwise failure.
1532 **
1533 *******************************************************************************/
BTA_BleEnableAdvInstance(tBTA_BLE_ADV_PARAMS * p_params,tBTA_BLE_MULTI_ADV_CBACK * p_cback,void * p_ref)1534 void BTA_BleEnableAdvInstance (tBTA_BLE_ADV_PARAMS *p_params,
1535                                 tBTA_BLE_MULTI_ADV_CBACK *p_cback,
1536                                 void *p_ref)
1537 {
1538     tBTA_DM_API_BLE_MULTI_ADV_ENB    *p_msg;
1539     UINT16 len = sizeof(tBTA_BLE_ADV_PARAMS) + sizeof(tBTA_DM_API_BLE_MULTI_ADV_ENB);
1540 
1541     APPL_TRACE_API ("BTA_BleEnableAdvInstance");
1542 
1543     if ((p_msg = (tBTA_DM_API_BLE_MULTI_ADV_ENB *) GKI_getbuf(len)) != NULL)
1544     {
1545         memset(p_msg, 0, sizeof(tBTA_DM_API_BLE_MULTI_ADV_ENB));
1546 
1547         p_msg->hdr.event     = BTA_DM_API_BLE_MULTI_ADV_ENB_EVT;
1548         p_msg->p_cback      = (void *)p_cback;
1549         if (p_params != NULL)
1550         {
1551             p_msg->p_params =  (void *)(p_msg + 1);
1552             memcpy(p_msg->p_params, p_params, sizeof(tBTA_BLE_ADV_PARAMS));
1553         }
1554         p_msg->p_ref        = p_ref;
1555 
1556         bta_sys_sendmsg(p_msg);
1557     }
1558 }
1559 
1560 /*******************************************************************************
1561 **
1562 ** Function         BTA_BleUpdateAdvInstParam
1563 **
1564 ** Description      This function update a Multi-ADV instance with the specififed
1565 **                  adv parameters.
1566 **
1567 ** Parameters       inst_id: Adv instance to update the parameter.
1568 **                  p_params: pointer to the adv parameter structure.
1569 **
1570 ** Returns          BTA_SUCCESS if command started sucessfully; otherwise failure.
1571 **
1572 *******************************************************************************/
BTA_BleUpdateAdvInstParam(UINT8 inst_id,tBTA_BLE_ADV_PARAMS * p_params)1573 void BTA_BleUpdateAdvInstParam (UINT8 inst_id, tBTA_BLE_ADV_PARAMS *p_params)
1574 {
1575     tBTA_DM_API_BLE_MULTI_ADV_PARAM    *p_msg;
1576     UINT16      len = sizeof(tBTA_BLE_ADV_PARAMS) + sizeof(tBTA_DM_API_BLE_MULTI_ADV_PARAM);
1577 
1578     APPL_TRACE_API ("BTA_BleUpdateAdvInstParam");
1579      if ((p_msg = (tBTA_DM_API_BLE_MULTI_ADV_PARAM *) GKI_getbuf(len)) != NULL)
1580      {
1581           memset(p_msg, 0, sizeof(tBTA_DM_API_BLE_MULTI_ADV_PARAM));
1582           p_msg->hdr.event     = BTA_DM_API_BLE_MULTI_ADV_PARAM_UPD_EVT;
1583           p_msg->inst_id        = inst_id;
1584           p_msg->p_params =  (void *)(p_msg + 1);
1585           memcpy(p_msg->p_params, p_params, sizeof(tBTA_BLE_ADV_PARAMS));
1586 
1587           bta_sys_sendmsg(p_msg);
1588     }
1589 }
1590 
1591 /*******************************************************************************
1592 **
1593 ** Function         BTA_BleCfgAdvInstData
1594 **
1595 ** Description      This function configure a Multi-ADV instance with the specififed
1596 **                  adv data or scan response data.
1597 **
1598 ** Parameter        inst_id: Adv instance to configure the adv data or scan response.
1599 **                  is_scan_rsp: is the data scan response or adv data.
1600 **                  data_mask: adv data type as bit mask.
1601 **                  p_data: pointer to the ADV data structure tBTA_BLE_ADV_DATA. This
1602 **                  memory space can not be freed until BTA_BLE_MULTI_ADV_DATA_EVT
1603 **                  is sent to application.
1604 **
1605 ** Returns          BTA_SUCCESS if command started sucessfully; otherwise failure.
1606 **
1607 *******************************************************************************/
BTA_BleCfgAdvInstData(UINT8 inst_id,BOOLEAN is_scan_rsp,tBTA_BLE_AD_MASK data_mask,tBTA_BLE_ADV_DATA * p_data)1608 void BTA_BleCfgAdvInstData (UINT8 inst_id, BOOLEAN is_scan_rsp,
1609                             tBTA_BLE_AD_MASK data_mask,
1610                             tBTA_BLE_ADV_DATA *p_data)
1611 {
1612     tBTA_DM_API_BLE_MULTI_ADV_DATA    *p_msg;
1613     UINT16      len =  sizeof(tBTA_DM_API_BLE_MULTI_ADV_DATA) ;
1614 
1615     APPL_TRACE_API ("BTA_BleCfgAdvInstData");
1616 
1617     if ((p_msg = (tBTA_DM_API_BLE_MULTI_ADV_DATA *) GKI_getbuf(len)) != NULL)
1618     {
1619           memset(p_msg, 0, len);
1620           p_msg->hdr.event     = BTA_DM_API_BLE_MULTI_ADV_DATA_EVT;
1621           p_msg->inst_id      = inst_id;
1622           p_msg->is_scan_rsp  = is_scan_rsp;
1623           p_msg->data_mask     = data_mask;
1624           p_msg->p_data        = p_data;
1625 
1626           bta_sys_sendmsg(p_msg);
1627     }
1628 }
1629 
1630 /*******************************************************************************
1631 **
1632 ** Function         BTA_BleDisableAdvInstance
1633 **
1634 ** Description      This function disable a Multi-ADV instance.
1635 **
1636 ** Parameter        inst_id: instance ID to disable.
1637 **
1638 ** Returns          BTA_SUCCESS if command started sucessfully; otherwise failure.
1639 **
1640 *******************************************************************************/
BTA_BleDisableAdvInstance(UINT8 inst_id)1641 void BTA_BleDisableAdvInstance (UINT8  inst_id)
1642 {
1643     tBTA_DM_API_BLE_MULTI_ADV_DISABLE    *p_msg;
1644 
1645     APPL_TRACE_API ("BTA_BleDisableAdvInstance: %d", inst_id);
1646     if ((p_msg = (tBTA_DM_API_BLE_MULTI_ADV_DISABLE *)
1647           GKI_getbuf(sizeof(tBTA_DM_API_BLE_MULTI_ADV_DISABLE))) != NULL)
1648     {
1649          memset(p_msg, 0, sizeof(tBTA_DM_API_BLE_MULTI_ADV_DISABLE));
1650          p_msg->hdr.event    = BTA_DM_API_BLE_MULTI_ADV_DISABLE_EVT;
1651          p_msg->inst_id      = inst_id;
1652          bta_sys_sendmsg(p_msg);
1653     }
1654 }
1655 
1656 /*******************************************************************************
1657 **
1658 ** Function         BTA_DmBleCfgFilterCondition
1659 **
1660 ** Description      This function is called to configure the adv data payload filter
1661 **                  condition.
1662 **
1663 ** Parameters       action: to read/write/clear
1664 **                  cond_type: filter condition type
1665 **                  filt_index - Filter index
1666 **                  p_cond: filter condition parameter
1667 **                  p_cmpl_back - Command completed callback
1668 **                  ref_value - Reference value
1669 **
1670 ** Returns          void
1671 **
1672 *******************************************************************************/
BTA_DmBleCfgFilterCondition(tBTA_DM_BLE_SCAN_COND_OP action,tBTA_DM_BLE_PF_COND_TYPE cond_type,tBTA_DM_BLE_PF_FILT_INDEX filt_index,tBTA_DM_BLE_PF_COND_PARAM * p_cond,tBTA_DM_BLE_PF_CFG_CBACK * p_cmpl_cback,tBTA_DM_BLE_REF_VALUE ref_value)1673 void BTA_DmBleCfgFilterCondition(tBTA_DM_BLE_SCAN_COND_OP action,
1674                                  tBTA_DM_BLE_PF_COND_TYPE cond_type,
1675                                  tBTA_DM_BLE_PF_FILT_INDEX filt_index,
1676                                  tBTA_DM_BLE_PF_COND_PARAM *p_cond,
1677                                  tBTA_DM_BLE_PF_CFG_CBACK *p_cmpl_cback,
1678                                  tBTA_DM_BLE_REF_VALUE ref_value)
1679 {
1680 #if BLE_ANDROID_CONTROLLER_SCAN_FILTER == TRUE
1681     tBTA_DM_API_CFG_FILTER_COND *p_msg;
1682     APPL_TRACE_API ("BTA_DmBleCfgFilterCondition: %d, %d", action, cond_type);
1683 
1684     UINT16  len = sizeof(tBTA_DM_API_CFG_FILTER_COND) +
1685                   sizeof(tBTA_DM_BLE_PF_COND_PARAM);
1686     UINT8 *p;
1687 
1688     if (NULL != p_cond)
1689     {
1690         switch(cond_type)
1691         {
1692             case BTA_DM_BLE_PF_SRVC_DATA_PATTERN:
1693             case BTA_DM_BLE_PF_MANU_DATA:
1694                 /* Length of pattern and pattern mask and other elements in */
1695                 /* tBTA_DM_BLE_PF_MANU_COND */
1696                 len += ((p_cond->manu_data.data_len) * 2) +
1697                         sizeof(UINT16) + sizeof(UINT16) + sizeof(UINT8);
1698                 break;
1699 
1700             case BTA_DM_BLE_PF_LOCAL_NAME:
1701                 len += ((p_cond->local_name.data_len) + sizeof(UINT8));
1702                 break;
1703 
1704             case BTM_BLE_PF_SRVC_UUID:
1705             case BTM_BLE_PF_SRVC_SOL_UUID:
1706                 len += sizeof(tBLE_BD_ADDR) + sizeof(tBTA_DM_BLE_PF_COND_MASK);
1707                 break;
1708 
1709             default:
1710                 break;
1711         }
1712     }
1713 
1714     if ((p_msg = (tBTA_DM_API_CFG_FILTER_COND *) GKI_getbuf(len)) != NULL)
1715     {
1716         memset (p_msg, 0, len);
1717 
1718         p_msg->hdr.event        = BTA_DM_API_CFG_FILTER_COND_EVT;
1719         p_msg->action           = action;
1720         p_msg->cond_type        = cond_type;
1721         p_msg->filt_index       = filt_index;
1722         p_msg->p_filt_cfg_cback = p_cmpl_cback;
1723         p_msg->ref_value        = ref_value;
1724         if (p_cond)
1725         {
1726             p_msg->p_cond_param = (tBTA_DM_BLE_PF_COND_PARAM *)(p_msg + 1);
1727             memcpy(p_msg->p_cond_param, p_cond, sizeof(tBTA_DM_BLE_PF_COND_PARAM));
1728 
1729             p = (UINT8 *)(p_msg->p_cond_param + 1);
1730 
1731             if (cond_type == BTA_DM_BLE_PF_SRVC_DATA_PATTERN ||
1732                 cond_type == BTA_DM_BLE_PF_MANU_DATA)
1733             {
1734                 p_msg->p_cond_param->manu_data.p_pattern = p;
1735                 p_msg->p_cond_param->manu_data.data_len = p_cond->manu_data.data_len;
1736                 memcpy(p_msg->p_cond_param->manu_data.p_pattern, p_cond->manu_data.p_pattern,
1737                     p_cond->manu_data.data_len);
1738                 p += p_cond->manu_data.data_len;
1739 
1740                 if (cond_type == BTA_DM_BLE_PF_MANU_DATA)
1741                 {
1742                     p_msg->p_cond_param->manu_data.company_id_mask =
1743                         p_cond->manu_data.company_id_mask;
1744                     if ( p_cond->manu_data.p_pattern_mask != NULL)
1745                     {
1746                         p_msg->p_cond_param->manu_data.p_pattern_mask = p;
1747                         memcpy(p_msg->p_cond_param->manu_data.p_pattern_mask,
1748                             p_cond->manu_data.p_pattern_mask, p_cond->manu_data.data_len);
1749                     }
1750                 }
1751             }
1752             else if (cond_type == BTA_DM_BLE_PF_LOCAL_NAME)
1753             {
1754                 p_msg->p_cond_param->local_name.p_data = p;
1755                 p_msg->p_cond_param->local_name.data_len =
1756                     p_cond->local_name.data_len;
1757                 memcpy(p_msg->p_cond_param->local_name.p_data,
1758                     p_cond->local_name.p_data, p_cond->local_name.data_len);
1759             }
1760             else if ((cond_type == BTM_BLE_PF_SRVC_UUID
1761                 || cond_type == BTM_BLE_PF_SRVC_SOL_UUID))
1762             {
1763                 if (p_cond->srvc_uuid.p_target_addr != NULL)
1764                 {
1765                     p_msg->p_cond_param->srvc_uuid.p_target_addr = (tBLE_BD_ADDR *)(p);
1766                     p_msg->p_cond_param->srvc_uuid.p_target_addr->type =
1767                         p_cond->srvc_uuid.p_target_addr->type;
1768                     memcpy(p_msg->p_cond_param->srvc_uuid.p_target_addr->bda,
1769                         p_cond->srvc_uuid.p_target_addr->bda, BD_ADDR_LEN);
1770                     p = (UINT8*)( p_msg->p_cond_param->srvc_uuid.p_target_addr + 1);
1771                 }
1772                 if (p_cond->srvc_uuid.p_uuid_mask)
1773                 {
1774                     p_msg->p_cond_param->srvc_uuid.p_uuid_mask = (tBTA_DM_BLE_PF_COND_MASK *)p;
1775                     memcpy(p_msg->p_cond_param->srvc_uuid.p_uuid_mask,
1776                         p_cond->srvc_uuid.p_uuid_mask, sizeof(tBTA_DM_BLE_PF_COND_MASK));
1777                 }
1778             }
1779         }
1780 
1781         bta_sys_sendmsg(p_msg);
1782     }
1783 #else
1784     UNUSED(action);
1785     UNUSED(cond_type);
1786     UNUSED(filt_index);
1787     UNUSED(p_cond);
1788     UNUSED(p_cmpl_cback);
1789     UNUSED(ref_value);
1790 #endif
1791 }
1792 
1793 /*******************************************************************************
1794 **
1795 ** Function         BTA_DmBleScanFilterSetup
1796 **
1797 ** Description      This function is called to setup the adv data payload filter param
1798 **
1799 ** Parameters       p_target: enable the filter condition on a target device; if NULL
1800 **                  filt_index - Filter index
1801 **                  p_filt_params -Filter parameters
1802 **                  ref_value - Reference value
1803 **                  action - Add, delete or clear
1804 **                  p_cmpl_back - Command completed callback
1805 **
1806 ** Returns          void
1807 **
1808 *******************************************************************************/
BTA_DmBleScanFilterSetup(UINT8 action,tBTA_DM_BLE_PF_FILT_INDEX filt_index,tBTA_DM_BLE_PF_FILT_PARAMS * p_filt_params,tBLE_BD_ADDR * p_target,tBTA_DM_BLE_PF_PARAM_CBACK * p_cmpl_cback,tBTA_DM_BLE_REF_VALUE ref_value)1809 void BTA_DmBleScanFilterSetup(UINT8 action, tBTA_DM_BLE_PF_FILT_INDEX filt_index,
1810                                     tBTA_DM_BLE_PF_FILT_PARAMS *p_filt_params,
1811                                     tBLE_BD_ADDR *p_target,
1812                                     tBTA_DM_BLE_PF_PARAM_CBACK *p_cmpl_cback,
1813                                     tBTA_DM_BLE_REF_VALUE ref_value)
1814 {
1815 #if BLE_ANDROID_CONTROLLER_SCAN_FILTER == TRUE
1816     tBTA_DM_API_SCAN_FILTER_PARAM_SETUP *p_msg;
1817     APPL_TRACE_API ("BTA_DmBleScanFilterSetup: %d", action);
1818 
1819     UINT16  len = sizeof(tBTA_DM_API_SCAN_FILTER_PARAM_SETUP) + sizeof(tBLE_BD_ADDR);
1820 
1821     if ((p_msg = (tBTA_DM_API_SCAN_FILTER_PARAM_SETUP *) GKI_getbuf(len)) != NULL)
1822     {
1823         memset (p_msg, 0, len);
1824 
1825         p_msg->hdr.event        = BTA_DM_API_SCAN_FILTER_SETUP_EVT;
1826         p_msg->action       = action;
1827         p_msg->filt_index = filt_index;
1828         if (p_filt_params)
1829             memcpy(&p_msg->filt_params, p_filt_params, sizeof(tBTA_DM_BLE_PF_FILT_PARAMS));
1830         p_msg->p_filt_param_cback = p_cmpl_cback;
1831         p_msg->ref_value        = ref_value;
1832 
1833         if (p_target)
1834         {
1835             p_msg->p_target = (tBLE_BD_ADDR *)(p_msg + 1);
1836             memcpy(p_msg->p_target, p_target, sizeof(tBLE_BD_ADDR));
1837         }
1838 
1839         bta_sys_sendmsg(p_msg);
1840     }
1841 #else
1842     UNUSED(action);
1843     UNUSED(filt_index);
1844     UNUSED(p_filt_params);
1845     UNUSED(p_target);
1846     UNUSED(p_cmpl_cback);
1847     UNUSED(ref_value);
1848 #endif
1849 }
1850 
1851 /*******************************************************************************
1852 **
1853 ** Function         BTA_DmBleGetEnergyInfo
1854 **
1855 ** Description      This function is called to obtain the energy info
1856 **
1857 ** Parameters       p_cmpl_cback - Command complete callback
1858 **
1859 ** Returns          void
1860 **
1861 *******************************************************************************/
BTA_DmBleGetEnergyInfo(tBTA_BLE_ENERGY_INFO_CBACK * p_cmpl_cback)1862 void BTA_DmBleGetEnergyInfo(tBTA_BLE_ENERGY_INFO_CBACK *p_cmpl_cback)
1863 {
1864     tBTA_DM_API_ENERGY_INFO *p_msg;
1865     APPL_TRACE_API ("BTA_DmBleGetEnergyInfo");
1866 
1867     UINT16  len = sizeof(tBTA_DM_API_ENERGY_INFO) + sizeof(tBLE_BD_ADDR);
1868 
1869     if ((p_msg = (tBTA_DM_API_ENERGY_INFO *) GKI_getbuf(len)) != NULL)
1870     {
1871         memset (p_msg, 0, len);
1872         p_msg->hdr.event        = BTA_DM_API_BLE_ENERGY_INFO_EVT;
1873         p_msg->p_energy_info_cback = p_cmpl_cback;
1874         bta_sys_sendmsg(p_msg);
1875     }
1876 }
1877 
1878 /*******************************************************************************
1879 **
1880 ** Function         BTA_DmEnableScanFilter
1881 **
1882 ** Description      This function is called to enable the adv data payload filter
1883 **
1884 ** Parameters       action - enable or disable the APCF feature
1885 **                  p_cmpl_cback - Command completed callback
1886 **                  ref_value - Reference value
1887 **
1888 ** Returns          void
1889 **
1890 *******************************************************************************/
BTA_DmEnableScanFilter(UINT8 action,tBTA_DM_BLE_PF_STATUS_CBACK * p_cmpl_cback,tBTA_DM_BLE_REF_VALUE ref_value)1891 void BTA_DmEnableScanFilter(UINT8 action, tBTA_DM_BLE_PF_STATUS_CBACK *p_cmpl_cback,
1892                                     tBTA_DM_BLE_REF_VALUE ref_value)
1893 {
1894 #if BLE_ANDROID_CONTROLLER_SCAN_FILTER == TRUE
1895     tBTA_DM_API_ENABLE_SCAN_FILTER *p_msg;
1896     APPL_TRACE_API ("BTA_DmEnableScanFilter: %d", action);
1897 
1898     UINT16  len = sizeof(tBTA_DM_API_ENABLE_SCAN_FILTER) + sizeof(tBLE_BD_ADDR);
1899 
1900     if ((p_msg = (tBTA_DM_API_ENABLE_SCAN_FILTER *) GKI_getbuf(len)) != NULL)
1901     {
1902         memset (p_msg, 0, len);
1903 
1904         p_msg->hdr.event        = BTA_DM_API_SCAN_FILTER_ENABLE_EVT;
1905         p_msg->action       = action;
1906         p_msg->ref_value    = ref_value;
1907         p_msg->p_filt_status_cback = p_cmpl_cback;
1908 
1909         bta_sys_sendmsg(p_msg);
1910     }
1911 #else
1912     UNUSED(action);
1913     UNUSED(p_cmpl_cback);
1914     UNUSED(ref_value);
1915 #endif
1916 }
1917 
1918 /*******************************************************************************
1919 **
1920 ** Function         BTA_DmBleUpdateConnectionParams
1921 **
1922 ** Description      Update connection parameters, can only be used when connection is up.
1923 **
1924 ** Parameters:      bd_addr   - BD address of the peer
1925 **                  min_int   -     minimum connection interval, [0x0004~ 0x4000]
1926 **                  max_int   -     maximum connection interval, [0x0004~ 0x4000]
1927 **                  latency   -     slave latency [0 ~ 500]
1928 **                  timeout   -     supervision timeout [0x000a ~ 0xc80]
1929 **
1930 ** Returns          void
1931 **
1932 *******************************************************************************/
BTA_DmBleUpdateConnectionParams(BD_ADDR bd_addr,UINT16 min_int,UINT16 max_int,UINT16 latency,UINT16 timeout)1933 void BTA_DmBleUpdateConnectionParams(BD_ADDR bd_addr, UINT16 min_int, UINT16 max_int,
1934                                     UINT16 latency, UINT16 timeout)
1935 {
1936     tBTA_DM_API_UPDATE_CONN_PARAM *p_msg;
1937 
1938     if ((p_msg = (tBTA_DM_API_UPDATE_CONN_PARAM *) GKI_getbuf(sizeof(tBTA_DM_API_UPDATE_CONN_PARAM))) != NULL)
1939     {
1940         memset (p_msg, 0, sizeof(tBTA_DM_API_UPDATE_CONN_PARAM));
1941 
1942         p_msg->hdr.event = BTA_DM_API_UPDATE_CONN_PARAM_EVT;
1943         bdcpy(p_msg->bd_addr, bd_addr);
1944         p_msg->min_int   = min_int;
1945         p_msg->max_int   = max_int;
1946         p_msg->latency   = latency;
1947         p_msg->timeout   = timeout;
1948 
1949         bta_sys_sendmsg(p_msg);
1950     }
1951 }
1952 
1953 /*******************************************************************************
1954 **
1955 ** Function         BTA_DmBleSetDataLength
1956 **
1957 ** Description      This function is to set maximum LE data packet size
1958 **
1959 ** Returns          void
1960 **
1961 **
1962 *******************************************************************************/
BTA_DmBleSetDataLength(BD_ADDR remote_device,UINT16 tx_data_length)1963 void BTA_DmBleSetDataLength(BD_ADDR remote_device, UINT16 tx_data_length)
1964 {
1965     tBTA_DM_API_BLE_SET_DATA_LENGTH *p_msg;
1966 
1967     if ((p_msg = (tBTA_DM_API_BLE_SET_DATA_LENGTH *)GKI_getbuf(sizeof(tBTA_DM_API_BLE_SET_DATA_LENGTH)))
1968                   != NULL)
1969     {
1970         bdcpy(p_msg->remote_bda, remote_device);
1971         p_msg->hdr.event = BTA_DM_API_SET_DATA_LENGTH_EVT;
1972         p_msg->tx_data_length = tx_data_length;
1973 
1974         bta_sys_sendmsg(p_msg);
1975     }
1976 }
1977 
1978 #endif
1979 
1980 /*******************************************************************************
1981 **
1982 ** Function         BTA_DmSetEncryption
1983 **
1984 ** Description      This function is called to ensure that connection is
1985 **                  encrypted.  Should be called only on an open connection.
1986 **                  Typically only needed for connections that first want to
1987 **                  bring up unencrypted links, then later encrypt them.
1988 **
1989 ** Parameters:      bd_addr       - Address of the peer device
1990 **                  transport     - transport of the link to be encruypted
1991 **                  p_callback    - Pointer to callback function to indicat the
1992 **                                  link encryption status
1993 **                  sec_act       - This is the security action to indicate
1994 **                                  what knid of BLE security level is required for
1995 **                                  the BLE link if the BLE is supported
1996 **                                  Note: This parameter is ignored for the BR/EDR link
1997 **                                        or the BLE is not supported
1998 **
1999 ** Returns          void
2000 **
2001 *******************************************************************************/
BTA_DmSetEncryption(BD_ADDR bd_addr,tBTA_TRANSPORT transport,tBTA_DM_ENCRYPT_CBACK * p_callback,tBTA_DM_BLE_SEC_ACT sec_act)2002 void BTA_DmSetEncryption(BD_ADDR bd_addr, tBTA_TRANSPORT transport, tBTA_DM_ENCRYPT_CBACK *p_callback,
2003                             tBTA_DM_BLE_SEC_ACT sec_act)
2004 {
2005     tBTA_DM_API_SET_ENCRYPTION   *p_msg;
2006 
2007     APPL_TRACE_API("BTA_DmSetEncryption"); //todo
2008     if ((p_msg = (tBTA_DM_API_SET_ENCRYPTION *) GKI_getbuf(sizeof(tBTA_DM_API_SET_ENCRYPTION))) != NULL)
2009     {
2010         memset(p_msg, 0, sizeof(tBTA_DM_API_SET_ENCRYPTION));
2011 
2012         p_msg->hdr.event = BTA_DM_API_SET_ENCRYPTION_EVT;
2013 
2014         memcpy(p_msg->bd_addr, bd_addr, BD_ADDR_LEN);
2015         p_msg->transport    = transport;
2016         p_msg->p_callback      = p_callback;
2017         p_msg->sec_act         = sec_act;
2018 
2019         bta_sys_sendmsg(p_msg);
2020     }
2021 }
2022 
2023 /*******************************************************************************
2024 **
2025 ** Function         BTA_DmCloseACL
2026 **
2027 ** Description      This function force to close an ACL connection and remove the
2028 **                  device from the security database list of known devices.
2029 **
2030 ** Parameters:      bd_addr       - Address of the peer device
2031 **                  remove_dev    - remove device or not after link down
2032 **
2033 ** Returns          void
2034 **
2035 *******************************************************************************/
BTA_DmCloseACL(BD_ADDR bd_addr,BOOLEAN remove_dev,tBTA_TRANSPORT transport)2036 void BTA_DmCloseACL(BD_ADDR bd_addr, BOOLEAN remove_dev, tBTA_TRANSPORT transport)
2037 {
2038     tBTA_DM_API_REMOVE_ACL   *p_msg;
2039 
2040     APPL_TRACE_API("BTA_DmCloseACL");
2041 
2042     if ((p_msg = (tBTA_DM_API_REMOVE_ACL *) GKI_getbuf(sizeof(tBTA_DM_API_REMOVE_ACL))) != NULL)
2043     {
2044         memset(p_msg, 0, sizeof(tBTA_DM_API_REMOVE_ACL));
2045 
2046         p_msg->hdr.event = BTA_DM_API_REMOVE_ACL_EVT;
2047 
2048         memcpy(p_msg->bd_addr, bd_addr, BD_ADDR_LEN);
2049         p_msg->remove_dev      = remove_dev;
2050         p_msg->transport       = transport;
2051 
2052         bta_sys_sendmsg(p_msg);
2053     }
2054 }
2055 
2056 #if BLE_INCLUDED == TRUE
2057 /*******************************************************************************
2058 **
2059 ** Function         BTA_DmBleObserve
2060 **
2061 ** Description      This procedure keep the device listening for advertising
2062 **                  events from a broadcast device.
2063 **
2064 ** Parameters       start: start or stop observe.
2065 **
2066 ** Returns          void
2067 
2068 **
2069 ** Returns          void.
2070 **
2071 *******************************************************************************/
BTA_DmBleObserve(BOOLEAN start,UINT8 duration,tBTA_DM_SEARCH_CBACK * p_results_cb)2072 extern void BTA_DmBleObserve(BOOLEAN start, UINT8 duration,
2073                              tBTA_DM_SEARCH_CBACK *p_results_cb)
2074 {
2075     tBTA_DM_API_BLE_OBSERVE   *p_msg;
2076 
2077     APPL_TRACE_API("BTA_DmBleObserve:start = %d ", start);
2078 
2079     if ((p_msg = (tBTA_DM_API_BLE_OBSERVE *) GKI_getbuf(sizeof(tBTA_DM_API_BLE_OBSERVE))) != NULL)
2080     {
2081         memset(p_msg, 0, sizeof(tBTA_DM_API_BLE_OBSERVE));
2082 
2083         p_msg->hdr.event = BTA_DM_API_BLE_OBSERVE_EVT;
2084         p_msg->start = start;
2085         p_msg->duration = duration;
2086         p_msg->p_cback = p_results_cb;
2087 
2088         bta_sys_sendmsg(p_msg);
2089     }
2090 }
2091 
2092 /*******************************************************************************
2093 **
2094 ** Function         BTA_VendorInit
2095 **
2096 ** Description      This function initializes vendor specific
2097 **
2098 ** Returns          void
2099 **
2100 *******************************************************************************/
BTA_VendorInit(void)2101 void BTA_VendorInit (void)
2102 {
2103     APPL_TRACE_API("BTA_VendorInit");
2104 }
2105 
2106 /*******************************************************************************
2107 **
2108 ** Function         BTA_VendorCleanup
2109 **
2110 ** Description      This function frees up Broadcom specific VS specific dynamic memory
2111 **
2112 ** Returns          void
2113 **
2114 *******************************************************************************/
BTA_VendorCleanup(void)2115 void BTA_VendorCleanup (void)
2116 {
2117     tBTM_BLE_VSC_CB cmn_ble_vsc_cb;
2118     BTM_BleGetVendorCapabilities(&cmn_ble_vsc_cb);
2119 
2120 #if (BLE_INCLUDED == TRUE && BLE_ANDROID_CONTROLLER_SCAN_FILTER == TRUE)
2121     if (cmn_ble_vsc_cb.max_filter > 0)
2122     {
2123         btm_ble_adv_filter_cleanup();
2124 #if BLE_PRIVACY_SPT == TRUE
2125         btm_ble_resolving_list_cleanup ();
2126 #endif
2127     }
2128 
2129     if (cmn_ble_vsc_cb.tot_scan_results_strg > 0)
2130         btm_ble_batchscan_cleanup();
2131 #endif
2132 
2133    if(cmn_ble_vsc_cb.adv_inst_max > 0)
2134       btm_ble_multi_adv_cleanup();
2135 }
2136 
2137 #endif
2138