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 "bta/bta_sys.h"
26 #include "bta/bta_api.h"
27 #include "bta_dm_int.h"
28 #include "bta_sys_int.h"
29 #include "stack/btm_api.h"
30 #include "btm_int.h"
31 #include <string.h>
32 #include <assert.h>
33 #include "bta/utl.h"
34 #include "osi/allocator.h"
35
36 /*****************************************************************************
37 ** Constants
38 *****************************************************************************/
39
40 static const tBTA_SYS_REG bta_dm_reg = {
41 bta_dm_sm_execute,
42 bta_dm_sm_disable
43 };
44
45 static const tBTA_SYS_REG bta_dm_search_reg = {
46 bta_dm_search_sm_execute,
47 bta_dm_search_sm_disable
48 };
49
50 /*******************************************************************************
51 **
52 ** Function BTA_EnableBluetooth
53 **
54 ** Description Enables bluetooth service. This function must be
55 ** called before any other functions in the BTA API are called.
56 **
57 **
58 ** Returns tBTA_STATUS
59 **
60 *******************************************************************************/
BTA_EnableBluetooth(tBTA_DM_SEC_CBACK * p_cback)61 tBTA_STATUS BTA_EnableBluetooth(tBTA_DM_SEC_CBACK *p_cback)
62 {
63
64 tBTA_DM_API_ENABLE *p_msg;
65
66 /* Bluetooth disabling is in progress */
67 if (bta_dm_cb.disabling) {
68 return BTA_FAILURE;
69 }
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 *) osi_malloc(sizeof(tBTA_DM_API_ENABLE))) != NULL) {
80 p_msg->hdr.event = BTA_DM_API_ENABLE_EVT;
81 p_msg->p_sec_cback = p_cback;
82 bta_sys_sendmsg(p_msg);
83 return BTA_SUCCESS;
84 }
85 return BTA_FAILURE;
86
87 }
88
89 /*******************************************************************************
90 **
91 ** Function BTA_DisableBluetooth
92 **
93 ** Description Disables bluetooth service. This function is called when
94 ** the application no longer needs bluetooth service
95 **
96 ** Returns void
97 **
98 *******************************************************************************/
BTA_DisableBluetooth(void)99 tBTA_STATUS BTA_DisableBluetooth(void)
100 {
101
102 BT_HDR *p_msg;
103
104 if ((p_msg = (BT_HDR *) osi_malloc(sizeof(BT_HDR))) != NULL) {
105 p_msg->event = BTA_DM_API_DISABLE_EVT;
106 bta_sys_sendmsg(p_msg);
107 } else {
108 return BTA_FAILURE;
109 }
110
111 return BTA_SUCCESS;
112 }
113
114 /*******************************************************************************
115 **
116 ** Function BTA_EnableTestMode
117 **
118 ** Description Enables bluetooth device under test mode
119 **
120 **
121 ** Returns tBTA_STATUS
122 **
123 *******************************************************************************/
BTA_EnableTestMode(void)124 tBTA_STATUS BTA_EnableTestMode(void)
125 {
126 BT_HDR *p_msg;
127
128 APPL_TRACE_API("BTA_EnableTestMode");
129
130 if ((p_msg = (BT_HDR *) osi_malloc(sizeof(BT_HDR))) != NULL) {
131 p_msg->event = BTA_DM_API_ENABLE_TEST_MODE_EVT;
132 bta_sys_sendmsg(p_msg);
133 return BTA_SUCCESS;
134 }
135 return BTA_FAILURE;
136 }
137
138 /*******************************************************************************
139 **
140 ** Function BTA_DisableTestMode
141 **
142 ** Description Disable bluetooth device under test mode
143 **
144 **
145 ** Returns None
146 **
147 *******************************************************************************/
BTA_DisableTestMode(void)148 void BTA_DisableTestMode(void)
149 {
150 BT_HDR *p_msg;
151
152 APPL_TRACE_API("BTA_DisableTestMode");
153
154 if ((p_msg = (BT_HDR *) osi_malloc(sizeof(BT_HDR))) != NULL) {
155 p_msg->event = BTA_DM_API_DISABLE_TEST_MODE_EVT;
156 bta_sys_sendmsg(p_msg);
157 }
158 }
159
160 /*******************************************************************************
161 **
162 ** Function BTA_DmSetDeviceName
163 **
164 ** Description This function sets the Bluetooth name of local device
165 **
166 **
167 ** Returns void
168 **
169 *******************************************************************************/
BTA_DmSetDeviceName(const char * p_name)170 void BTA_DmSetDeviceName(const char *p_name)
171 {
172
173 tBTA_DM_API_SET_NAME *p_msg;
174
175 if ((p_msg = (tBTA_DM_API_SET_NAME *) osi_malloc(sizeof(tBTA_DM_API_SET_NAME))) != NULL) {
176 p_msg->hdr.event = BTA_DM_API_SET_NAME_EVT;
177 /* truncate the name if needed */
178 BCM_STRNCPY_S((char *)p_msg->name, p_name, BD_NAME_LEN);
179 p_msg->name[BD_NAME_LEN] = '\0';
180
181 bta_sys_sendmsg(p_msg);
182 }
183 }
184
185 /*******************************************************************************
186 **
187 ** Function BTA_DmGetDeviceName
188 **
189 ** Description This function gets the Bluetooth name of local device
190 **
191 **
192 ** Returns void
193 **
194 *******************************************************************************/
BTA_DmGetDeviceName(tBTA_GET_DEV_NAME_CBACK * p_cback)195 void BTA_DmGetDeviceName(tBTA_GET_DEV_NAME_CBACK *p_cback)
196 {
197 tBTA_DM_API_GET_NAME *p_msg;
198
199 if ((p_msg = (tBTA_DM_API_GET_NAME *) osi_malloc(sizeof(tBTA_DM_API_GET_NAME))) != NULL) {
200 p_msg->hdr.event = BTA_DM_API_GET_NAME_EVT;
201 p_msg->p_cback = p_cback;
202 bta_sys_sendmsg(p_msg);
203 }
204 }
205
BTA_DmsendVendorHciCmd(UINT16 opcode,UINT8 param_len,UINT8 * p_param_buf,tBTA_SEND_VENDOR_HCI_CMPL_CBACK p_vendor_cmd_complete_cback)206 void BTA_DmsendVendorHciCmd(UINT16 opcode, UINT8 param_len, UINT8 *p_param_buf, tBTA_SEND_VENDOR_HCI_CMPL_CBACK p_vendor_cmd_complete_cback)
207 {
208 tBTA_DM_API_SEND_VENDOR_HCI_CMD *p_msg;
209 if ((p_msg = (tBTA_DM_API_SEND_VENDOR_HCI_CMD *)osi_malloc(sizeof(tBTA_DM_API_SEND_VENDOR_HCI_CMD) + param_len)) != NULL) {
210 p_msg->hdr.event = BTA_DM_API_SEND_VENDOR_HCI_CMD_EVT;
211 p_msg->opcode = opcode;
212 p_msg->param_len = param_len;
213 p_msg->p_param_buf = (UINT8 *)(p_msg + 1);
214 memcpy(p_msg->p_param_buf, p_param_buf, param_len);
215 p_msg->vendor_hci_cb = p_vendor_cmd_complete_cback;
216
217 bta_sys_sendmsg(p_msg);
218 }
219 }
220
221 #if (CLASSIC_BT_INCLUDED == TRUE)
222
BTA_DmConfigEir(tBTA_DM_EIR_CONF * eir_config)223 void BTA_DmConfigEir(tBTA_DM_EIR_CONF *eir_config)
224 {
225 tBTA_DM_API_CONFIG_EIR *p_msg;
226
227 UINT8 eir_manufac_spec_len = eir_config->bta_dm_eir_manufac_spec_len;
228 UINT8 eir_url_len = eir_config->bta_dm_eir_url_len;
229
230 if (eir_manufac_spec_len > HCI_EXT_INQ_RESPONSE_LEN) {
231 APPL_TRACE_WARNING ("%s: Manufacturer data is too long(%d), cut it to %d\n",
232 __func__, eir_manufac_spec_len, HCI_EXT_INQ_RESPONSE_LEN);
233 eir_manufac_spec_len = HCI_EXT_INQ_RESPONSE_LEN;
234 }
235 if (eir_url_len > HCI_EXT_INQ_RESPONSE_LEN) {
236 APPL_TRACE_WARNING ("%s: URL is too long(%d), cut it to %d\n",
237 __func__, eir_url_len, HCI_EXT_INQ_RESPONSE_LEN);
238 eir_url_len = HCI_EXT_INQ_RESPONSE_LEN;
239 }
240
241 if ((p_msg = (tBTA_DM_API_CONFIG_EIR *) osi_malloc(sizeof(tBTA_DM_API_CONFIG_EIR) + eir_manufac_spec_len + eir_url_len)) != NULL) {
242 p_msg->hdr.event = BTA_DM_API_CONFIG_EIR_EVT;
243
244 p_msg->eir_fec_required = eir_config->bta_dm_eir_fec_required;
245 p_msg->eir_included_name = eir_config->bta_dm_eir_included_name;
246 p_msg->eir_included_tx_power = eir_config->bta_dm_eir_included_tx_power;
247 p_msg->eir_included_uuid = eir_config->bta_dm_eir_included_uuid;
248 p_msg->eir_flags = eir_config->bta_dm_eir_flags;
249 p_msg->eir_manufac_spec_len = eir_manufac_spec_len;
250 p_msg->eir_manufac_spec = p_msg->data;
251 p_msg->eir_url_len = eir_url_len;
252 p_msg->eir_url = p_msg->data + eir_manufac_spec_len;
253
254 if (eir_manufac_spec_len > 0) {
255 memcpy(p_msg->eir_manufac_spec, eir_config->bta_dm_eir_manufac_spec, eir_manufac_spec_len);
256 }
257
258 if (eir_url_len > 0) {
259 memcpy(p_msg->eir_url, eir_config->bta_dm_eir_url, eir_url_len);
260 }
261
262 bta_sys_sendmsg(p_msg);
263 }
264 }
265
266
267 /*******************************************************************************
268 **
269 ** Function BTA_DmSetAfhChannels
270 **
271 ** Description This function sets the AFH channels
272 **
273 **
274 ** Returns void
275 **
276 *******************************************************************************/
BTA_DmSetAfhChannels(const uint8_t * channels,tBTA_CMPL_CB * set_afh_cb)277 void BTA_DmSetAfhChannels(const uint8_t *channels, tBTA_CMPL_CB *set_afh_cb)
278 {
279 tBTA_DM_API_SET_AFH_CHANNELS *p_msg;
280
281 if ((p_msg = (tBTA_DM_API_SET_AFH_CHANNELS *) osi_malloc(sizeof(tBTA_DM_API_SET_AFH_CHANNELS))) != NULL) {
282 p_msg->hdr.event = BTA_DM_API_SET_AFH_CHANNELS_EVT;
283
284 p_msg->set_afh_cb = set_afh_cb;
285 memcpy(p_msg->channels, channels, AFH_CHANNELS_LEN);
286
287 bta_sys_sendmsg(p_msg);
288 }
289 }
290
291 /*******************************************************************************
292 **
293 ** Function BTA_DmSetAclPktTypes
294 **
295 ** Description This function sets the packet types used for ACL traffic.
296 **
297 **
298 ** Returns void
299 **
300 *******************************************************************************/
BTA_DmSetAclPktTypes(BD_ADDR remote_addr,UINT16 pkt_types,tBTM_CMPL_CB * p_cb)301 void BTA_DmSetAclPktTypes(BD_ADDR remote_addr, UINT16 pkt_types, tBTM_CMPL_CB *p_cb)
302 {
303 tBTA_DM_API_SET_ACL_PKT_TYPES *p_msg;
304
305 if ((p_msg = (tBTA_DM_API_SET_ACL_PKT_TYPES *) osi_malloc(sizeof(tBTA_DM_API_SET_ACL_PKT_TYPES))) != NULL) {
306 p_msg->hdr.event = BTA_DM_API_SET_ACL_PKT_TYPES_EVT;
307 bdcpy(p_msg->rmt_addr, remote_addr);
308 p_msg->pkt_types = pkt_types;
309 p_msg->set_acl_pkt_types_cb = p_cb;
310
311 bta_sys_sendmsg(p_msg);
312 }
313 }
314 #endif /// CLASSIC_BT_INCLUDED == TRUE
315
316 #if (SDP_INCLUDED == TRUE)
317 /*******************************************************************************
318 **
319 ** Function BTA_DmGetRemoteName
320 **
321 ** Description This function gets the peer device's Bluetooth name.
322 **
323 **
324 ** Returns void
325 **
326 *******************************************************************************/
BTA_DmGetRemoteName(BD_ADDR remote_addr,tBTA_CMPL_CB * rmt_name_cb)327 void BTA_DmGetRemoteName(BD_ADDR remote_addr, tBTA_CMPL_CB *rmt_name_cb)
328 {
329 tBTA_DM_API_GET_REMOTE_NAME *p_msg;
330
331 if ((p_msg = (tBTA_DM_API_GET_REMOTE_NAME *) osi_malloc(sizeof(tBTA_DM_API_GET_REMOTE_NAME))) != NULL) {
332 p_msg->hdr.event = BTA_DM_API_GET_REMOTE_NAME_EVT;
333 p_msg->rmt_name_cb = rmt_name_cb;
334 bdcpy(p_msg->rmt_addr, remote_addr);
335 bta_sys_sendmsg(p_msg);
336 }
337 }
338 #endif
339
340 #if (BLE_INCLUDED == TRUE)
341 /*******************************************************************************
342 **
343 ** Function BTA_DmBleSetChannels
344 **
345 ** Description This function sets BLE channels
346 **
347 **
348 ** Returns void
349 **
350 *******************************************************************************/
BTA_DmBleSetChannels(const uint8_t * channels,tBTA_CMPL_CB * set_channels_cb)351 void BTA_DmBleSetChannels(const uint8_t *channels, tBTA_CMPL_CB *set_channels_cb)
352 {
353
354 tBTA_DM_API_BLE_SET_CHANNELS *p_msg;
355
356 if ((p_msg = (tBTA_DM_API_BLE_SET_CHANNELS *) osi_malloc(sizeof(tBTA_DM_API_BLE_SET_CHANNELS))) != NULL) {
357 p_msg->hdr.event = BTA_DM_API_BLE_SET_CHANNELS_EVT;
358
359 p_msg->set_channels_cb = set_channels_cb;
360 memcpy(p_msg->channels, channels, BLE_CHANNELS_LEN);
361
362 bta_sys_sendmsg(p_msg);
363 }
364
365
366 }
367
BTA_DmUpdateWhiteList(BOOLEAN add_remove,BD_ADDR remote_addr,tBLE_ADDR_TYPE addr_type,tBTA_UPDATE_WHITELIST_CBACK * update_wl_cb)368 void BTA_DmUpdateWhiteList(BOOLEAN add_remove, BD_ADDR remote_addr, tBLE_ADDR_TYPE addr_type, tBTA_UPDATE_WHITELIST_CBACK *update_wl_cb)
369 {
370 tBTA_DM_API_UPDATE_WHITE_LIST *p_msg;
371 if ((p_msg = (tBTA_DM_API_UPDATE_WHITE_LIST *)osi_malloc(sizeof(tBTA_DM_API_UPDATE_WHITE_LIST))) != NULL) {
372 p_msg->hdr.event = BTA_DM_API_UPDATE_WHITE_LIST_EVT;
373 p_msg->add_remove = add_remove;
374 p_msg->addr_type = addr_type;
375 p_msg->update_wl_cb = update_wl_cb;
376 memcpy(p_msg->remote_addr, remote_addr, sizeof(BD_ADDR));
377
378 bta_sys_sendmsg(p_msg);
379 }
380 }
381
BTA_DmClearWhiteList(tBTA_UPDATE_WHITELIST_CBACK * update_wl_cb)382 void BTA_DmClearWhiteList(tBTA_UPDATE_WHITELIST_CBACK *update_wl_cb)
383 {
384 tBTA_DM_API_UPDATE_WHITE_LIST *p_msg;
385 if ((p_msg = (tBTA_DM_API_UPDATE_WHITE_LIST *)osi_malloc(sizeof(tBTA_DM_API_UPDATE_WHITE_LIST))) != NULL) {
386 p_msg->hdr.event = BTA_DM_API_CLEAR_WHITE_LIST_EVT;
387 p_msg->update_wl_cb = update_wl_cb;
388
389 bta_sys_sendmsg(p_msg);
390 }
391 }
392
BTA_DmBleReadAdvTxPower(tBTA_CMPL_CB * cmpl_cb)393 void BTA_DmBleReadAdvTxPower(tBTA_CMPL_CB *cmpl_cb)
394 {
395 tBTA_DM_API_READ_ADV_TX_POWER *p_msg;
396 if ((p_msg = (tBTA_DM_API_READ_ADV_TX_POWER *)osi_malloc(sizeof(tBTA_DM_API_READ_ADV_TX_POWER))) != NULL) {
397 p_msg->hdr.event = BTA_DM_API_BLE_READ_ADV_TX_POWER_EVT;
398 p_msg->read_tx_power_cb = cmpl_cb;
399 bta_sys_sendmsg(p_msg);
400 }
401 }
402 #endif ///BLE_INCLUDED == TRUE
403
BTA_DmReadRSSI(BD_ADDR remote_addr,tBTA_TRANSPORT transport,tBTA_CMPL_CB * cmpl_cb)404 void BTA_DmReadRSSI(BD_ADDR remote_addr, tBTA_TRANSPORT transport, tBTA_CMPL_CB *cmpl_cb)
405 {
406 tBTA_DM_API_READ_RSSI *p_msg;
407 if ((p_msg = (tBTA_DM_API_READ_RSSI *)osi_malloc(sizeof(tBTA_DM_API_READ_RSSI))) != NULL) {
408 p_msg->hdr.event = BTA_DM_API_READ_RSSI_EVT;
409 memcpy(p_msg->remote_addr, remote_addr, sizeof(BD_ADDR));
410 p_msg->transport = transport;
411 p_msg->read_rssi_cb = cmpl_cb;
412 bta_sys_sendmsg(p_msg);
413 }
414 }
415
416 /*******************************************************************************
417 **
418 ** Function BTA_DmSetVisibility
419 **
420 ** Description This function sets the Bluetooth connectable,
421 ** discoverable, pairable and conn paired only modes of local device
422 **
423 **
424 ** Returns void
425 **
426 *******************************************************************************/
BTA_DmSetVisibility(tBTA_DM_DISC disc_mode,tBTA_DM_CONN conn_mode,UINT8 pairable_mode,UINT8 conn_filter)427 void BTA_DmSetVisibility(tBTA_DM_DISC disc_mode, tBTA_DM_CONN conn_mode, UINT8 pairable_mode, UINT8 conn_filter )
428 {
429
430 tBTA_DM_API_SET_VISIBILITY *p_msg;
431
432 if ((p_msg = (tBTA_DM_API_SET_VISIBILITY *) osi_malloc(sizeof(tBTA_DM_API_SET_VISIBILITY))) != NULL) {
433 p_msg->hdr.event = BTA_DM_API_SET_VISIBILITY_EVT;
434 p_msg->disc_mode = disc_mode;
435 p_msg->conn_mode = conn_mode;
436 p_msg->pair_mode = pairable_mode;
437 p_msg->conn_paired_only = conn_filter;
438
439
440 bta_sys_sendmsg(p_msg);
441 }
442
443
444 }
445
446 /*******************************************************************************
447 **
448 ** Function BTA_DmSearch
449 **
450 ** Description This function searches for peer Bluetooth devices. It performs
451 ** an inquiry and gets the remote name for devices. Service
452 ** discovery is done if services is non zero
453 **
454 **
455 ** Returns void
456 **
457 *******************************************************************************/
BTA_DmSearch(tBTA_DM_INQ * p_dm_inq,tBTA_SERVICE_MASK services,tBTA_DM_SEARCH_CBACK * p_cback)458 void BTA_DmSearch(tBTA_DM_INQ *p_dm_inq, tBTA_SERVICE_MASK services, tBTA_DM_SEARCH_CBACK *p_cback)
459 {
460
461 tBTA_DM_API_SEARCH *p_msg;
462
463 if ((p_msg = (tBTA_DM_API_SEARCH *) osi_malloc(sizeof(tBTA_DM_API_SEARCH))) != NULL) {
464 memset(p_msg, 0, sizeof(tBTA_DM_API_SEARCH));
465
466 p_msg->hdr.event = BTA_DM_API_SEARCH_EVT;
467 memcpy(&p_msg->inq_params, p_dm_inq, sizeof(tBTA_DM_INQ));
468 p_msg->services = services;
469 p_msg->p_cback = p_cback;
470 p_msg->rs_res = BTA_DM_RS_NONE;
471 bta_sys_sendmsg(p_msg);
472 }
473
474 }
475
476
477 /*******************************************************************************
478 **
479 ** Function BTA_DmSearchCancel
480 **
481 ** Description This function cancels a search initiated by BTA_DmSearch
482 **
483 **
484 ** Returns void
485 **
486 *******************************************************************************/
BTA_DmSearchCancel(void)487 void BTA_DmSearchCancel(void)
488 {
489 BT_HDR *p_msg;
490
491 if ((p_msg = (BT_HDR *) osi_malloc(sizeof(BT_HDR))) != NULL) {
492 p_msg->event = BTA_DM_API_SEARCH_CANCEL_EVT;
493 bta_sys_sendmsg(p_msg);
494 }
495
496 }
497
498 #if (SDP_INCLUDED == TRUE)
499 /*******************************************************************************
500 **
501 ** Function BTA_DmDiscover
502 **
503 ** Description This function does service discovery for services of a
504 ** peer device
505 **
506 **
507 ** Returns void
508 **
509 *******************************************************************************/
BTA_DmDiscover(BD_ADDR bd_addr,tBTA_SERVICE_MASK services,tBTA_DM_SEARCH_CBACK * p_cback,BOOLEAN sdp_search)510 void BTA_DmDiscover(BD_ADDR bd_addr, tBTA_SERVICE_MASK services,
511 tBTA_DM_SEARCH_CBACK *p_cback, BOOLEAN sdp_search)
512 {
513 tBTA_DM_API_DISCOVER *p_msg;
514
515 if ((p_msg = (tBTA_DM_API_DISCOVER *) osi_malloc(sizeof(tBTA_DM_API_DISCOVER))) != NULL) {
516 memset(p_msg, 0, sizeof(tBTA_DM_API_DISCOVER));
517
518 p_msg->hdr.event = BTA_DM_API_DISCOVER_EVT;
519 bdcpy(p_msg->bd_addr, bd_addr);
520 p_msg->services = services;
521 p_msg->p_cback = p_cback;
522 p_msg->sdp_search = sdp_search;
523 bta_sys_sendmsg(p_msg);
524 }
525 }
526
527 /*******************************************************************************
528 **
529 ** Function BTA_DmDiscoverUUID
530 **
531 ** Description This function does service discovery for services of a
532 ** peer device
533 **
534 **
535 ** Returns void
536 **
537 *******************************************************************************/
BTA_DmDiscoverUUID(BD_ADDR bd_addr,tSDP_UUID * uuid,tBTA_DM_SEARCH_CBACK * p_cback,BOOLEAN sdp_search)538 void BTA_DmDiscoverUUID(BD_ADDR bd_addr, tSDP_UUID *uuid,
539 tBTA_DM_SEARCH_CBACK *p_cback, BOOLEAN sdp_search)
540 {
541 tBTA_DM_API_DISCOVER *p_msg;
542
543 if ((p_msg = (tBTA_DM_API_DISCOVER *) osi_malloc(sizeof(tBTA_DM_API_DISCOVER))) != NULL) {
544 p_msg->hdr.event = BTA_DM_API_DISCOVER_EVT;
545 bdcpy(p_msg->bd_addr, bd_addr);
546 p_msg->services = BTA_USER_SERVICE_MASK; //Not exposed at API level
547 p_msg->p_cback = p_cback;
548 p_msg->sdp_search = sdp_search;
549
550 #if BLE_INCLUDED == TRUE && BTA_GATT_INCLUDED == TRUE
551 p_msg->num_uuid = 0;
552 p_msg->p_uuid = NULL;
553 #endif
554 memcpy( &p_msg->uuid, uuid, sizeof(tSDP_UUID) );
555 bta_sys_sendmsg(p_msg);
556 }
557 }
558 #endif ///SDP_INCLUDED == TRUE
559
560 /*******************************************************************************
561 **
562 ** Function BTA_DmBond
563 **
564 ** Description This function initiates a bonding procedure with a peer
565 ** device
566 **
567 **
568 ** Returns void
569 **
570 *******************************************************************************/
571 #if (SMP_INCLUDED == TRUE)
BTA_DmBond(BD_ADDR bd_addr)572 void BTA_DmBond(BD_ADDR bd_addr)
573 {
574 tBTA_DM_API_BOND *p_msg;
575
576 p_msg = (tBTA_DM_API_BOND *) osi_malloc(sizeof(tBTA_DM_API_BOND));
577 if (p_msg != NULL) {
578 p_msg->hdr.event = BTA_DM_API_BOND_EVT;
579 bdcpy(p_msg->bd_addr, bd_addr);
580 p_msg->transport = BTA_TRANSPORT_UNKNOWN;
581 bta_sys_sendmsg(p_msg);
582 }
583 }
584
585 /*******************************************************************************
586 **
587 ** Function BTA_DmBondByTransports
588 **
589 ** Description This function initiates a bonding procedure with a peer
590 ** device
591 **
592 **
593 ** Returns void
594 **
595 *******************************************************************************/
BTA_DmBondByTransport(BD_ADDR bd_addr,tBTA_TRANSPORT transport)596 void BTA_DmBondByTransport(BD_ADDR bd_addr, tBTA_TRANSPORT transport)
597 {
598 tBTA_DM_API_BOND *p_msg;
599
600 if ((p_msg = (tBTA_DM_API_BOND *) osi_malloc(sizeof(tBTA_DM_API_BOND))) != NULL) {
601 p_msg->hdr.event = BTA_DM_API_BOND_EVT;
602 bdcpy(p_msg->bd_addr, bd_addr);
603 p_msg->transport = transport;
604 bta_sys_sendmsg(p_msg);
605 }
606
607
608 }
609
610 /*******************************************************************************
611 **
612 ** Function BTA_DmBondCancel
613 **
614 ** Description This function cancels the bonding procedure with a peer
615 ** device
616 **
617 **
618 ** Returns void
619 **
620 *******************************************************************************/
BTA_DmBondCancel(BD_ADDR bd_addr)621 void BTA_DmBondCancel(BD_ADDR bd_addr)
622 {
623 tBTA_DM_API_BOND_CANCEL *p_msg;
624
625 if ((p_msg = (tBTA_DM_API_BOND_CANCEL *) osi_malloc(sizeof(tBTA_DM_API_BOND_CANCEL))) != NULL) {
626 p_msg->hdr.event = BTA_DM_API_BOND_CANCEL_EVT;
627 bdcpy(p_msg->bd_addr, bd_addr);
628 bta_sys_sendmsg(p_msg);
629 }
630 }
631 #endif ///SMP_INCLUDED == TRUE
632
633 #if (CLASSIC_BT_INCLUDED == TRUE)
634 /*******************************************************************************
635 **
636 ** Function BTA_DMSetPinType
637 **
638 ** Description This function set pin type as BTM_PIN_TYPE_FIXED or BTM_PIN_TYPE_VARIABLE
639 **
640 **
641 ** Returns void
642 **
643 *******************************************************************************/
BTA_DMSetPinType(UINT8 pin_type,UINT8 * pin_code,UINT8 pin_code_len)644 void BTA_DMSetPinType (UINT8 pin_type, UINT8 *pin_code, UINT8 pin_code_len)
645 {
646 tBTA_DM_API_SET_PIN_TYPE *p_msg;
647
648 if ((p_msg = (tBTA_DM_API_SET_PIN_TYPE *) osi_malloc(sizeof(tBTA_DM_API_SET_PIN_TYPE))) != NULL) {
649 p_msg->hdr.event = BTA_DM_API_SET_PIN_TYPE_EVT;
650 p_msg->pin_type = pin_type;
651 p_msg->pin_len = pin_code_len;
652 memcpy(p_msg->p_pin, pin_code, pin_code_len);
653 bta_sys_sendmsg(p_msg);
654 }
655 }
656
657 /*******************************************************************************
658 **
659 ** Function BTA_DmPinReply
660 **
661 ** Description This function provides a pincode for a remote device when
662 ** one is requested by DM through BTA_DM_PIN_REQ_EVT
663 **
664 **
665 ** Returns void
666 **
667 *******************************************************************************/
BTA_DmPinReply(BD_ADDR bd_addr,BOOLEAN accept,UINT8 pin_len,UINT8 * p_pin)668 void BTA_DmPinReply(BD_ADDR bd_addr, BOOLEAN accept, UINT8 pin_len, UINT8 *p_pin)
669 {
670 tBTA_DM_API_PIN_REPLY *p_msg;
671
672 if ((p_msg = (tBTA_DM_API_PIN_REPLY *) osi_malloc(sizeof(tBTA_DM_API_PIN_REPLY))) != NULL) {
673 p_msg->hdr.event = BTA_DM_API_PIN_REPLY_EVT;
674 bdcpy(p_msg->bd_addr, bd_addr);
675 p_msg->accept = accept;
676 if (accept) {
677 p_msg->pin_len = pin_len;
678 memcpy(p_msg->p_pin, p_pin, pin_len);
679 }
680 bta_sys_sendmsg(p_msg);
681 }
682
683 }
684 #endif ///CLASSIC_BT_INCLUDED == TRUE
685
686 #if (BTM_OOB_INCLUDED == TRUE && SMP_INCLUDED == TRUE)
687 /*******************************************************************************
688 **
689 ** Function BTA_DmLocalOob
690 **
691 ** Description This function retrieves the OOB data from local controller.
692 ** The result is reported by:
693 ** - bta_dm_co_loc_oob_ext() if device supports secure
694 ** connections (SC)
695 ** - bta_dm_co_loc_oob() if device doesn't support SC
696 **
697 ** Returns void
698 **
699 *******************************************************************************/
BTA_DmLocalOob(void)700 void BTA_DmLocalOob(void)
701 {
702 tBTA_DM_API_LOC_OOB *p_msg;
703
704 if ((p_msg = (tBTA_DM_API_LOC_OOB *) osi_malloc(sizeof(tBTA_DM_API_LOC_OOB))) != NULL) {
705 p_msg->hdr.event = BTA_DM_API_LOC_OOB_EVT;
706 bta_sys_sendmsg(p_msg);
707 }
708 }
709
710 /*******************************************************************************
711 **
712 ** Function BTA_DmOobReply
713 **
714 ** This function is called to provide the OOB data for
715 ** SMP in response to BTA_LE_OOB_REQ_EVT
716 **
717 ** Parameters: bd_addr - Address of the peer device
718 ** len - length of simple pairing Randomizer C
719 ** p_value - simple pairing Randomizer C.
720 **
721 ** Returns void
722 **
723 *******************************************************************************/
BTA_DmOobReply(BD_ADDR bd_addr,UINT8 len,UINT8 * p_value)724 void BTA_DmOobReply(BD_ADDR bd_addr, UINT8 len, UINT8 *p_value)
725 {
726 tBTA_DM_API_OOB_REPLY *p_msg;
727
728 if ((p_msg = (tBTA_DM_API_OOB_REPLY *) osi_malloc(sizeof(tBTA_DM_API_OOB_REPLY))) != NULL) {
729 p_msg->hdr.event = BTA_DM_API_OOB_REPLY_EVT;
730 if(p_value == NULL || len > BT_OCTET16_LEN) {
731 osi_free(p_msg);
732 return;
733 }
734 memcpy(p_msg->bd_addr, bd_addr, BD_ADDR_LEN);
735 p_msg->len = len;
736 memcpy(p_msg->value, p_value, len);
737 bta_sys_sendmsg(p_msg);
738 }
739 }
740
741 /*******************************************************************************
742 **
743 ** Function BTA_DmSecureConnectionOobReply
744 **
745 ** This function is called to provide the OOB data for
746 ** SMP in response to BTA_LE_OOB_REQ_EVT
747 **
748 ** Parameters: bd_addr - Address of the peer device
749 ** p_c - Pointer to Confirmation
750 ** p_r - Pointer to Randomizer
751 **
752 ** Returns void
753 **
754 *******************************************************************************/
BTA_DmSecureConnectionOobReply(BD_ADDR bd_addr,UINT8 * p_c,UINT8 * p_r)755 void BTA_DmSecureConnectionOobReply(BD_ADDR bd_addr, UINT8 *p_c, UINT8 *p_r)
756 {
757 tBTA_DM_API_SC_OOB_REPLY *p_msg;
758
759 if ((p_msg = (tBTA_DM_API_SC_OOB_REPLY *) osi_malloc(sizeof(tBTA_DM_API_OOB_REPLY))) != NULL) {
760 p_msg->hdr.event = BTA_DM_API_SC_OOB_REPLY_EVT;
761 if((p_c == NULL) || (p_r == NULL)) {
762 return;
763 }
764 memcpy(p_msg->bd_addr, bd_addr, BD_ADDR_LEN);
765 memcpy(p_msg->c, p_c, BT_OCTET16_LEN);
766 memcpy(p_msg->r, p_r, BT_OCTET16_LEN);
767 bta_sys_sendmsg(p_msg);
768 }
769 }
770 /*******************************************************************************
771 **
772 ** Function BTA_DmSecureConnectionCreateOobData
773 **
774 ** This function is called to create the OOB data for
775 ** SMP when secure connection
776 **
777 ** Returns void
778 **
779 *******************************************************************************/
BTA_DmSecureConnectionCreateOobData(void)780 void BTA_DmSecureConnectionCreateOobData(void)
781 {
782 tBTA_DM_API_SC_CR_OOB_DATA *p_msg;
783
784 if ((p_msg = (tBTA_DM_API_SC_CR_OOB_DATA *) osi_malloc(sizeof(tBTA_DM_API_SC_CR_OOB_DATA))) != NULL) {
785 p_msg->hdr.event = BTA_DM_API_SC_CR_OOB_DATA_EVT;
786 bta_sys_sendmsg(p_msg);
787 }
788 }
789 #endif /* BTM_OOB_INCLUDED */
790 /*******************************************************************************
791 **
792 ** Function BTA_DmConfirm
793 **
794 ** Description This function accepts or rejects the numerical value of the
795 ** Simple Pairing process on BTA_DM_SP_CFM_REQ_EVT
796 **
797 ** Returns void
798 **
799 *******************************************************************************/
800 #if (SMP_INCLUDED == TRUE)
BTA_DmConfirm(BD_ADDR bd_addr,BOOLEAN accept)801 void BTA_DmConfirm(BD_ADDR bd_addr, BOOLEAN accept)
802 {
803 tBTA_DM_API_CONFIRM *p_msg;
804
805 if ((p_msg = (tBTA_DM_API_CONFIRM *) osi_malloc(sizeof(tBTA_DM_API_CONFIRM))) != NULL) {
806 p_msg->hdr.event = BTA_DM_API_CONFIRM_EVT;
807 bdcpy(p_msg->bd_addr, bd_addr);
808 p_msg->accept = accept;
809 bta_sys_sendmsg(p_msg);
810 }
811 }
812
813 /*******************************************************************************
814 **
815 ** Function BTA_DmPasskeyReqReply
816 **
817 ** Description This function is called to provide the passkey for
818 ** Simple Pairing in response to BTA_DM_SP_KEY_REQ_EVT
819 **
820 ** Returns void
821 **
822 *******************************************************************************/
823 #if (BT_SSP_INCLUDED == TRUE)
BTA_DmPasskeyReqReply(BOOLEAN accept,BD_ADDR bd_addr,UINT32 passkey)824 void BTA_DmPasskeyReqReply(BOOLEAN accept, BD_ADDR bd_addr, UINT32 passkey)
825 {
826 tBTA_DM_API_KEY_REQ *p_msg;
827 if ((p_msg = (tBTA_DM_API_KEY_REQ *) osi_malloc(sizeof(tBTA_DM_API_KEY_REQ))) != NULL) {
828 p_msg->hdr.event = BTA_DM_API_KEY_REQ_EVT;
829 bdcpy(p_msg->bd_addr, bd_addr);
830 p_msg->accept = accept;
831 p_msg->passkey = passkey;
832 bta_sys_sendmsg(p_msg);
833 }
834 }
835 #endif ///BT_SSP_INCLUDED == TRUE
836 #endif ///SMP_INCLUDED == TRUE
837 /*******************************************************************************
838 **
839 ** Function BTA_DmAddDevice
840 **
841 ** Description This function adds a device to the security database list of
842 ** peer device
843 **
844 **
845 ** Returns void
846 **
847 *******************************************************************************/
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,UINT8 sc_support)848 void BTA_DmAddDevice(BD_ADDR bd_addr, DEV_CLASS dev_class, LINK_KEY link_key,
849 tBTA_SERVICE_MASK trusted_mask, BOOLEAN is_trusted,
850 UINT8 key_type, tBTA_IO_CAP io_cap, UINT8 pin_length,
851 UINT8 sc_support)
852 {
853
854 tBTA_DM_API_ADD_DEVICE *p_msg;
855
856 if ((p_msg = (tBTA_DM_API_ADD_DEVICE *) osi_malloc(sizeof(tBTA_DM_API_ADD_DEVICE))) != NULL) {
857 memset (p_msg, 0, sizeof(tBTA_DM_API_ADD_DEVICE));
858
859 p_msg->hdr.event = BTA_DM_API_ADD_DEVICE_EVT;
860 bdcpy(p_msg->bd_addr, bd_addr);
861 p_msg->tm = trusted_mask;
862 p_msg->is_trusted = is_trusted;
863 p_msg->io_cap = io_cap;
864 p_msg->sc_support = sc_support;
865
866 if (link_key) {
867 p_msg->link_key_known = TRUE;
868 p_msg->key_type = key_type;
869 memcpy(p_msg->link_key, link_key, LINK_KEY_LEN);
870 }
871
872 /* Load device class if specified */
873 if (dev_class) {
874 p_msg->dc_known = TRUE;
875 memcpy (p_msg->dc, dev_class, DEV_CLASS_LEN);
876 }
877
878 memset (p_msg->bd_name, 0, BD_NAME_LEN + 1);
879 memset (p_msg->features, 0, sizeof (p_msg->features));
880 p_msg->pin_length = pin_length;
881
882 bta_sys_sendmsg(p_msg);
883 }
884 }
885
886
887 /*******************************************************************************
888 **
889 ** Function BTA_DmRemoveDevice
890 **
891 ** Description This function removes a device from the security database list of
892 ** peer device. It manages unpairing even while connected.
893 **
894 **
895 ** Returns void
896 **
897 *******************************************************************************/
BTA_DmRemoveDevice(BD_ADDR bd_addr,tBT_TRANSPORT transport)898 tBTA_STATUS BTA_DmRemoveDevice(BD_ADDR bd_addr, tBT_TRANSPORT transport)
899 {
900 tBTA_DM_API_REMOVE_DEVICE *p_msg;
901
902 if ((p_msg = (tBTA_DM_API_REMOVE_DEVICE *) osi_malloc(sizeof(tBTA_DM_API_REMOVE_DEVICE))) != NULL) {
903 memset (p_msg, 0, sizeof(tBTA_DM_API_REMOVE_DEVICE));
904
905 p_msg->hdr.event = BTA_DM_API_REMOVE_DEVICE_EVT;
906 bdcpy(p_msg->bd_addr, bd_addr);
907 p_msg->transport = transport;
908 bta_sys_sendmsg(p_msg);
909 } else {
910 return BTA_FAILURE;
911 }
912
913 return BTA_SUCCESS;
914 }
915 // #endif ///SMP_INCLUDED == TRUE
916
917 /*******************************************************************************
918 **
919 ** Function BTA_GetEirService
920 **
921 ** Description This function is called to get BTA service mask from EIR.
922 **
923 ** Parameters p_eir - pointer of EIR significant part
924 ** p_services - return the BTA service mask
925 **
926 ** Returns None
927 **
928 *******************************************************************************/
929 extern const UINT16 bta_service_id_to_uuid_lkup_tbl [];
BTA_GetEirService(UINT8 * p_eir,tBTA_SERVICE_MASK * p_services)930 void BTA_GetEirService( UINT8 *p_eir, tBTA_SERVICE_MASK *p_services )
931 {
932 UINT8 xx, yy;
933 UINT8 num_uuid, max_num_uuid = 32;
934 UINT8 uuid_list[32 * LEN_UUID_16];
935 UINT16 *p_uuid16 = (UINT16 *)uuid_list;
936 tBTA_SERVICE_MASK mask;
937
938 BTM_GetEirUuidList( p_eir, LEN_UUID_16, &num_uuid, uuid_list, max_num_uuid);
939 for ( xx = 0; xx < num_uuid; xx++ ) {
940 mask = 1;
941 for ( yy = 0; yy < BTA_MAX_SERVICE_ID; yy++ ) {
942 if ( *(p_uuid16 + xx) == bta_service_id_to_uuid_lkup_tbl[yy] ) {
943 *p_services |= mask;
944 break;
945 }
946 mask <<= 1;
947 }
948
949 /* for HSP v1.2 only device */
950 if (*(p_uuid16 + xx) == UUID_SERVCLASS_HEADSET_HS) {
951 *p_services |= BTA_HSP_SERVICE_MASK;
952 }
953
954 if (*(p_uuid16 + xx) == UUID_SERVCLASS_HDP_SOURCE) {
955 *p_services |= BTA_HL_SERVICE_MASK;
956 }
957
958 if (*(p_uuid16 + xx) == UUID_SERVCLASS_HDP_SINK) {
959 *p_services |= BTA_HL_SERVICE_MASK;
960 }
961 }
962 }
963
964 /*******************************************************************************
965 **
966 ** Function BTA_DmGetConnectionState
967 **
968 ** Description Returns whether the remote device is currently connected.
969 **
970 ** Returns 0 if the device is NOT connected.
971 **
972 *******************************************************************************/
BTA_DmGetConnectionState(BD_ADDR bd_addr)973 UINT16 BTA_DmGetConnectionState( BD_ADDR bd_addr )
974 {
975 tBTA_DM_PEER_DEVICE *p_dev = bta_dm_find_peer_device(bd_addr);
976 return (p_dev && p_dev->conn_state == BTA_DM_CONNECTED);
977 }
978
979 #if (SDP_INCLUDED == TRUE)
980 /*******************************************************************************
981 ** Device Identification (DI) Server Functions
982 *******************************************************************************/
983 /*******************************************************************************
984 **
985 ** Function BTA_DmSetLocalDiRecord
986 **
987 ** Description This function adds a DI record to the local SDP database.
988 **
989 ** Returns BTA_SUCCESS if record set successfully, otherwise error code.
990 **
991 *******************************************************************************/
BTA_DmSetLocalDiRecord(tBTA_DI_RECORD * p_device_info,UINT32 * p_handle)992 tBTA_STATUS BTA_DmSetLocalDiRecord( tBTA_DI_RECORD *p_device_info,
993 UINT32 *p_handle )
994 {
995 tBTA_STATUS status = BTA_FAILURE;
996
997 if (bta_dm_di_cb.di_num < BTA_DI_NUM_MAX) {
998 if (SDP_SetLocalDiRecord((tSDP_DI_RECORD *)p_device_info, p_handle) == SDP_SUCCESS) {
999 if (!p_device_info->primary_record) {
1000 for (uint8_t i = 1; i < BTA_DI_NUM_MAX; i++) {
1001 if (!bta_dm_di_cb.di_handle[i]) {
1002 bta_dm_di_cb.di_handle[i] = *p_handle;
1003 break;
1004 }
1005 }
1006 bta_dm_di_cb.di_num++;
1007 } else if (!bta_dm_di_cb.di_handle[0]) {
1008 bta_dm_di_cb.di_handle[0] = *p_handle;
1009 bta_dm_di_cb.di_num++;
1010 } else {
1011 assert(bta_dm_di_cb.di_handle[0] == (*p_handle));
1012 }
1013
1014 if (!bta_dm_di_cb.uuid_added) {
1015 bta_sys_add_uuid(UUID_SERVCLASS_PNP_INFORMATION);
1016 bta_dm_di_cb.uuid_added = TRUE;
1017 }
1018
1019 status = BTA_SUCCESS;
1020 }
1021 }
1022
1023 return status;
1024 }
1025
1026 /*******************************************************************************
1027 **
1028 ** Function BTA_DmRemoveLocalDiRecord
1029 **
1030 ** Description This function removes a DI record from the local SDP database.
1031 **
1032 ** Returns BTA_SUCCESS if record is removed successfully, otherwise error code.
1033 **
1034 *******************************************************************************/
BTA_DmRemoveLocalDiRecord(UINT32 handle)1035 tBTA_STATUS BTA_DmRemoveLocalDiRecord(UINT32 handle)
1036 {
1037 tBTA_STATUS status = BTA_FAILURE;
1038
1039 for (uint8_t i = 0; i < BTA_DI_NUM_MAX; i++) {
1040 if (bta_dm_di_cb.di_handle[i] == handle) {
1041 if (SDP_DeleteRecord(handle)) {
1042 bta_dm_di_cb.di_handle[i] = 0;
1043 bta_dm_di_cb.di_num--;
1044 status = BTA_SUCCESS;
1045 break;
1046 }
1047 }
1048 }
1049
1050 if (bta_dm_di_cb.di_num == 0 && bta_dm_di_cb.uuid_added) {
1051 bta_sys_remove_uuid(UUID_SERVCLASS_PNP_INFORMATION);
1052 }
1053
1054 return status;
1055 }
1056 #endif ///SDP_INCLUDED == TRUE
1057 /*******************************************************************************
1058 **
1059 ** Function bta_dmexecutecallback
1060 **
1061 ** Description This function will request BTA to execute a call back in the context of BTU task
1062 ** This API was named in lower case because it is only intended
1063 ** for the internal customers(like BTIF).
1064 **
1065 ** Returns void
1066 **
1067 *******************************************************************************/
bta_dmexecutecallback(tBTA_DM_EXEC_CBACK * p_callback,void * p_param)1068 void bta_dmexecutecallback (tBTA_DM_EXEC_CBACK *p_callback, void *p_param)
1069 {
1070 tBTA_DM_API_EXECUTE_CBACK *p_msg;
1071
1072 if ((p_msg = (tBTA_DM_API_EXECUTE_CBACK *) osi_malloc(sizeof(tBTA_DM_API_EXECUTE_CBACK))) != NULL) {
1073 p_msg->hdr.event = BTA_DM_API_EXECUTE_CBACK_EVT;
1074 p_msg->p_param = p_param;
1075 p_msg->p_exec_cback = p_callback;
1076 bta_sys_sendmsg(p_msg);
1077 }
1078 }
1079
1080 /*******************************************************************************
1081 **
1082 ** Function BTA_DmAddBleKey
1083 **
1084 ** Description Add/modify LE device information. This function will be
1085 ** normally called during host startup to restore all required
1086 ** information stored in the NVRAM.
1087 **
1088 ** Parameters: bd_addr - BD address of the peer
1089 ** p_le_key - LE key values.
1090 ** key_type - LE SMP key type.
1091 **
1092 ** Returns BTA_SUCCESS if successful
1093 ** BTA_FAIL if operation failed.
1094 **
1095 *******************************************************************************/
1096 #if BLE_INCLUDED == TRUE
1097 #if SMP_INCLUDED == TRUE
BTA_DmAddBleKey(BD_ADDR bd_addr,tBTA_LE_KEY_VALUE * p_le_key,tBTA_LE_KEY_TYPE key_type)1098 void BTA_DmAddBleKey (BD_ADDR bd_addr, tBTA_LE_KEY_VALUE *p_le_key, tBTA_LE_KEY_TYPE key_type)
1099 {
1100 tBTA_DM_API_ADD_BLEKEY *p_msg;
1101
1102 if ((p_msg = (tBTA_DM_API_ADD_BLEKEY *) osi_malloc(sizeof(tBTA_DM_API_ADD_BLEKEY))) != NULL) {
1103 memset (p_msg, 0, sizeof(tBTA_DM_API_ADD_BLEKEY));
1104
1105 p_msg->hdr.event = BTA_DM_API_ADD_BLEKEY_EVT;
1106 p_msg->key_type = key_type;
1107 bdcpy(p_msg->bd_addr, bd_addr);
1108 memcpy(&p_msg->blekey, p_le_key, sizeof(tBTA_LE_KEY_VALUE));
1109
1110 bta_sys_sendmsg(p_msg);
1111 }
1112
1113 }
1114
1115 /*******************************************************************************
1116 **
1117 ** Function BTA_DmAddBleDevice
1118 **
1119 ** Description Add a BLE device. This function will be normally called
1120 ** during host startup to restore all required information
1121 ** for a LE device stored in the NVRAM.
1122 **
1123 ** Parameters: bd_addr - BD address of the peer
1124 ** dev_type - Remote device's device type.
1125 ** auth_mode - auth mode
1126 ** addr_type - LE device address type.
1127 **
1128 ** Returns void
1129 **
1130 *******************************************************************************/
BTA_DmAddBleDevice(BD_ADDR bd_addr,tBLE_ADDR_TYPE addr_type,int auth_mode,tBT_DEVICE_TYPE dev_type)1131 void BTA_DmAddBleDevice(BD_ADDR bd_addr, tBLE_ADDR_TYPE addr_type, int auth_mode, tBT_DEVICE_TYPE dev_type)
1132 {
1133 tBTA_DM_API_ADD_BLE_DEVICE *p_msg;
1134
1135 if ((p_msg = (tBTA_DM_API_ADD_BLE_DEVICE *) osi_malloc(sizeof(tBTA_DM_API_ADD_BLE_DEVICE))) != NULL) {
1136 memset (p_msg, 0, sizeof(tBTA_DM_API_ADD_BLE_DEVICE));
1137
1138 p_msg->hdr.event = BTA_DM_API_ADD_BLEDEVICE_EVT;
1139 bdcpy(p_msg->bd_addr, bd_addr);
1140 p_msg->addr_type = addr_type;
1141 p_msg->auth_mode = auth_mode;
1142 p_msg->dev_type = dev_type;
1143
1144 bta_sys_sendmsg(p_msg);
1145 }
1146 }
1147 /*******************************************************************************
1148 **
1149 ** Function BTA_DmBlePasskeyReply
1150 **
1151 ** Description Send BLE SMP passkey reply.
1152 **
1153 ** Parameters: bd_addr - BD address of the peer
1154 ** accept - passkey entry successful or declined.
1155 ** passkey - passkey value, must be a 6 digit number,
1156 ** can be lead by 0.
1157 **
1158 ** Returns void
1159 **
1160 *******************************************************************************/
BTA_DmBlePasskeyReply(BD_ADDR bd_addr,BOOLEAN accept,UINT32 passkey)1161 void BTA_DmBlePasskeyReply(BD_ADDR bd_addr, BOOLEAN accept, UINT32 passkey)
1162 {
1163 tBTA_DM_API_PASSKEY_REPLY *p_msg;
1164
1165 if ((p_msg = (tBTA_DM_API_PASSKEY_REPLY *) osi_malloc(sizeof(tBTA_DM_API_PASSKEY_REPLY))) != NULL) {
1166 memset(p_msg, 0, sizeof(tBTA_DM_API_PASSKEY_REPLY));
1167
1168 p_msg->hdr.event = BTA_DM_API_BLE_PASSKEY_REPLY_EVT;
1169 bdcpy(p_msg->bd_addr, bd_addr);
1170 p_msg->accept = accept;
1171
1172 if (accept) {
1173 p_msg->passkey = passkey;
1174 }
1175 bta_sys_sendmsg(p_msg);
1176 }
1177 }
1178
BTA_DmBleSetStaticPasskey(bool add,uint32_t passkey)1179 void BTA_DmBleSetStaticPasskey(bool add, uint32_t passkey)
1180 {
1181 tBTA_DM_API_SET_DEFAULT_PASSKEY *p_msg;
1182
1183 if ((p_msg = (tBTA_DM_API_SET_DEFAULT_PASSKEY *) osi_malloc(sizeof(tBTA_DM_API_SET_DEFAULT_PASSKEY))) != NULL) {
1184 memset(p_msg, 0, sizeof(tBTA_DM_API_SET_DEFAULT_PASSKEY));
1185
1186 p_msg->hdr.event = BTA_DM_API_BLE_SET_STATIC_PASSKEY_EVT;
1187 p_msg->add = add;
1188 p_msg->static_passkey = passkey;
1189 bta_sys_sendmsg(p_msg);
1190 }
1191 }
1192
1193 /*******************************************************************************
1194 **
1195 ** Function BTA_DmBleConfirmReply
1196 **
1197 ** Description Send BLE SMP SC user confirmation reply.
1198 **
1199 ** Parameters: bd_addr - BD address of the peer
1200 ** accept - numbers to compare are the same or different.
1201 **
1202 ** Returns void
1203 **
1204 *******************************************************************************/
BTA_DmBleConfirmReply(BD_ADDR bd_addr,BOOLEAN accept)1205 void BTA_DmBleConfirmReply(BD_ADDR bd_addr, BOOLEAN accept)
1206 {
1207 tBTA_DM_API_CONFIRM *p_msg = (tBTA_DM_API_CONFIRM *)osi_malloc(sizeof(tBTA_DM_API_CONFIRM));
1208 if (p_msg != NULL) {
1209 memset(p_msg, 0, sizeof(tBTA_DM_API_CONFIRM));
1210 p_msg->hdr.event = BTA_DM_API_BLE_CONFIRM_REPLY_EVT;
1211 bdcpy(p_msg->bd_addr, bd_addr);
1212 p_msg->accept = accept;
1213 bta_sys_sendmsg(p_msg);
1214 }
1215 }
1216
1217 /*******************************************************************************
1218 **
1219 ** Function BTA_DmBleSecurityGrant
1220 **
1221 ** Description Grant security request access.
1222 **
1223 ** Parameters: bd_addr - BD address of the peer
1224 ** res - security grant status.
1225 **
1226 ** Returns void
1227 **
1228 *******************************************************************************/
BTA_DmBleSecurityGrant(BD_ADDR bd_addr,tBTA_DM_BLE_SEC_GRANT res)1229 void BTA_DmBleSecurityGrant(BD_ADDR bd_addr, tBTA_DM_BLE_SEC_GRANT res)
1230 {
1231 tBTA_DM_API_BLE_SEC_GRANT *p_msg;
1232
1233 if ((p_msg = (tBTA_DM_API_BLE_SEC_GRANT *) osi_malloc(sizeof(tBTA_DM_API_BLE_SEC_GRANT))) != NULL) {
1234 memset(p_msg, 0, sizeof(tBTA_DM_API_BLE_SEC_GRANT));
1235
1236 p_msg->hdr.event = BTA_DM_API_BLE_SEC_GRANT_EVT;
1237 bdcpy(p_msg->bd_addr, bd_addr);
1238 p_msg->res = res;
1239
1240 bta_sys_sendmsg(p_msg);
1241 }
1242 }
1243 #endif ///SMP_INCLUDED == TRUE
1244
1245
1246 /*******************************************************************************
1247 **
1248 ** Function BTA_DmSetBlePrefConnParams
1249 **
1250 ** Description This function is called to set the preferred connection
1251 ** parameters when default connection parameter is not desired.
1252 **
1253 ** Parameters: bd_addr - BD address of the peripheral
1254 ** scan_interval - scan interval
1255 ** scan_window - scan window
1256 ** min_conn_int - minimum preferred connection interval
1257 ** max_conn_int - maximum preferred connection interval
1258 ** slave_latency - preferred slave latency
1259 ** supervision_tout - preferred supervision timeout
1260 **
1261 **
1262 ** Returns void
1263 **
1264 *******************************************************************************/
BTA_DmSetBlePrefConnParams(BD_ADDR bd_addr,UINT16 min_conn_int,UINT16 max_conn_int,UINT16 slave_latency,UINT16 supervision_tout)1265 void BTA_DmSetBlePrefConnParams(BD_ADDR bd_addr,
1266 UINT16 min_conn_int, UINT16 max_conn_int,
1267 UINT16 slave_latency, UINT16 supervision_tout )
1268 {
1269 #if BLE_INCLUDED == TRUE
1270 tBTA_DM_API_BLE_CONN_PARAMS *p_msg;
1271
1272 if ((p_msg = (tBTA_DM_API_BLE_CONN_PARAMS *) osi_malloc(sizeof(tBTA_DM_API_BLE_CONN_PARAMS))) != NULL) {
1273 memset(p_msg, 0, sizeof(tBTA_DM_API_BLE_CONN_PARAMS));
1274
1275 p_msg->hdr.event = BTA_DM_API_BLE_CONN_PARAM_EVT;
1276
1277 memcpy(p_msg->peer_bda, bd_addr, BD_ADDR_LEN);
1278
1279 p_msg->conn_int_max = max_conn_int;
1280 p_msg->conn_int_min = min_conn_int;
1281 p_msg->slave_latency = slave_latency;
1282 p_msg->supervision_tout = supervision_tout;
1283
1284 bta_sys_sendmsg(p_msg);
1285 }
1286 #endif
1287 }
1288
1289 /*******************************************************************************
1290 **
1291 ** Function BTA_DmSetBleConnScanParams
1292 **
1293 ** Description This function is called to set scan parameters used in
1294 ** BLE connection request
1295 **
1296 ** Parameters: scan_interval - scan interval
1297 ** scan_window - scan window
1298 **
1299 ** Returns void
1300 **
1301 *******************************************************************************/
BTA_DmSetBleConnScanParams(UINT32 scan_interval,UINT32 scan_window)1302 void BTA_DmSetBleConnScanParams(UINT32 scan_interval, UINT32 scan_window)
1303 {
1304 tBTA_DM_API_BLE_SCAN_PARAMS *p_msg;
1305 if ((p_msg = (tBTA_DM_API_BLE_SCAN_PARAMS *)osi_malloc(sizeof(tBTA_DM_API_BLE_SCAN_PARAMS))) != NULL) {
1306 memset(p_msg, 0, sizeof(tBTA_DM_API_BLE_SCAN_PARAMS));
1307 p_msg->hdr.event = BTA_DM_API_BLE_CONN_SCAN_PARAM_EVT;
1308 p_msg->scan_int = scan_interval;
1309 p_msg->scan_window = scan_window;
1310 bta_sys_sendmsg(p_msg);
1311 }
1312 }
1313
1314 /*******************************************************************************
1315 **
1316 ** Function BTA_DmSetBleScanParams
1317 **
1318 ** Description This function is called to set scan parameters
1319 **
1320 ** Parameters: client_if - Client IF
1321 ** scan_interval - scan interval
1322 ** scan_window - scan window
1323 ** scan_mode - scan mode
1324 ** scan_param_setup_status_cback - Set scan param status callback
1325 **
1326 ** Returns void
1327 **
1328 *******************************************************************************/
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)1329 void BTA_DmSetBleScanParams(tGATT_IF client_if, UINT32 scan_interval,
1330 UINT32 scan_window, tBLE_SCAN_MODE scan_mode,
1331 tBLE_SCAN_PARAM_SETUP_CBACK scan_param_setup_cback)
1332 {
1333 tBTA_DM_API_BLE_SCAN_PARAMS *p_msg;
1334
1335 if ((p_msg = (tBTA_DM_API_BLE_SCAN_PARAMS *)osi_malloc(sizeof(tBTA_DM_API_BLE_SCAN_PARAMS))) != NULL) {
1336 memset(p_msg, 0, sizeof(tBTA_DM_API_BLE_SCAN_PARAMS));
1337 p_msg->hdr.event = BTA_DM_API_BLE_SCAN_PARAM_EVT;
1338 p_msg->client_if = client_if;
1339 p_msg->scan_int = scan_interval;
1340 p_msg->scan_window = scan_window;
1341 p_msg->scan_mode = scan_mode;
1342 p_msg->scan_param_setup_cback = scan_param_setup_cback;
1343
1344 bta_sys_sendmsg(p_msg);
1345 }
1346 }
1347
1348
1349 /*******************************************************************************
1350 **
1351 ** Function BTA_DmSetBleScanFilterParams
1352 **
1353 ** Description This function is called to set scan parameters
1354 **
1355 ** Parameters: client_if - Client IF
1356 ** scan_interval - scan interval
1357 ** scan_window - scan window
1358 ** scan_mode - scan mode
1359 ** scan_duplicate_filter - scan duplicate filter
1360 ** scan_param_setup_status_cback - Set scan param status callback
1361 **
1362 ** Returns void
1363 **
1364 *******************************************************************************/
BTA_DmSetBleScanFilterParams(tGATT_IF client_if,UINT32 scan_interval,UINT32 scan_window,tBLE_SCAN_MODE scan_mode,UINT8 scan_fil_poilcy,UINT8 addr_type_own,UINT8 scan_duplicate_filter,tBLE_SCAN_PARAM_SETUP_CBACK scan_param_setup_cback)1365 void BTA_DmSetBleScanFilterParams(tGATT_IF client_if, UINT32 scan_interval,
1366 UINT32 scan_window, tBLE_SCAN_MODE scan_mode, UINT8 scan_fil_poilcy,
1367 UINT8 addr_type_own, UINT8 scan_duplicate_filter, tBLE_SCAN_PARAM_SETUP_CBACK scan_param_setup_cback)
1368 {
1369 tBTA_DM_API_BLE_SCAN_FILTER_PARAMS *p_msg;
1370
1371 if ((p_msg = (tBTA_DM_API_BLE_SCAN_FILTER_PARAMS *)osi_malloc(sizeof(tBTA_DM_API_BLE_SCAN_FILTER_PARAMS))) != NULL) {
1372 memset(p_msg, 0, sizeof(tBTA_DM_API_BLE_SCAN_FILTER_PARAMS));
1373 p_msg->hdr.event = BTA_DM_API_BLE_SCAN_FIL_PARAM_EVT;
1374 p_msg->client_if = client_if;
1375 p_msg->scan_int = scan_interval;
1376 p_msg->scan_window = scan_window;
1377 p_msg->scan_mode = scan_mode;
1378 p_msg->addr_type_own = addr_type_own;
1379 p_msg->scan_duplicate_filter = scan_duplicate_filter;
1380 p_msg->scan_filter_policy = scan_fil_poilcy;
1381 p_msg->scan_param_setup_cback = scan_param_setup_cback;
1382
1383 bta_sys_sendmsg(p_msg);
1384 }
1385
1386
1387 }
1388
1389 /*******************************************************************************
1390 **
1391 ** Function BTA_DmSetBleAdvParams
1392 **
1393 ** Description This function sets the advertising parameters BLE functionality.
1394 ** It is to be called when device act in peripheral or broadcaster
1395 ** role.
1396 **
1397 **
1398 ** Returns void
1399 **
1400 *******************************************************************************/
BTA_DmSetBleAdvParams(UINT16 adv_int_min,UINT16 adv_int_max,tBLE_BD_ADDR * p_dir_bda)1401 void BTA_DmSetBleAdvParams (UINT16 adv_int_min, UINT16 adv_int_max,
1402 tBLE_BD_ADDR *p_dir_bda)
1403 {
1404 #if BLE_INCLUDED == TRUE
1405 tBTA_DM_API_BLE_ADV_PARAMS *p_msg;
1406
1407 APPL_TRACE_API ("BTA_DmSetBleAdvParam: %d, %d\n", adv_int_min, adv_int_max);
1408
1409 if ((p_msg = (tBTA_DM_API_BLE_ADV_PARAMS *) osi_malloc(sizeof(tBTA_DM_API_BLE_ADV_PARAMS)
1410 + sizeof(tBLE_BD_ADDR))) != NULL) {
1411 memset(p_msg, 0, sizeof(tBTA_DM_API_BLE_ADV_PARAMS) + sizeof(tBLE_BD_ADDR));
1412
1413 p_msg->hdr.event = BTA_DM_API_BLE_ADV_PARAM_EVT;
1414
1415 p_msg->adv_int_min = adv_int_min;
1416 p_msg->adv_int_max = adv_int_max;
1417
1418 if (p_dir_bda != NULL) {
1419 p_msg->p_dir_bda = (tBLE_BD_ADDR *)(p_msg + 1);
1420 memcpy(p_msg->p_dir_bda, p_dir_bda, sizeof(tBLE_BD_ADDR));
1421 }
1422
1423 bta_sys_sendmsg(p_msg);
1424 }
1425 #endif
1426 }
1427
BTA_DmSetBleAdvParamsAll(UINT16 adv_int_min,UINT16 adv_int_max,UINT8 adv_type,tBLE_ADDR_TYPE addr_type_own,tBTM_BLE_ADV_CHNL_MAP chnl_map,tBTM_BLE_AFP adv_fil_pol,tBLE_BD_ADDR * p_dir_bda,tBTA_START_ADV_CMPL_CBACK p_start_adv_cb)1428 void BTA_DmSetBleAdvParamsAll (UINT16 adv_int_min, UINT16 adv_int_max,
1429 UINT8 adv_type, tBLE_ADDR_TYPE addr_type_own,
1430 tBTM_BLE_ADV_CHNL_MAP chnl_map, tBTM_BLE_AFP adv_fil_pol,
1431 tBLE_BD_ADDR *p_dir_bda, tBTA_START_ADV_CMPL_CBACK p_start_adv_cb)
1432 {
1433 #if BLE_INCLUDED == TRUE
1434 tBTA_DM_API_BLE_ADV_PARAMS_ALL *p_msg;
1435
1436 APPL_TRACE_API ("BTA_DmSetBleAdvParamsAll: %d, %d\n", adv_int_min, adv_int_max);
1437 APPL_TRACE_API ("adv_type = %d, addr_type_own = %d, chnl_map = %d, adv_fil_pol = %d\n",
1438 adv_type, addr_type_own, chnl_map, adv_fil_pol);
1439 if ((p_msg = (tBTA_DM_API_BLE_ADV_PARAMS_ALL *) osi_malloc(sizeof(tBTA_DM_API_BLE_ADV_PARAMS_ALL)
1440 + sizeof(tBLE_BD_ADDR))) != NULL) {
1441 memset(p_msg, 0, sizeof(tBTA_DM_API_BLE_ADV_PARAMS_ALL));
1442
1443 p_msg->hdr.event = BTA_DM_API_BLE_ADV_PARAM_All_EVT;
1444
1445 p_msg->adv_int_min = adv_int_min;
1446 p_msg->adv_int_max = adv_int_max;
1447 p_msg->adv_type = adv_type;
1448 p_msg->addr_type_own = addr_type_own;
1449 p_msg->channel_map = chnl_map;
1450 p_msg->adv_filter_policy = adv_fil_pol;
1451 p_msg->p_start_adv_cback = p_start_adv_cb;
1452 if (p_dir_bda != NULL) {
1453 p_msg->p_dir_bda = (tBLE_BD_ADDR *)(p_msg + 1);
1454 memcpy(p_msg->p_dir_bda, p_dir_bda, sizeof(tBLE_BD_ADDR));
1455 }
1456
1457 bta_sys_sendmsg(p_msg);
1458 }
1459 #endif
1460 }
1461 #endif ///BLE_INCLUDED == TRUE
1462
1463
1464 /*******************************************************************************
1465 ** BLE ADV data management API
1466 ********************************************************************************/
1467
1468 #if BLE_INCLUDED == TRUE
1469 /*******************************************************************************
1470 **
1471 ** Function BTA_DmBleSetAdvConfig
1472 **
1473 ** Description This function is called to override the BTA default ADV parameters.
1474 **
1475 ** Parameters data_mask: adv data mask.
1476 ** p_adv_cfg: Pointer to User defined ADV data structure. This
1477 ** memory space can not be freed until p_adv_data_cback
1478 ** is received.
1479 ** p_adv_data_cback: set adv data complete callback.
1480 **
1481 ** Returns None
1482 **
1483 *******************************************************************************/
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)1484 void BTA_DmBleSetAdvConfig (tBTA_BLE_AD_MASK data_mask, tBTA_BLE_ADV_DATA *p_adv_cfg,
1485 tBTA_SET_ADV_DATA_CMPL_CBACK *p_adv_data_cback)
1486 {
1487 tBTA_DM_API_SET_ADV_CONFIG *p_msg;
1488
1489 if ((p_msg = (tBTA_DM_API_SET_ADV_CONFIG *)
1490 osi_malloc(sizeof(tBTA_DM_API_SET_ADV_CONFIG))) != NULL) {
1491 p_msg->hdr.event = BTA_DM_API_BLE_SET_ADV_CONFIG_EVT;
1492 p_msg->data_mask = data_mask;
1493 p_msg->p_adv_data_cback = p_adv_data_cback;
1494 p_msg->p_adv_cfg = p_adv_cfg;
1495
1496 bta_sys_sendmsg(p_msg);
1497 }
1498 }
1499
1500 /*******************************************************************************
1501 **
1502 ** Function BTA_DmBleSetAdvConfigRaw
1503 **
1504 ** Description This function is called to set raw Advertising data
1505 **
1506 ** Parameters p_raw_adv : raw advertising data.
1507 ** raw_adv_len : raw advertising data length.
1508 ** p_adv_data_cback : set adv data complete callback.
1509 **
1510 ** Returns None
1511 **
1512 *******************************************************************************/
BTA_DmBleSetAdvConfigRaw(UINT8 * p_raw_adv,UINT32 raw_adv_len,tBTA_SET_ADV_DATA_CMPL_CBACK * p_adv_data_cback)1513 void BTA_DmBleSetAdvConfigRaw (UINT8 *p_raw_adv, UINT32 raw_adv_len,
1514 tBTA_SET_ADV_DATA_CMPL_CBACK *p_adv_data_cback)
1515 {
1516 tBTA_DM_API_SET_ADV_CONFIG_RAW *p_msg;
1517
1518 if ((p_msg = (tBTA_DM_API_SET_ADV_CONFIG_RAW *)
1519 osi_malloc(sizeof(tBTA_DM_API_SET_ADV_CONFIG_RAW) + raw_adv_len)) != NULL) {
1520 p_msg->hdr.event = BTA_DM_API_BLE_SET_ADV_CONFIG_RAW_EVT;
1521 p_msg->p_adv_data_cback = p_adv_data_cback;
1522 p_msg->p_raw_adv = (UINT8 *)(p_msg + 1);
1523 memcpy(p_msg->p_raw_adv, p_raw_adv, raw_adv_len);
1524 p_msg->raw_adv_len = raw_adv_len;
1525
1526 bta_sys_sendmsg(p_msg);
1527 }
1528 }
1529
1530 /*******************************************************************************
1531 **
1532 ** Function BTA_DmBleSetLongAdv
1533 **
1534 ** Description This function is called to set long Advertising data
1535 **
1536 ** Parameters adv_data : long advertising data.
1537 ** adv_data_len : long advertising data length.
1538 ** p_adv_data_cback : set long adv data complete callback.
1539 **
1540 ** Returns None
1541 **
1542 *******************************************************************************/
BTA_DmBleSetLongAdv(UINT8 * adv_data,UINT32 adv_data_len,tBTA_SET_ADV_DATA_CMPL_CBACK * p_adv_data_cback)1543 void BTA_DmBleSetLongAdv (UINT8 *adv_data, UINT32 adv_data_len,
1544 tBTA_SET_ADV_DATA_CMPL_CBACK *p_adv_data_cback)
1545 {
1546 tBTA_DM_API_SET_LONG_ADV *p_msg;
1547
1548 if ((p_msg = (tBTA_DM_API_SET_LONG_ADV *)
1549 osi_malloc(sizeof(tBTA_DM_API_SET_LONG_ADV))) != NULL) {
1550 p_msg->hdr.event = BTA_DM_API_BLE_SET_LONG_ADV_EVT;
1551 p_msg->p_adv_data_cback = p_adv_data_cback;
1552 p_msg->adv_data = adv_data;
1553 p_msg->adv_data_len = adv_data_len;
1554
1555 bta_sys_sendmsg(p_msg);
1556 }
1557 }
1558
1559 /*******************************************************************************
1560 **
1561 ** Function BTA_DmBleSetScanRsp
1562 **
1563 ** Description This function is called to override the BTA scan response.
1564 **
1565 ** Parameters Pointer to User defined ADV data structure
1566 **
1567 ** Returns None
1568 **
1569 *******************************************************************************/
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)1570 extern void BTA_DmBleSetScanRsp (tBTA_BLE_AD_MASK data_mask, tBTA_BLE_ADV_DATA *p_adv_cfg,
1571 tBTA_SET_ADV_DATA_CMPL_CBACK *p_adv_data_cback)
1572 {
1573 tBTA_DM_API_SET_ADV_CONFIG *p_msg;
1574
1575 if ((p_msg = (tBTA_DM_API_SET_ADV_CONFIG *)
1576 osi_malloc(sizeof(tBTA_DM_API_SET_ADV_CONFIG))) != NULL) {
1577 p_msg->hdr.event = BTA_DM_API_BLE_SET_SCAN_RSP_EVT;
1578 p_msg->data_mask = data_mask;
1579 p_msg->p_adv_data_cback = p_adv_data_cback;
1580 p_msg->p_adv_cfg = p_adv_cfg;
1581
1582 bta_sys_sendmsg(p_msg);
1583 }
1584 }
1585
1586 /*******************************************************************************
1587 **
1588 ** Function BTA_DmBleSetScanRspRaw
1589 **
1590 ** Description This function is called to set raw scan response data
1591 **
1592 ** Parameters p_raw_scan_rsp : raw scan_rspertising data.
1593 ** raw_scan_rsp_len : raw scan_rspertising data length.
1594 ** p_scan_rsp_data_cback : set scan_rsp data complete callback.
1595 **
1596 ** Returns None
1597 **
1598 *******************************************************************************/
BTA_DmBleSetScanRspRaw(UINT8 * p_raw_scan_rsp,UINT32 raw_scan_rsp_len,tBTA_SET_ADV_DATA_CMPL_CBACK * p_scan_rsp_data_cback)1599 void BTA_DmBleSetScanRspRaw (UINT8 *p_raw_scan_rsp, UINT32 raw_scan_rsp_len,
1600 tBTA_SET_ADV_DATA_CMPL_CBACK *p_scan_rsp_data_cback)
1601 {
1602 tBTA_DM_API_SET_ADV_CONFIG_RAW *p_msg;
1603
1604 if ((p_msg = (tBTA_DM_API_SET_ADV_CONFIG_RAW *)
1605 osi_malloc(sizeof(tBTA_DM_API_SET_ADV_CONFIG_RAW) + raw_scan_rsp_len)) != NULL) {
1606 p_msg->hdr.event = BTA_DM_API_BLE_SET_SCAN_RSP_RAW_EVT;
1607 p_msg->p_adv_data_cback = p_scan_rsp_data_cback;
1608 p_msg->p_raw_adv = (UINT8 *)(p_msg + 1);
1609 memcpy(p_msg->p_raw_adv, p_raw_scan_rsp, raw_scan_rsp_len);
1610 p_msg->raw_adv_len = raw_scan_rsp_len;
1611
1612 bta_sys_sendmsg(p_msg);
1613 }
1614 }
1615
1616 /*******************************************************************************
1617 **
1618 ** Function BTA_DmUpdateDuplicateExceptionalList
1619 **
1620 ** Description This function is called to update duplicate scan exceptional list
1621 **
1622 ** Parameters subcode : add, remove or clean duplicate scan exceptional list.
1623 ** type : device info type.
1624 ** device_info: device info
1625 ** p_update_duplicate_ignore_list_cback : update complete callback.
1626 **
1627 ** Returns None
1628 **
1629 *******************************************************************************/
BTA_DmUpdateDuplicateExceptionalList(UINT8 subcode,UINT32 type,BD_ADDR device_info,tBTA_UPDATE_DUPLICATE_EXCEPTIONAL_LIST_CMPL_CBACK p_update_duplicate_exceptional_list_cback)1630 void BTA_DmUpdateDuplicateExceptionalList(UINT8 subcode, UINT32 type, BD_ADDR device_info, tBTA_UPDATE_DUPLICATE_EXCEPTIONAL_LIST_CMPL_CBACK p_update_duplicate_exceptional_list_cback)
1631 {
1632 tBTA_DM_API_UPDATE_DUPLICATE_EXCEPTIONAL_LIST *p_msg;
1633 if ((p_msg = (tBTA_DM_API_UPDATE_DUPLICATE_EXCEPTIONAL_LIST *)osi_malloc(sizeof(tBTA_DM_API_UPDATE_DUPLICATE_EXCEPTIONAL_LIST))) != NULL) {
1634 p_msg->hdr.event = BTA_DM_API_UPDATE_DUPLICATE_EXCEPTIONAL_LIST_EVT;
1635 p_msg->subcode = subcode;
1636 p_msg->type = type;
1637 p_msg->exceptional_list_cb = p_update_duplicate_exceptional_list_cback;
1638 memcpy(p_msg->device_info, device_info, sizeof(BD_ADDR));
1639
1640 bta_sys_sendmsg(p_msg);
1641 }
1642 }
1643
1644 /*******************************************************************************
1645 **
1646 ** Function BTA_DmBleSetStorageParams
1647 **
1648 ** Description This function is called to override the BTA scan response.
1649 **
1650 ** Parameters batch_scan_full_max -Max storage space (in %) allocated to full scanning
1651 ** batch_scan_trunc_max -Max storage space (in %) allocated to truncated scanning
1652 ** batch_scan_notify_threshold -Setup notification level based on total space
1653 ** p_setup_cback - Setup callback pointer
1654 ** p_thres_cback - Threshold callback pointer
1655 ** p_rep_cback - Reports callback pointer
1656 ** ref_value - Ref value
1657 **
1658 ** Returns None
1659 **
1660 *******************************************************************************/
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)1661 extern void BTA_DmBleSetStorageParams(UINT8 batch_scan_full_max,
1662 UINT8 batch_scan_trunc_max,
1663 UINT8 batch_scan_notify_threshold,
1664 tBTA_BLE_SCAN_SETUP_CBACK *p_setup_cback,
1665 tBTA_BLE_SCAN_THRESHOLD_CBACK *p_thres_cback,
1666 tBTA_BLE_SCAN_REP_CBACK *p_rep_cback,
1667 tBTA_DM_BLE_REF_VALUE ref_value)
1668 {
1669 tBTA_DM_API_SET_STORAGE_CONFIG *p_msg;
1670 bta_dm_cb.p_setup_cback = p_setup_cback;
1671 if ((p_msg = (tBTA_DM_API_SET_STORAGE_CONFIG *)
1672 osi_malloc(sizeof(tBTA_DM_API_SET_STORAGE_CONFIG))) != NULL) {
1673 p_msg->hdr.event = BTA_DM_API_BLE_SETUP_STORAGE_EVT;
1674 p_msg->p_setup_cback = bta_ble_scan_setup_cb;
1675 p_msg->p_thres_cback = p_thres_cback;
1676 p_msg->p_read_rep_cback = p_rep_cback;
1677 p_msg->ref_value = ref_value;
1678 p_msg->batch_scan_full_max = batch_scan_full_max;
1679 p_msg->batch_scan_trunc_max = batch_scan_trunc_max;
1680 p_msg->batch_scan_notify_threshold = batch_scan_notify_threshold;
1681 bta_sys_sendmsg(p_msg);
1682 }
1683 }
1684
1685 /*******************************************************************************
1686 **
1687 ** Function BTA_DmBleEnableBatchScan
1688 **
1689 ** Description This function is called to enable the batch scan
1690 **
1691 ** Parameters scan_mode -Batch scan mode
1692 ** scan_interval - Scan interval
1693 ** scan_window - Scan window
1694 ** discard_rule -Discard rules
1695 ** addr_type - Address type
1696 ** ref_value - Reference value
1697 **
1698 ** Returns None
1699 **
1700 *******************************************************************************/
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)1701 extern void BTA_DmBleEnableBatchScan(tBTA_BLE_BATCH_SCAN_MODE scan_mode,
1702 UINT32 scan_interval, UINT32 scan_window,
1703 tBTA_BLE_DISCARD_RULE discard_rule,
1704 tBLE_ADDR_TYPE addr_type,
1705 tBTA_DM_BLE_REF_VALUE ref_value)
1706 {
1707 tBTA_DM_API_ENABLE_SCAN *p_msg;
1708
1709 if ((p_msg = (tBTA_DM_API_ENABLE_SCAN *) osi_malloc(sizeof(tBTA_DM_API_ENABLE_SCAN))) != NULL) {
1710 p_msg->hdr.event = BTA_DM_API_BLE_ENABLE_BATCH_SCAN_EVT;
1711 p_msg->scan_mode = scan_mode;
1712 p_msg->scan_int = scan_interval;
1713 p_msg->scan_window = scan_window;
1714 p_msg->discard_rule = discard_rule;
1715 p_msg->addr_type = addr_type;
1716 p_msg->ref_value = ref_value;
1717 bta_sys_sendmsg(p_msg);
1718 }
1719 }
1720
1721 /*******************************************************************************
1722 **
1723 ** Function BTA_DmBleDisableBatchScan
1724 **
1725 ** Description This function is called to disable the batch scan
1726 **
1727 ** Parameters ref_value - Reference value
1728 **
1729 ** Returns None
1730 **
1731 *******************************************************************************/
BTA_DmBleDisableBatchScan(tBTA_DM_BLE_REF_VALUE ref_value)1732 extern void BTA_DmBleDisableBatchScan(tBTA_DM_BLE_REF_VALUE ref_value)
1733 {
1734 tBTA_DM_API_DISABLE_SCAN *p_msg;
1735
1736 if ((p_msg = (tBTA_DM_API_DISABLE_SCAN *)
1737 osi_malloc(sizeof(tBTA_DM_API_DISABLE_SCAN))) != NULL) {
1738 p_msg->hdr.event = BTA_DM_API_BLE_DISABLE_BATCH_SCAN_EVT;
1739 p_msg->ref_value = ref_value;
1740 bta_sys_sendmsg(p_msg);
1741 }
1742 }
1743
1744 /*******************************************************************************
1745 **
1746 ** Function BTA_DmBleReadScanReports
1747 **
1748 ** Description This function is called to read scan reports
1749 **
1750 ** Parameters scan_type -Batch scan mode
1751 ** ref_value - Reference value
1752 **
1753 ** Returns None
1754 **
1755 *******************************************************************************/
BTA_DmBleReadScanReports(tBTA_BLE_BATCH_SCAN_MODE scan_type,tBTA_DM_BLE_REF_VALUE ref_value)1756 extern void BTA_DmBleReadScanReports(tBTA_BLE_BATCH_SCAN_MODE scan_type,
1757 tBTA_DM_BLE_REF_VALUE ref_value)
1758 {
1759 tBTA_DM_API_READ_SCAN_REPORTS *p_msg;
1760
1761 if ((p_msg = (tBTA_DM_API_READ_SCAN_REPORTS *)
1762 osi_malloc(sizeof(tBTA_DM_API_READ_SCAN_REPORTS))) != NULL) {
1763 p_msg->hdr.event = BTA_DM_API_BLE_READ_SCAN_REPORTS_EVT;
1764 p_msg->scan_type = scan_type;
1765 p_msg->ref_value = ref_value;
1766 bta_sys_sendmsg(p_msg);
1767 }
1768 }
1769
1770 /*******************************************************************************
1771 **
1772 ** Function BTA_DmBleTrackAdvertiser
1773 **
1774 ** Description This function is called to track advertiser
1775 **
1776 ** Parameters ref_value - Reference value
1777 ** p_track_adv_cback - Track ADV callback
1778 **
1779 ** Returns None
1780 **
1781 *******************************************************************************/
BTA_DmBleTrackAdvertiser(tBTA_DM_BLE_REF_VALUE ref_value,tBTA_BLE_TRACK_ADV_CBACK * p_track_adv_cback)1782 extern void BTA_DmBleTrackAdvertiser(tBTA_DM_BLE_REF_VALUE ref_value,
1783 tBTA_BLE_TRACK_ADV_CBACK *p_track_adv_cback)
1784 {
1785 tBTA_DM_API_TRACK_ADVERTISER *p_msg;
1786
1787 if ((p_msg = (tBTA_DM_API_TRACK_ADVERTISER *)
1788 osi_malloc(sizeof(tBTA_DM_API_TRACK_ADVERTISER))) != NULL) {
1789 p_msg->hdr.event = BTA_DM_API_BLE_TRACK_ADVERTISER_EVT;
1790 p_msg->p_track_adv_cback = p_track_adv_cback;
1791 p_msg->ref_value = ref_value;
1792 bta_sys_sendmsg(p_msg);
1793 }
1794 }
1795
1796 #endif
1797
1798 /*******************************************************************************
1799 ** BLE ADV data management API
1800 ********************************************************************************/
1801 #if BLE_INCLUDED == TRUE
1802
1803 /*******************************************************************************
1804 **
1805 ** Function BTA_DmBleBroadcast
1806 **
1807 ** Description This function starts or stops LE broadcasting.
1808 **
1809 ** Parameters start: start or stop broadcast.
1810 **
1811 ** Returns None
1812 **
1813 *******************************************************************************/
BTA_DmBleBroadcast(BOOLEAN start,tBTA_START_STOP_ADV_CMPL_CBACK * p_start_stop_adv_cb)1814 extern void BTA_DmBleBroadcast (BOOLEAN start, tBTA_START_STOP_ADV_CMPL_CBACK *p_start_stop_adv_cb)
1815 {
1816 tBTA_DM_API_BLE_OBSERVE *p_msg;
1817
1818 APPL_TRACE_API("BTA_DmBleBroadcast: start = %d \n", start);
1819
1820 if ((p_msg = (tBTA_DM_API_BLE_OBSERVE *) osi_malloc(sizeof(tBTA_DM_API_BLE_OBSERVE))) != NULL) {
1821 memset(p_msg, 0, sizeof(tBTA_DM_API_BLE_OBSERVE));
1822
1823 p_msg->hdr.event = BTA_DM_API_BLE_BROADCAST_EVT;
1824 p_msg->start = start;
1825 if (start == FALSE){
1826 p_msg->p_stop_adv_cback= p_start_stop_adv_cb;
1827 }
1828
1829 bta_sys_sendmsg(p_msg);
1830 }
1831 }
1832
1833 /*******************************************************************************
1834 **
1835 ** Function BTA_DmBleClearAdv
1836 **
1837 ** Description This function is called to clear Advertising
1838 **
1839 ** Parameters p_adv_data_cback : clear adv complete callback.
1840 **
1841 ** Returns None
1842 **
1843 *******************************************************************************/
BTA_DmBleClearAdv(tBTA_CLEAR_ADV_CMPL_CBACK * p_clear_adv_cback)1844 void BTA_DmBleClearAdv (tBTA_CLEAR_ADV_CMPL_CBACK *p_clear_adv_cback)
1845 {
1846 tBTA_DM_API_CLEAR_ADV *p_msg;
1847
1848 if ((p_msg = (tBTA_DM_API_CLEAR_ADV *)
1849 osi_malloc(sizeof(tBTA_DM_API_CLEAR_ADV))) != NULL) {
1850 p_msg->hdr.event = BTA_DM_API_BLE_CLEAR_ADV_EVT;
1851 p_msg->p_clear_adv_cback = p_clear_adv_cback;
1852
1853 bta_sys_sendmsg(p_msg);
1854 }
1855 }
1856 #endif
1857 /*******************************************************************************
1858 **
1859 ** Function BTA_DmBleSetBgConnType
1860 **
1861 ** Description This function is called to set BLE connectable mode for a
1862 ** peripheral device.
1863 **
1864 ** Parameters bg_conn_type: it can be auto connection, or selective connection.
1865 ** p_select_cback: callback function when selective connection procedure
1866 ** is being used.
1867 **
1868 ** Returns void
1869 **
1870 *******************************************************************************/
BTA_DmBleSetBgConnType(tBTA_DM_BLE_CONN_TYPE bg_conn_type,tBTA_DM_BLE_SEL_CBACK * p_select_cback)1871 void BTA_DmBleSetBgConnType(tBTA_DM_BLE_CONN_TYPE bg_conn_type, tBTA_DM_BLE_SEL_CBACK *p_select_cback)
1872 {
1873 #if BLE_INCLUDED == TRUE
1874 tBTA_DM_API_BLE_SET_BG_CONN_TYPE *p_msg;
1875
1876 if ((p_msg = (tBTA_DM_API_BLE_SET_BG_CONN_TYPE *) osi_malloc(sizeof(tBTA_DM_API_BLE_SET_BG_CONN_TYPE))) != NULL) {
1877 memset(p_msg, 0, sizeof(tBTA_DM_API_BLE_SET_BG_CONN_TYPE));
1878
1879 p_msg->hdr.event = BTA_DM_API_BLE_SET_BG_CONN_TYPE;
1880 p_msg->bg_conn_type = bg_conn_type;
1881 p_msg->p_select_cback = p_select_cback;
1882
1883 bta_sys_sendmsg(p_msg);
1884 }
1885 #endif
1886 }
1887
1888 /*******************************************************************************
1889 **
1890 ** Function bta_dm_discover_send_msg
1891 **
1892 ** Description This function send discover message to BTA task.
1893 **
1894 ** Returns void
1895 **
1896 *******************************************************************************/
1897 #if BLE_INCLUDED == TRUE && BTA_GATT_INCLUDED == TRUE && SDP_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)1898 static void bta_dm_discover_send_msg(BD_ADDR bd_addr, tBTA_SERVICE_MASK_EXT *p_services,
1899 tBTA_DM_SEARCH_CBACK *p_cback, BOOLEAN sdp_search,
1900 tBTA_TRANSPORT transport)
1901 {
1902 tBTA_DM_API_DISCOVER *p_msg;
1903 UINT16 len = p_services ? (sizeof(tBTA_DM_API_DISCOVER) +
1904 sizeof(tBT_UUID) * p_services->num_uuid) :
1905 sizeof(tBTA_DM_API_DISCOVER);
1906
1907 if ((p_msg = (tBTA_DM_API_DISCOVER *) osi_malloc(len)) != NULL) {
1908 memset(p_msg, 0, len);
1909
1910 p_msg->hdr.event = BTA_DM_API_DISCOVER_EVT;
1911 bdcpy(p_msg->bd_addr, bd_addr);
1912 p_msg->p_cback = p_cback;
1913 p_msg->sdp_search = sdp_search;
1914 p_msg->transport = transport;
1915
1916 if (p_services != NULL) {
1917 #if BLE_INCLUDED == TRUE && BTA_GATT_INCLUDED == TRUE
1918 p_msg->services = p_services->srvc_mask;
1919 p_msg->num_uuid = p_services->num_uuid;
1920 if (p_services->num_uuid != 0) {
1921 p_msg->p_uuid = (tBT_UUID *)(p_msg + 1);
1922 memcpy(p_msg->p_uuid, p_services->p_uuid, sizeof(tBT_UUID) * p_services->num_uuid);
1923 }
1924 #endif
1925 }
1926
1927 bta_sys_sendmsg(p_msg);
1928 }
1929 }
1930 #endif
1931 /*******************************************************************************
1932 **
1933 ** Function BTA_DmDiscoverByTransport
1934 **
1935 ** Description This function does service discovery on particular transport
1936 ** for services of a
1937 ** peer device. When services.num_uuid is 0, it indicates all
1938 ** GATT based services are to be searched; otherwise a list of
1939 ** UUID of interested services should be provided through
1940 ** p_services->p_uuid.
1941 **
1942 **
1943 **
1944 ** Returns void
1945 **
1946 *******************************************************************************/
BTA_DmDiscoverByTransport(BD_ADDR bd_addr,tBTA_SERVICE_MASK_EXT * p_services,tBTA_DM_SEARCH_CBACK * p_cback,BOOLEAN sdp_search,tBTA_TRANSPORT transport)1947 void BTA_DmDiscoverByTransport(BD_ADDR bd_addr, tBTA_SERVICE_MASK_EXT *p_services,
1948 tBTA_DM_SEARCH_CBACK *p_cback, BOOLEAN sdp_search,
1949 tBTA_TRANSPORT transport)
1950 {
1951 #if BLE_INCLUDED == TRUE && BTA_GATT_INCLUDED == TRUE && SDP_INCLUDED == TRUE
1952 bta_dm_discover_send_msg(bd_addr, p_services, p_cback, sdp_search, transport);
1953 #endif
1954 }
1955
1956
1957 /*******************************************************************************
1958 **
1959 ** Function BTA_DmDiscoverExt
1960 **
1961 ** Description This function does service discovery for services of a
1962 ** peer device. When services.num_uuid is 0, it indicates all
1963 ** GATT based services are to be searched; other wise a list of
1964 ** UUID of interested services should be provided through
1965 ** p_services->p_uuid.
1966 **
1967 **
1968 **
1969 ** Returns void
1970 **
1971 *******************************************************************************/
BTA_DmDiscoverExt(BD_ADDR bd_addr,tBTA_SERVICE_MASK_EXT * p_services,tBTA_DM_SEARCH_CBACK * p_cback,BOOLEAN sdp_search)1972 void BTA_DmDiscoverExt(BD_ADDR bd_addr, tBTA_SERVICE_MASK_EXT *p_services,
1973 tBTA_DM_SEARCH_CBACK *p_cback, BOOLEAN sdp_search)
1974 {
1975 #if BLE_INCLUDED == TRUE && BTA_GATT_INCLUDED == TRUE && SDP_INCLUDED == TRUE
1976 bta_dm_discover_send_msg(bd_addr, p_services, p_cback, sdp_search, BTA_TRANSPORT_UNKNOWN);
1977 #endif
1978
1979 }
1980
1981 /*******************************************************************************
1982 **
1983 ** Function BTA_DmSearchExt
1984 **
1985 ** Description This function searches for peer Bluetooth devices. It performs
1986 ** an inquiry and gets the remote name for devices. Service
1987 ** discovery is done if services is non zero
1988 **
1989 ** Parameters p_dm_inq: inquiry conditions
1990 ** p_services: if service is not empty, service discovery will be done.
1991 ** for all GATT based service condition, put num_uuid, and
1992 ** p_uuid is the pointer to the list of UUID values.
1993 ** p_cback: callback function when search is completed.
1994 **
1995 **
1996 **
1997 ** Returns void
1998 **
1999 *******************************************************************************/
BTA_DmSearchExt(tBTA_DM_INQ * p_dm_inq,tBTA_SERVICE_MASK_EXT * p_services,tBTA_DM_SEARCH_CBACK * p_cback)2000 void BTA_DmSearchExt(tBTA_DM_INQ *p_dm_inq, tBTA_SERVICE_MASK_EXT *p_services, tBTA_DM_SEARCH_CBACK *p_cback)
2001 {
2002 #if BLE_INCLUDED == TRUE && BTA_GATT_INCLUDED == TRUE
2003 tBTA_DM_API_SEARCH *p_msg;
2004 UINT16 len = p_services ? (sizeof(tBTA_DM_API_SEARCH) + sizeof(tBT_UUID) * p_services->num_uuid) :
2005 sizeof(tBTA_DM_API_SEARCH);
2006
2007 if ((p_msg = (tBTA_DM_API_SEARCH *) osi_malloc(len)) != NULL) {
2008 memset(p_msg, 0, len);
2009
2010 p_msg->hdr.event = BTA_DM_API_SEARCH_EVT;
2011 memcpy(&p_msg->inq_params, p_dm_inq, sizeof(tBTA_DM_INQ));
2012 p_msg->p_cback = p_cback;
2013 p_msg->rs_res = BTA_DM_RS_NONE;
2014
2015
2016 if (p_services != NULL) {
2017 p_msg->services = p_services->srvc_mask;
2018 p_msg->num_uuid = p_services->num_uuid;
2019
2020 if (p_services->num_uuid != 0) {
2021 p_msg->p_uuid = (tBT_UUID *)(p_msg + 1);
2022 memcpy(p_msg->p_uuid, p_services->p_uuid, sizeof(tBT_UUID) * p_services->num_uuid);
2023 } else {
2024 p_msg->p_uuid = NULL;
2025 }
2026 }
2027
2028 bta_sys_sendmsg(p_msg);
2029 }
2030 #else
2031 UNUSED(p_dm_inq);
2032 UNUSED(p_services);
2033 UNUSED(p_cback);
2034 #endif
2035 }
2036 /*******************************************************************************
2037 **
2038 ** Function BTA_DmBleUpdateConnectionParam
2039 **
2040 ** Description Update connection parameters, can only be used when connection is up.
2041 **
2042 ** Parameters: bd_addr - BD address of the peer
2043 ** min_int - minimum connection interval, [0x0004~ 0x4000]
2044 ** max_int - maximum connection interval, [0x0004~ 0x4000]
2045 ** latency - slave latency [0 ~ 500]
2046 ** timeout - supervision timeout [0x000a ~ 0xc80]
2047 **
2048 ** Returns void
2049 **
2050 *******************************************************************************/
BTA_DmBleUpdateConnectionParam(BD_ADDR bd_addr,UINT16 min_int,UINT16 max_int,UINT16 latency,UINT16 timeout)2051 void BTA_DmBleUpdateConnectionParam(BD_ADDR bd_addr, UINT16 min_int,
2052 UINT16 max_int, UINT16 latency,
2053 UINT16 timeout)
2054 {
2055 #if BLE_INCLUDED == TRUE
2056 tBTA_DM_API_UPDATE_CONN_PARAM *p_msg;
2057
2058 p_msg = (tBTA_DM_API_UPDATE_CONN_PARAM *) osi_malloc(sizeof(tBTA_DM_API_UPDATE_CONN_PARAM));
2059 if (p_msg != NULL) {
2060 memset(p_msg, 0, sizeof(tBTA_DM_API_UPDATE_CONN_PARAM));
2061
2062 p_msg->hdr.event = BTA_DM_API_UPDATE_CONN_PARAM_EVT;
2063 bdcpy(p_msg->bd_addr, bd_addr);
2064 p_msg->min_int = min_int;
2065 p_msg->max_int = max_int;
2066 p_msg->latency = latency;
2067 p_msg->timeout = timeout;
2068
2069 bta_sys_sendmsg(p_msg);
2070 }
2071 #endif
2072 }
2073
2074 #if BLE_INCLUDED == TRUE
2075 /*******************************************************************************
2076 **
2077 ** Function BTA_DmBleConfigLocalPrivacy
2078 **
2079 ** Description Enable/disable privacy on the local device
2080 **
2081 ** Parameters: privacy_enable - enable/disable privacy on remote device.
2082 **
2083 ** Returns void
2084 **
2085 *******************************************************************************/
BTA_DmBleConfigLocalPrivacy(BOOLEAN privacy_enable,tBTA_SET_LOCAL_PRIVACY_CBACK * set_local_privacy_cback)2086 void BTA_DmBleConfigLocalPrivacy(BOOLEAN privacy_enable, tBTA_SET_LOCAL_PRIVACY_CBACK *set_local_privacy_cback)
2087 {
2088 ///This function used the irk to generate the resolve address
2089 #if BLE_INCLUDED == TRUE && BLE_PRIVACY_SPT == TRUE
2090 tBTA_DM_API_LOCAL_PRIVACY *p_msg;
2091
2092 if ((p_msg = (tBTA_DM_API_LOCAL_PRIVACY *) osi_malloc(sizeof(tBTA_DM_API_ENABLE_PRIVACY))) != NULL) {
2093 memset (p_msg, 0, sizeof(tBTA_DM_API_LOCAL_PRIVACY));
2094
2095 p_msg->hdr.event = BTA_DM_API_LOCAL_PRIVACY_EVT;
2096 p_msg->privacy_enable = privacy_enable;
2097 p_msg->set_local_privacy_cback = set_local_privacy_cback;
2098 bta_sys_sendmsg(p_msg);
2099 }
2100 #else
2101 UNUSED (privacy_enable);
2102 #endif
2103 }
2104
2105 /*******************************************************************************
2106 **
2107 ** Function BTA_DmBleConfigLocalIcon
2108 **
2109 ** Description set gap local icon
2110 **
2111 ** Parameters: icon - appearance value.
2112 **
2113 ** Returns void
2114 **
2115 *******************************************************************************/
BTA_DmBleConfigLocalIcon(uint16_t icon)2116 void BTA_DmBleConfigLocalIcon(uint16_t icon)
2117 {
2118 tBTA_DM_API_LOCAL_ICON *p_msg;
2119
2120 if ((p_msg = (tBTA_DM_API_LOCAL_ICON *) osi_malloc(sizeof(tBTA_DM_API_LOCAL_ICON))) != NULL) {
2121 memset (p_msg, 0, sizeof(tBTA_DM_API_LOCAL_ICON));
2122
2123 p_msg->hdr.event = BTA_DM_API_LOCAL_ICON_EVT;
2124 p_msg->icon = icon;
2125 bta_sys_sendmsg(p_msg);
2126 }
2127 }
2128
2129 /*******************************************************************************
2130 **
2131 ** Function BTA_BleEnableAdvInstance
2132 **
2133 ** Description This function enable a Multi-ADV instance with the specified
2134 ** adv parameters
2135 **
2136 ** Parameters p_params: pointer to the adv parameter structure.
2137 ** p_cback: callback function associated to this adv instance.
2138 ** p_ref: reference data pointer to this adv instance.
2139 **
2140 ** Returns BTA_SUCCESS if command started successfully; otherwise failure.
2141 **
2142 *******************************************************************************/
BTA_BleEnableAdvInstance(tBTA_BLE_ADV_PARAMS * p_params,tBTA_BLE_MULTI_ADV_CBACK * p_cback,void * p_ref)2143 void BTA_BleEnableAdvInstance (tBTA_BLE_ADV_PARAMS *p_params,
2144 tBTA_BLE_MULTI_ADV_CBACK *p_cback,
2145 void *p_ref)
2146 {
2147 ///This function just used for vendor debug
2148 tBTA_DM_API_BLE_MULTI_ADV_ENB *p_msg;
2149 UINT16 len = sizeof(tBTA_BLE_ADV_PARAMS) + sizeof(tBTA_DM_API_BLE_MULTI_ADV_ENB);
2150
2151 APPL_TRACE_API ("BTA_BleEnableAdvInstance");
2152
2153 if ((p_msg = (tBTA_DM_API_BLE_MULTI_ADV_ENB *) osi_malloc(len)) != NULL) {
2154 memset(p_msg, 0, sizeof(tBTA_DM_API_BLE_MULTI_ADV_ENB));
2155
2156 p_msg->hdr.event = BTA_DM_API_BLE_MULTI_ADV_ENB_EVT;
2157 p_msg->p_cback = (void *)p_cback;
2158 if (p_params != NULL) {
2159 p_msg->p_params = (void *)(p_msg + 1);
2160 memcpy(p_msg->p_params, p_params, sizeof(tBTA_BLE_ADV_PARAMS));
2161 }
2162 p_msg->p_ref = p_ref;
2163
2164 bta_sys_sendmsg(p_msg);
2165 }
2166 }
2167
2168 /*******************************************************************************
2169 **
2170 ** Function BTA_BleUpdateAdvInstParam
2171 **
2172 ** Description This function update a Multi-ADV instance with the specified
2173 ** adv parameters.
2174 **
2175 ** Parameters inst_id: Adv instance to update the parameter.
2176 ** p_params: pointer to the adv parameter structure.
2177 **
2178 ** Returns BTA_SUCCESS if command started successfully; otherwise failure.
2179 **
2180 *******************************************************************************/
BTA_BleUpdateAdvInstParam(UINT8 inst_id,tBTA_BLE_ADV_PARAMS * p_params)2181 void BTA_BleUpdateAdvInstParam (UINT8 inst_id, tBTA_BLE_ADV_PARAMS *p_params)
2182 {
2183 ///This function just used for vendor debug
2184 tBTA_DM_API_BLE_MULTI_ADV_PARAM *p_msg;
2185 UINT16 len = sizeof(tBTA_BLE_ADV_PARAMS) + sizeof(tBTA_DM_API_BLE_MULTI_ADV_PARAM);
2186
2187 APPL_TRACE_API ("BTA_BleUpdateAdvInstParam");
2188 if ((p_msg = (tBTA_DM_API_BLE_MULTI_ADV_PARAM *) osi_malloc(len)) != NULL) {
2189 memset(p_msg, 0, sizeof(tBTA_DM_API_BLE_MULTI_ADV_PARAM));
2190 p_msg->hdr.event = BTA_DM_API_BLE_MULTI_ADV_PARAM_UPD_EVT;
2191 p_msg->inst_id = inst_id;
2192 p_msg->p_params = (void *)(p_msg + 1);
2193 memcpy(p_msg->p_params, p_params, sizeof(tBTA_BLE_ADV_PARAMS));
2194
2195 bta_sys_sendmsg(p_msg);
2196 }
2197 }
2198
2199 /*******************************************************************************
2200 **
2201 ** Function BTA_BleCfgAdvInstData
2202 **
2203 ** Description This function configure a Multi-ADV instance with the specified
2204 ** adv data or scan response data.
2205 **
2206 ** Parameter inst_id: Adv instance to configure the adv data or scan response.
2207 ** is_scan_rsp: is the data scan response or adv data.
2208 ** data_mask: adv data type as bit mask.
2209 ** p_data: pointer to the ADV data structure tBTA_BLE_ADV_DATA. This
2210 ** memory space can not be freed until BTA_BLE_MULTI_ADV_DATA_EVT
2211 ** is sent to application.
2212 **
2213 ** Returns BTA_SUCCESS if command started successfully; otherwise failure.
2214 **
2215 *******************************************************************************/
BTA_BleCfgAdvInstData(UINT8 inst_id,BOOLEAN is_scan_rsp,tBTA_BLE_AD_MASK data_mask,tBTA_BLE_ADV_DATA * p_data)2216 void BTA_BleCfgAdvInstData (UINT8 inst_id, BOOLEAN is_scan_rsp,
2217 tBTA_BLE_AD_MASK data_mask,
2218 tBTA_BLE_ADV_DATA *p_data)
2219 {
2220 ///This function just used for vendor debug
2221 tBTA_DM_API_BLE_MULTI_ADV_DATA *p_msg;
2222 UINT16 len = sizeof(tBTA_DM_API_BLE_MULTI_ADV_DATA) ;
2223
2224 APPL_TRACE_API ("BTA_BleCfgAdvInstData");
2225
2226 if ((p_msg = (tBTA_DM_API_BLE_MULTI_ADV_DATA *) osi_malloc(len)) != NULL) {
2227 memset(p_msg, 0, len);
2228 p_msg->hdr.event = BTA_DM_API_BLE_MULTI_ADV_DATA_EVT;
2229 p_msg->inst_id = inst_id;
2230 p_msg->is_scan_rsp = is_scan_rsp;
2231 p_msg->data_mask = data_mask;
2232 p_msg->p_data = p_data;
2233
2234 bta_sys_sendmsg(p_msg);
2235 }
2236 }
2237
2238 /*******************************************************************************
2239 **
2240 ** Function BTA_BleDisableAdvInstance
2241 **
2242 ** Description This function disable a Multi-ADV instance.
2243 **
2244 ** Parameter inst_id: instance ID to disable.
2245 **
2246 ** Returns BTA_SUCCESS if command started successfully; otherwise failure.
2247 **
2248 *******************************************************************************/
BTA_BleDisableAdvInstance(UINT8 inst_id)2249 void BTA_BleDisableAdvInstance (UINT8 inst_id) //this function just used for vendor debug
2250 {
2251 tBTA_DM_API_BLE_MULTI_ADV_DISABLE *p_msg;
2252
2253 APPL_TRACE_API ("BTA_BleDisableAdvInstance: %d", inst_id);
2254 if ((p_msg = (tBTA_DM_API_BLE_MULTI_ADV_DISABLE *)
2255 osi_malloc(sizeof(tBTA_DM_API_BLE_MULTI_ADV_DISABLE))) != NULL) {
2256 memset(p_msg, 0, sizeof(tBTA_DM_API_BLE_MULTI_ADV_DISABLE));
2257 p_msg->hdr.event = BTA_DM_API_BLE_MULTI_ADV_DISABLE_EVT;
2258 p_msg->inst_id = inst_id;
2259 bta_sys_sendmsg(p_msg);
2260 }
2261 }
2262
2263 /*******************************************************************************
2264 **
2265 ** Function BTA_DmBleCfgFilterCondition
2266 **
2267 ** Description This function is called to configure the adv data payload filter
2268 ** condition.
2269 **
2270 ** Parameters action: to read/write/clear
2271 ** cond_type: filter condition type
2272 ** filt_index - Filter index
2273 ** p_cond: filter condition parameter
2274 ** p_cmpl_back - Command completed callback
2275 ** ref_value - Reference value
2276 **
2277 ** Returns void
2278 **
2279 *******************************************************************************/
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)2280 void BTA_DmBleCfgFilterCondition(tBTA_DM_BLE_SCAN_COND_OP action,
2281 tBTA_DM_BLE_PF_COND_TYPE cond_type,
2282 tBTA_DM_BLE_PF_FILT_INDEX filt_index,
2283 tBTA_DM_BLE_PF_COND_PARAM *p_cond,
2284 tBTA_DM_BLE_PF_CFG_CBACK *p_cmpl_cback,
2285 tBTA_DM_BLE_REF_VALUE ref_value)
2286 {
2287 #if BLE_ANDROID_CONTROLLER_SCAN_FILTER == TRUE
2288 tBTA_DM_API_CFG_FILTER_COND *p_msg;
2289 APPL_TRACE_API ("BTA_DmBleCfgFilterCondition: %d, %d", action, cond_type);
2290
2291 UINT16 len = sizeof(tBTA_DM_API_CFG_FILTER_COND) +
2292 sizeof(tBTA_DM_BLE_PF_COND_PARAM);
2293 UINT8 *p;
2294
2295 if (NULL != p_cond) {
2296 switch (cond_type) {
2297 case BTA_DM_BLE_PF_SRVC_DATA_PATTERN:
2298 case BTA_DM_BLE_PF_MANU_DATA:
2299 /* Length of pattern and pattern mask and other elements in */
2300 /* tBTA_DM_BLE_PF_MANU_COND */
2301 len += ((p_cond->manu_data.data_len) * 2) +
2302 sizeof(UINT16) + sizeof(UINT16) + sizeof(UINT8);
2303 break;
2304
2305 case BTA_DM_BLE_PF_LOCAL_NAME:
2306 len += ((p_cond->local_name.data_len) + sizeof(UINT8));
2307 break;
2308
2309 case BTM_BLE_PF_SRVC_UUID:
2310 case BTM_BLE_PF_SRVC_SOL_UUID:
2311 len += sizeof(tBLE_BD_ADDR) + sizeof(tBTA_DM_BLE_PF_COND_MASK);
2312 break;
2313
2314 default:
2315 break;
2316 }
2317 }
2318
2319 if ((p_msg = (tBTA_DM_API_CFG_FILTER_COND *) osi_malloc(len)) != NULL) {
2320 memset (p_msg, 0, len);
2321
2322 p_msg->hdr.event = BTA_DM_API_CFG_FILTER_COND_EVT;
2323 p_msg->action = action;
2324 p_msg->cond_type = cond_type;
2325 p_msg->filt_index = filt_index;
2326 p_msg->p_filt_cfg_cback = p_cmpl_cback;
2327 p_msg->ref_value = ref_value;
2328 if (p_cond) {
2329 p_msg->p_cond_param = (tBTA_DM_BLE_PF_COND_PARAM *)(p_msg + 1);
2330 memcpy(p_msg->p_cond_param, p_cond, sizeof(tBTA_DM_BLE_PF_COND_PARAM));
2331
2332 p = (UINT8 *)(p_msg->p_cond_param + 1);
2333
2334 if (cond_type == BTA_DM_BLE_PF_SRVC_DATA_PATTERN ||
2335 cond_type == BTA_DM_BLE_PF_MANU_DATA) {
2336 p_msg->p_cond_param->manu_data.p_pattern = p;
2337 p_msg->p_cond_param->manu_data.data_len = p_cond->manu_data.data_len;
2338 memcpy(p_msg->p_cond_param->manu_data.p_pattern, p_cond->manu_data.p_pattern,
2339 p_cond->manu_data.data_len);
2340 p += p_cond->manu_data.data_len;
2341
2342 if (cond_type == BTA_DM_BLE_PF_MANU_DATA) {
2343 p_msg->p_cond_param->manu_data.company_id_mask =
2344 p_cond->manu_data.company_id_mask;
2345 if ( p_cond->manu_data.p_pattern_mask != NULL) {
2346 p_msg->p_cond_param->manu_data.p_pattern_mask = p;
2347 memcpy(p_msg->p_cond_param->manu_data.p_pattern_mask,
2348 p_cond->manu_data.p_pattern_mask, p_cond->manu_data.data_len);
2349 }
2350 }
2351 } else if (cond_type == BTA_DM_BLE_PF_LOCAL_NAME) {
2352 p_msg->p_cond_param->local_name.p_data = p;
2353 p_msg->p_cond_param->local_name.data_len =
2354 p_cond->local_name.data_len;
2355 memcpy(p_msg->p_cond_param->local_name.p_data,
2356 p_cond->local_name.p_data, p_cond->local_name.data_len);
2357 } else if ((cond_type == BTM_BLE_PF_SRVC_UUID
2358 || cond_type == BTM_BLE_PF_SRVC_SOL_UUID)) {
2359 if (p_cond->srvc_uuid.p_target_addr != NULL) {
2360 p_msg->p_cond_param->srvc_uuid.p_target_addr = (tBLE_BD_ADDR *)(p);
2361 p_msg->p_cond_param->srvc_uuid.p_target_addr->type =
2362 p_cond->srvc_uuid.p_target_addr->type;
2363 memcpy(p_msg->p_cond_param->srvc_uuid.p_target_addr->bda,
2364 p_cond->srvc_uuid.p_target_addr->bda, BD_ADDR_LEN);
2365 p = (UINT8 *)( p_msg->p_cond_param->srvc_uuid.p_target_addr + 1);
2366 }
2367 if (p_cond->srvc_uuid.p_uuid_mask) {
2368 p_msg->p_cond_param->srvc_uuid.p_uuid_mask = (tBTA_DM_BLE_PF_COND_MASK *)p;
2369 memcpy(p_msg->p_cond_param->srvc_uuid.p_uuid_mask,
2370 p_cond->srvc_uuid.p_uuid_mask, sizeof(tBTA_DM_BLE_PF_COND_MASK));
2371 }
2372 }
2373 }
2374
2375 bta_sys_sendmsg(p_msg);
2376 }
2377 #else
2378 UNUSED(action);
2379 UNUSED(cond_type);
2380 UNUSED(filt_index);
2381 UNUSED(p_cond);
2382 UNUSED(p_cmpl_cback);
2383 UNUSED(ref_value);
2384 #endif
2385 }
2386
2387 /*******************************************************************************
2388 **
2389 ** Function BTA_DmBleScanFilterSetup
2390 **
2391 ** Description This function is called to setup the adv data payload filter param
2392 **
2393 ** Parameters p_target: enable the filter condition on a target device; if NULL
2394 ** filt_index - Filter index
2395 ** p_filt_params -Filter parameters
2396 ** ref_value - Reference value
2397 ** action - Add, delete or clear
2398 ** p_cmpl_back - Command completed callback
2399 **
2400 ** Returns void
2401 **
2402 *******************************************************************************/
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)2403 void BTA_DmBleScanFilterSetup(UINT8 action, tBTA_DM_BLE_PF_FILT_INDEX filt_index,
2404 tBTA_DM_BLE_PF_FILT_PARAMS *p_filt_params,
2405 tBLE_BD_ADDR *p_target,
2406 tBTA_DM_BLE_PF_PARAM_CBACK *p_cmpl_cback,
2407 tBTA_DM_BLE_REF_VALUE ref_value)
2408 {
2409 #if BLE_ANDROID_CONTROLLER_SCAN_FILTER == TRUE
2410 tBTA_DM_API_SCAN_FILTER_PARAM_SETUP *p_msg;
2411 APPL_TRACE_API ("BTA_DmBleScanFilterSetup: %d", action);
2412
2413 UINT16 len = sizeof(tBTA_DM_API_SCAN_FILTER_PARAM_SETUP) + sizeof(tBLE_BD_ADDR);
2414
2415 if ((p_msg = (tBTA_DM_API_SCAN_FILTER_PARAM_SETUP *) osi_malloc(len)) != NULL) {
2416 memset (p_msg, 0, len);
2417
2418 p_msg->hdr.event = BTA_DM_API_SCAN_FILTER_SETUP_EVT;
2419 p_msg->action = action;
2420 p_msg->filt_index = filt_index;
2421 if (p_filt_params) {
2422 memcpy(&p_msg->filt_params, p_filt_params, sizeof(tBTA_DM_BLE_PF_FILT_PARAMS));
2423 }
2424 p_msg->p_filt_param_cback = p_cmpl_cback;
2425 p_msg->ref_value = ref_value;
2426
2427 if (p_target) {
2428 p_msg->p_target = (tBLE_BD_ADDR *)(p_msg + 1);
2429 memcpy(p_msg->p_target, p_target, sizeof(tBLE_BD_ADDR));
2430 }
2431
2432 bta_sys_sendmsg(p_msg);
2433 }
2434 #else
2435 UNUSED(action);
2436 UNUSED(filt_index);
2437 UNUSED(p_filt_params);
2438 UNUSED(p_target);
2439 UNUSED(p_cmpl_cback);
2440 UNUSED(ref_value);
2441 #endif
2442 }
2443
2444 /*******************************************************************************
2445 **
2446 ** Function BTA_DmBleGetEnergyInfo
2447 **
2448 ** Description This function is called to obtain the energy info
2449 **
2450 ** Parameters p_cmpl_cback - Command complete callback
2451 **
2452 ** Returns void
2453 **
2454 *******************************************************************************/
BTA_DmBleGetEnergyInfo(tBTA_BLE_ENERGY_INFO_CBACK * p_cmpl_cback)2455 void BTA_DmBleGetEnergyInfo(tBTA_BLE_ENERGY_INFO_CBACK *p_cmpl_cback)
2456 {
2457 tBTA_DM_API_ENERGY_INFO *p_msg;
2458 APPL_TRACE_API ("BTA_DmBleGetEnergyInfo");
2459
2460 UINT16 len = sizeof(tBTA_DM_API_ENERGY_INFO) + sizeof(tBLE_BD_ADDR);
2461
2462 if ((p_msg = (tBTA_DM_API_ENERGY_INFO *) osi_malloc(len)) != NULL) {
2463 memset (p_msg, 0, len);
2464 p_msg->hdr.event = BTA_DM_API_BLE_ENERGY_INFO_EVT;
2465 p_msg->p_energy_info_cback = p_cmpl_cback;
2466 bta_sys_sendmsg(p_msg);
2467 }
2468 }
2469
2470 /*******************************************************************************
2471 **
2472 ** Function BTA_DmEnableScanFilter
2473 **
2474 ** Description This function is called to enable the adv data payload filter
2475 **
2476 ** Parameters action - enable or disable the APCF feature
2477 ** p_cmpl_cback - Command completed callback
2478 ** ref_value - Reference value
2479 **
2480 ** Returns void
2481 **
2482 *******************************************************************************/
BTA_DmEnableScanFilter(UINT8 action,tBTA_DM_BLE_PF_STATUS_CBACK * p_cmpl_cback,tBTA_DM_BLE_REF_VALUE ref_value)2483 void BTA_DmEnableScanFilter(UINT8 action, tBTA_DM_BLE_PF_STATUS_CBACK *p_cmpl_cback,
2484 tBTA_DM_BLE_REF_VALUE ref_value)
2485 {
2486 #if BLE_ANDROID_CONTROLLER_SCAN_FILTER == TRUE
2487 tBTA_DM_API_ENABLE_SCAN_FILTER *p_msg;
2488 APPL_TRACE_API ("BTA_DmEnableScanFilter: %d\n", action);
2489
2490 UINT16 len = sizeof(tBTA_DM_API_ENABLE_SCAN_FILTER) + sizeof(tBLE_BD_ADDR);
2491
2492 if ((p_msg = (tBTA_DM_API_ENABLE_SCAN_FILTER *) osi_malloc(len)) != NULL) {
2493 memset (p_msg, 0, len);
2494
2495 p_msg->hdr.event = BTA_DM_API_SCAN_FILTER_ENABLE_EVT;
2496 p_msg->action = action;
2497 p_msg->ref_value = ref_value;
2498 p_msg->p_filt_status_cback = p_cmpl_cback;
2499
2500 bta_sys_sendmsg(p_msg);
2501 }
2502 #else
2503 UNUSED(action);
2504 UNUSED(p_cmpl_cback);
2505 UNUSED(ref_value);
2506 #endif
2507 }
2508
2509 /*******************************************************************************
2510 **
2511 ** Function BTA_DmBleUpdateConnectionParams
2512 **
2513 ** Description Update connection parameters, can only be used when connection is up.
2514 **
2515 ** Parameters: bd_addr - BD address of the peer
2516 ** min_int - minimum connection interval, [0x0004~ 0x4000]
2517 ** max_int - maximum connection interval, [0x0004~ 0x4000]
2518 ** latency - slave latency [0 ~ 500]
2519 ** timeout - supervision timeout [0x000a ~ 0xc80]
2520 **
2521 ** Returns void
2522 **
2523 *******************************************************************************/
BTA_DmBleUpdateConnectionParams(BD_ADDR bd_addr,UINT16 min_int,UINT16 max_int,UINT16 latency,UINT16 timeout)2524 void BTA_DmBleUpdateConnectionParams(BD_ADDR bd_addr, UINT16 min_int, UINT16 max_int,
2525 UINT16 latency, UINT16 timeout)
2526 {
2527 tBTA_DM_API_UPDATE_CONN_PARAM *p_msg;
2528
2529 if ((p_msg = (tBTA_DM_API_UPDATE_CONN_PARAM *) osi_malloc(sizeof(tBTA_DM_API_UPDATE_CONN_PARAM))) != NULL) {
2530 memset (p_msg, 0, sizeof(tBTA_DM_API_UPDATE_CONN_PARAM));
2531
2532 p_msg->hdr.event = BTA_DM_API_UPDATE_CONN_PARAM_EVT;
2533 bdcpy(p_msg->bd_addr, bd_addr);
2534 p_msg->min_int = min_int;
2535 p_msg->max_int = max_int;
2536 p_msg->latency = latency;
2537 p_msg->timeout = timeout;
2538 bta_sys_sendmsg(p_msg);
2539 }
2540 }
2541 /*******************************************************************************
2542 **
2543 ** Function BTA_DmBleDisconnect
2544 **
2545 ** Description Disconnect the ble connection, can only be used when connection is up.
2546 **
2547 ** Parameters: bd_addr - BD address of the peer
2548 **
2549 ** Returns void
2550 **
2551 *******************************************************************************/
BTA_DmBleDisconnect(BD_ADDR bd_addr)2552 void BTA_DmBleDisconnect(BD_ADDR bd_addr)
2553 {
2554 tBTA_DM_API_BLE_DISCONNECT *p_msg;
2555
2556 if ((p_msg = (tBTA_DM_API_BLE_DISCONNECT *) osi_malloc(sizeof(tBTA_DM_API_BLE_DISCONNECT))) != NULL) {
2557 memset (p_msg, 0, sizeof(tBTA_DM_API_BLE_DISCONNECT));
2558
2559 p_msg->hdr.event = BTA_DM_API_BLE_DISCONNECT_EVT;
2560 bdcpy(p_msg->remote_bda, bd_addr);
2561
2562 bta_sys_sendmsg(p_msg);
2563 }
2564 }
2565 /*******************************************************************************
2566 **
2567 ** Function BTA_DmBleSetDataLength
2568 **
2569 ** Description This function is to set maximum LE data packet size
2570 **
2571 ** Returns void
2572 **
2573 **
2574 *******************************************************************************/
BTA_DmBleSetDataLength(BD_ADDR remote_device,UINT16 tx_data_length,tBTA_SET_PKT_DATA_LENGTH_CBACK * p_set_pkt_data_cback)2575 void BTA_DmBleSetDataLength(BD_ADDR remote_device, UINT16 tx_data_length, tBTA_SET_PKT_DATA_LENGTH_CBACK *p_set_pkt_data_cback)
2576 {
2577 tBTA_DM_API_BLE_SET_DATA_LENGTH *p_msg;
2578
2579 if ((p_msg = (tBTA_DM_API_BLE_SET_DATA_LENGTH *)osi_malloc(sizeof(tBTA_DM_API_BLE_SET_DATA_LENGTH)))
2580 != NULL) {
2581 bdcpy(p_msg->remote_bda, remote_device);
2582 p_msg->hdr.event = BTA_DM_API_SET_DATA_LENGTH_EVT;
2583 p_msg->tx_data_length = tx_data_length;
2584 p_msg->p_set_pkt_data_cback = p_set_pkt_data_cback;
2585
2586 bta_sys_sendmsg(p_msg);
2587 }
2588 }
2589
BTA_DmBleDtmTxStart(uint8_t tx_channel,uint8_t len_of_data,uint8_t pkt_payload,tBTA_DTM_CMD_CMPL_CBACK * p_dtm_cmpl_cback)2590 void BTA_DmBleDtmTxStart(uint8_t tx_channel, uint8_t len_of_data, uint8_t pkt_payload, tBTA_DTM_CMD_CMPL_CBACK *p_dtm_cmpl_cback)
2591 {
2592 tBTA_DM_API_BLE_DTM_TX_START *p_msg;
2593
2594 if ((p_msg = (tBTA_DM_API_BLE_DTM_TX_START *)osi_malloc(sizeof(tBTA_DM_API_BLE_DTM_TX_START)))
2595 != NULL) {
2596 p_msg->hdr.event = BTA_DM_API_DTM_TX_START_EVT;
2597 p_msg->tx_channel = tx_channel;
2598 p_msg->len_of_data = len_of_data;
2599 p_msg->pkt_payload = pkt_payload;
2600 p_msg->p_dtm_cmpl_cback = p_dtm_cmpl_cback;
2601
2602 bta_sys_sendmsg(p_msg);
2603 }
2604 }
2605
BTA_DmBleDtmRxStart(uint8_t rx_channel,tBTA_DTM_CMD_CMPL_CBACK * p_dtm_cmpl_cback)2606 void BTA_DmBleDtmRxStart(uint8_t rx_channel, tBTA_DTM_CMD_CMPL_CBACK *p_dtm_cmpl_cback)
2607 {
2608 tBTA_DM_API_BLE_DTM_RX_START *p_msg;
2609
2610 if ((p_msg = (tBTA_DM_API_BLE_DTM_RX_START *)osi_malloc(sizeof(tBTA_DM_API_BLE_DTM_RX_START)))
2611 != NULL) {
2612 p_msg->hdr.event = BTA_DM_API_DTM_RX_START_EVT;
2613 p_msg->rx_channel= rx_channel;
2614 p_msg->p_dtm_cmpl_cback = p_dtm_cmpl_cback;
2615
2616 bta_sys_sendmsg(p_msg);
2617 }
2618 }
2619
BTA_DmBleDtmStop(tBTA_DTM_CMD_CMPL_CBACK * p_dtm_cmpl_cback)2620 void BTA_DmBleDtmStop(tBTA_DTM_CMD_CMPL_CBACK *p_dtm_cmpl_cback)
2621 {
2622 tBTA_DM_API_BLE_DTM_STOP *p_msg;
2623
2624 if ((p_msg = (tBTA_DM_API_BLE_DTM_STOP *)osi_malloc(sizeof(tBTA_DM_API_BLE_DTM_STOP)))
2625 != NULL) {
2626 p_msg->hdr.event = BTA_DM_API_DTM_STOP_EVT;
2627 p_msg->p_dtm_cmpl_cback = p_dtm_cmpl_cback;
2628
2629 bta_sys_sendmsg(p_msg);
2630 }
2631 }
2632
BTA_DmBleSetPrivacyMode(uint8_t addr_type,BD_ADDR addr,uint8_t privacy_mode,tBTA_SET_PRIVACY_MODE_CMPL_CBACK * p_cback)2633 void BTA_DmBleSetPrivacyMode(uint8_t addr_type, BD_ADDR addr, uint8_t privacy_mode, tBTA_SET_PRIVACY_MODE_CMPL_CBACK *p_cback)
2634 {
2635 tBTA_DM_API_SET_PRIVACY_MODE *p_msg;
2636
2637 if ((p_msg = (tBTA_DM_API_SET_PRIVACY_MODE *)osi_malloc(sizeof(tBTA_DM_API_SET_PRIVACY_MODE)))
2638 != NULL) {
2639 p_msg->hdr.event = BTA_DM_API_SET_PRIVACY_MODE_EVT;
2640 p_msg->addr_type = addr_type;
2641 memcpy(p_msg->addr, addr, sizeof(BD_ADDR));
2642 p_msg->privacy_mode = privacy_mode;
2643 p_msg->p_cback = p_cback;
2644 bta_sys_sendmsg(p_msg);
2645 }
2646 }
2647
2648 #endif
2649
2650 /*******************************************************************************
2651 **
2652 ** Function BTA_DmSetEncryption
2653 **
2654 ** Description This function is called to ensure that connection is
2655 ** encrypted. Should be called only on an open connection.
2656 ** Typically only needed for connections that first want to
2657 ** bring up unencrypted links, then later encrypt them.
2658 **
2659 ** Parameters: bd_addr - Address of the peer device
2660 ** transport - transport of the link to be encruypted
2661 ** p_callback - Pointer to callback function to indicate the
2662 ** link encryption status
2663 ** sec_act - This is the security action to indicate
2664 ** what kind of BLE security level is required for
2665 ** the BLE link if the BLE is supported
2666 ** Note: This parameter is ignored for the BR/EDR link
2667 ** or the BLE is not supported
2668 **
2669 ** Returns void
2670 **
2671 *******************************************************************************/
2672 #if (SMP_INCLUDED == TRUE)
BTA_DmSetEncryption(BD_ADDR bd_addr,tBTA_TRANSPORT transport,tBTA_DM_ENCRYPT_CBACK * p_callback,tBTA_DM_BLE_SEC_ACT sec_act)2673 void BTA_DmSetEncryption(BD_ADDR bd_addr, tBTA_TRANSPORT transport, tBTA_DM_ENCRYPT_CBACK *p_callback,
2674 tBTA_DM_BLE_SEC_ACT sec_act)
2675 {
2676 tBTA_DM_API_SET_ENCRYPTION *p_msg;
2677
2678 APPL_TRACE_API("BTA_DmSetEncryption"); //todo
2679 if ((p_msg = (tBTA_DM_API_SET_ENCRYPTION *) osi_malloc(sizeof(tBTA_DM_API_SET_ENCRYPTION))) != NULL) {
2680 memset(p_msg, 0, sizeof(tBTA_DM_API_SET_ENCRYPTION));
2681
2682 p_msg->hdr.event = BTA_DM_API_SET_ENCRYPTION_EVT;
2683
2684 memcpy(p_msg->bd_addr, bd_addr, BD_ADDR_LEN);
2685 p_msg->transport = transport;
2686 p_msg->p_callback = p_callback;
2687 p_msg->sec_act = sec_act;
2688
2689 bta_sys_sendmsg(p_msg);
2690 }
2691 }
2692 #endif ///SMP_INCLUDED == TRUE
2693
2694 /*******************************************************************************
2695 **
2696 ** Function BTA_DmCloseACL
2697 **
2698 ** Description This function force to close an ACL connection and remove the
2699 ** device from the security database list of known devices.
2700 **
2701 ** Parameters: bd_addr - Address of the peer device
2702 ** remove_dev - remove device or not after link down
2703 **
2704 ** Returns void
2705 **
2706 *******************************************************************************/
BTA_DmCloseACL(BD_ADDR bd_addr,BOOLEAN remove_dev,tBTA_TRANSPORT transport)2707 void BTA_DmCloseACL(BD_ADDR bd_addr, BOOLEAN remove_dev, tBTA_TRANSPORT transport)
2708 {
2709 tBTA_DM_API_REMOVE_ACL *p_msg;
2710
2711 APPL_TRACE_API("BTA_DmCloseACL");
2712
2713 if ((p_msg = (tBTA_DM_API_REMOVE_ACL *) osi_malloc(sizeof(tBTA_DM_API_REMOVE_ACL))) != NULL) {
2714 memset(p_msg, 0, sizeof(tBTA_DM_API_REMOVE_ACL));
2715
2716 p_msg->hdr.event = BTA_DM_API_REMOVE_ACL_EVT;
2717
2718 memcpy(p_msg->bd_addr, bd_addr, BD_ADDR_LEN);
2719 p_msg->remove_dev = remove_dev;
2720 p_msg->transport = transport;
2721
2722 bta_sys_sendmsg(p_msg);
2723 }
2724 }
2725
2726 #if BLE_INCLUDED == TRUE
2727 /*******************************************************************************
2728 **
2729 ** Function BTA_DmBleObserve
2730 **
2731 ** Description This procedure keep the device listening for advertising
2732 ** events from a broadcast device.
2733 **
2734 ** Parameters start: start or stop observe.
2735 **
2736 ** Returns void
2737
2738 **
2739 ** Returns void.
2740 **
2741 *******************************************************************************/
BTA_DmBleObserve(BOOLEAN start,UINT32 duration,tBTA_DM_SEARCH_CBACK * p_results_cb,tBTA_START_STOP_SCAN_CMPL_CBACK * p_start_stop_scan_cb)2742 extern void BTA_DmBleObserve(BOOLEAN start, UINT32 duration,
2743 tBTA_DM_SEARCH_CBACK *p_results_cb,
2744 tBTA_START_STOP_SCAN_CMPL_CBACK *p_start_stop_scan_cb)
2745 {
2746 tBTA_DM_API_BLE_OBSERVE *p_msg;
2747
2748 APPL_TRACE_API("BTA_DmBleObserve:start = %d ", start);
2749
2750 if ((p_msg = (tBTA_DM_API_BLE_OBSERVE *) osi_malloc(sizeof(tBTA_DM_API_BLE_OBSERVE))) != NULL) {
2751 memset(p_msg, 0, sizeof(tBTA_DM_API_BLE_OBSERVE));
2752
2753 p_msg->hdr.event = BTA_DM_API_BLE_OBSERVE_EVT;
2754 p_msg->start = start;
2755 p_msg->duration = duration;
2756 p_msg->p_cback = p_results_cb;
2757 if (start){
2758 p_msg->p_start_scan_cback = p_start_stop_scan_cb;
2759 }
2760 else {
2761 p_msg->p_stop_scan_cback = p_start_stop_scan_cb;
2762 }
2763
2764 bta_sys_sendmsg(p_msg);
2765 }
2766 }
2767
2768 /*******************************************************************************
2769 **
2770 ** Function BTA_DmBleScan
2771 **
2772 ** Description This procedure keep the device listening for advertising
2773 ** events from a broadcast device.
2774 **
2775 ** Parameters start: start or stop scan.
2776 **
2777 ** Returns void
2778
2779 **
2780 ** Returns void.
2781 **
2782 *******************************************************************************/
BTA_DmBleScan(BOOLEAN start,UINT32 duration,tBTA_DM_SEARCH_CBACK * p_results_cb,tBTA_START_STOP_SCAN_CMPL_CBACK * p_start_stop_scan_cb)2783 extern void BTA_DmBleScan(BOOLEAN start, UINT32 duration,
2784 tBTA_DM_SEARCH_CBACK *p_results_cb,
2785 tBTA_START_STOP_SCAN_CMPL_CBACK *p_start_stop_scan_cb)
2786 {
2787 tBTA_DM_API_BLE_SCAN *p_msg;
2788
2789 APPL_TRACE_API("BTA_DmBleScan:start = %d ", start);
2790
2791 if ((p_msg = (tBTA_DM_API_BLE_SCAN *) osi_malloc(sizeof(tBTA_DM_API_BLE_SCAN))) != NULL) {
2792 memset(p_msg, 0, sizeof(tBTA_DM_API_BLE_SCAN));
2793
2794 p_msg->hdr.event = BTA_DM_API_BLE_SCAN_EVT;
2795 p_msg->start = start;
2796 p_msg->duration = duration;
2797 p_msg->p_cback = p_results_cb;
2798 if (start){
2799 p_msg->p_start_scan_cback = p_start_stop_scan_cb;
2800 }
2801 else {
2802 p_msg->p_stop_scan_cback = p_start_stop_scan_cb;
2803 }
2804
2805 bta_sys_sendmsg(p_msg);
2806 }
2807 }
2808
2809 /*******************************************************************************
2810 **
2811 ** Function BTA_DmBleStopAdvertising
2812 **
2813 ** Description This function set the random address for the APP
2814 **
2815 ** Parameters void
2816 **
2817 ** Returns void
2818 **
2819 **
2820 *******************************************************************************/
BTA_DmBleStopAdvertising(void)2821 extern void BTA_DmBleStopAdvertising(void)
2822 {
2823 BT_HDR *p_msg;
2824
2825 APPL_TRACE_API("BTA_DmBleStopAdvertising\n");
2826
2827 if ((p_msg = (BT_HDR *) osi_malloc(sizeof(BT_HDR))) != NULL) {
2828 memset(p_msg, 0, sizeof(BT_HDR));
2829 p_msg->event = BTA_DM_API_BLE_STOP_ADV_EVT;
2830 bta_sys_sendmsg(p_msg);
2831 }
2832 }
2833
2834
2835 /*******************************************************************************
2836 **
2837 ** Function BTA_DmSetRandAddress
2838 **
2839 ** Description This function set the random address for the APP
2840 **
2841 ** Parameters rand_addr: the random address with should be setting
2842 ** p_set_rand_addr_cback: complete callback
2843 ** Returns void
2844 **
2845 **
2846 *******************************************************************************/
BTA_DmSetRandAddress(BD_ADDR rand_addr,tBTA_SET_RAND_ADDR_CBACK * p_set_rand_addr_cback)2847 extern void BTA_DmSetRandAddress(BD_ADDR rand_addr, tBTA_SET_RAND_ADDR_CBACK *p_set_rand_addr_cback)
2848 {
2849 tBTA_DM_APT_SET_DEV_ADDR *p_msg;
2850 APPL_TRACE_API("set the random address ");
2851 if ((p_msg = (tBTA_DM_APT_SET_DEV_ADDR *) osi_malloc(sizeof(tBTA_DM_APT_SET_DEV_ADDR))) != NULL) {
2852 memset(p_msg, 0, sizeof(tBTA_DM_APT_SET_DEV_ADDR));
2853 memcpy(p_msg->address, rand_addr, BD_ADDR_LEN);
2854 p_msg->hdr.event = BTA_DM_API_SET_RAND_ADDR_EVT;
2855 p_msg->addr_type = BLE_ADDR_RANDOM;
2856 p_msg->p_set_rand_addr_cback = p_set_rand_addr_cback;
2857 //start sent the msg to the bta system control module
2858 bta_sys_sendmsg(p_msg);
2859 }
2860 }
2861 /*******************************************************************************
2862 **
2863 ** Function BTA_DmBleSetRpaTimeout
2864 **
2865 ** Description This function sets the Resolvable Private Address (RPA) timeout
2866 ** for the Bluetooth device. The RPA timeout defines how long an RPA
2867 ** remains in use before a new one is generated.
2868 **
2869 ** Parameters rpa_timeout: The timeout in seconds within the range of 1s to 1 hour
2870 ** as defined by the Bluetooth specification. This duration
2871 ** specifies how long the controller uses an RPA before
2872 ** generating a new one.
2873 ** Returns void
2874 **
2875 **
2876 *******************************************************************************/
BTA_DmBleSetRpaTimeout(uint16_t rpa_timeout,tBTA_SET_RPA_TIMEOUT_CMPL_CBACK * p_set_rpa_timeout_cback)2877 void BTA_DmBleSetRpaTimeout(uint16_t rpa_timeout,tBTA_SET_RPA_TIMEOUT_CMPL_CBACK *p_set_rpa_timeout_cback)
2878 {
2879 tBTA_DM_API_SET_RPA_TIMEOUT *p_msg;
2880 if ((p_msg = (tBTA_DM_API_SET_RPA_TIMEOUT *) osi_malloc(sizeof(tBTA_DM_API_SET_RPA_TIMEOUT))) != NULL) {
2881 memset(p_msg, 0, sizeof(tBTA_DM_API_SET_RPA_TIMEOUT));
2882 p_msg->hdr.event = BTA_DM_API_SET_RPA_TIMEOUT_EVT;
2883 p_msg->rpa_timeout = rpa_timeout; // Assign the RPA timeout value to the message
2884 p_msg->p_set_rpa_timeout_cback = p_set_rpa_timeout_cback;
2885 bta_sys_sendmsg(p_msg);
2886 }
2887 }
2888
2889 /*******************************************************************************
2890 **
2891 ** Function BTA_DmBleAddDevToResolvingList
2892 **
2893 ** Description This function adds a device to the resolving list of the
2894 ** Bluetooth controller. The resolving list is used for resolving
2895 ** the identity of devices using resolvable private addresses (RPAs).
2896 **
2897 ** Parameters addr: Bluetooth device address to be added to the resolving list
2898 ** addr_type: Type of the address (public or random)
2899 ** irk: Identity Resolving Key (IRK) of the device
2900 ** add_dev_to_resolving_list_callback: Callback function to be invoked
2901 ** upon completion of the operation
2902 **
2903 ** Returns void
2904 **
2905 *******************************************************************************/
BTA_DmBleAddDevToResolvingList(BD_ADDR addr,uint8_t addr_type,PEER_IRK irk,tBTA_ADD_DEV_TO_RESOLVING_LIST_CMPL_CBACK * add_dev_to_resolving_list_callback)2906 void BTA_DmBleAddDevToResolvingList(BD_ADDR addr,
2907 uint8_t addr_type,
2908 PEER_IRK irk,
2909 tBTA_ADD_DEV_TO_RESOLVING_LIST_CMPL_CBACK *add_dev_to_resolving_list_callback)
2910 {
2911 tBTA_DM_API_ADD_DEV_TO_RESOLVING_LIST *p_msg;
2912 if ((p_msg = (tBTA_DM_API_ADD_DEV_TO_RESOLVING_LIST *) osi_malloc(sizeof(tBTA_DM_API_ADD_DEV_TO_RESOLVING_LIST))) != NULL) {
2913 memset(p_msg, 0, sizeof(tBTA_DM_API_ADD_DEV_TO_RESOLVING_LIST));
2914 p_msg->hdr.event = BTA_DM_API_ADD_DEV_TO_RESOLVING_LIST_EVT;
2915 memcpy(p_msg->addr, addr, BD_ADDR_LEN); // Copy the device address to the message
2916 p_msg->addr_type = addr_type; // Assign the address type to the message
2917 memcpy(p_msg->irk, irk, PEER_IRK_LEN); // Copy the IRK to the message
2918 p_msg->p_add_dev_to_resolving_list_callback = add_dev_to_resolving_list_callback;
2919 bta_sys_sendmsg(p_msg);
2920 }
2921 }
2922
BTA_DmClearRandAddress(void)2923 void BTA_DmClearRandAddress(void)
2924 {
2925 tBTA_DM_APT_CLEAR_ADDR *p_msg;
2926 if ((p_msg = (tBTA_DM_APT_CLEAR_ADDR *) osi_malloc(sizeof(tBTA_DM_APT_CLEAR_ADDR))) != NULL) {
2927 memset(p_msg, 0, sizeof(tBTA_DM_APT_CLEAR_ADDR));
2928 p_msg->hdr.event = BTA_DM_API_CLEAR_RAND_ADDR_EVT;
2929 bta_sys_sendmsg(p_msg);
2930 }
2931 }
2932
BTA_DmBleGapSetCsaSupport(uint8_t csa_select,tBTA_SET_CSA_SUPPORT_CMPL_CBACK * p_callback)2933 void BTA_DmBleGapSetCsaSupport(uint8_t csa_select, tBTA_SET_CSA_SUPPORT_CMPL_CBACK *p_callback)
2934 {
2935 tBTA_DM_API_BLE_SET_CSA_SUPPORT *p_msg;
2936
2937 if ((p_msg = (tBTA_DM_API_BLE_SET_CSA_SUPPORT *)osi_malloc(sizeof(tBTA_DM_API_BLE_SET_CSA_SUPPORT)))
2938 != NULL) {
2939 p_msg->hdr.event = BTA_DM_API_BLE_SET_CSA_SUPPORT_EVT;
2940 p_msg->csa_select = csa_select;
2941 p_msg->p_cback = p_callback;
2942 bta_sys_sendmsg(p_msg);
2943 }
2944 }
2945
2946 /*******************************************************************************
2947 **
2948 ** Function BTA_VendorInit
2949 **
2950 ** Description This function initializes vendor specific
2951 **
2952 ** Returns void
2953 **
2954 *******************************************************************************/
BTA_VendorInit(void)2955 void BTA_VendorInit (void)
2956 {
2957 APPL_TRACE_API("BTA_VendorInit");
2958 }
2959
2960 /*******************************************************************************
2961 **
2962 ** Function BTA_VendorCleanup
2963 **
2964 ** Description This function frees up Broadcom specific VS specific dynamic memory
2965 **
2966 ** Returns void
2967 **
2968 *******************************************************************************/
BTA_VendorCleanup(void)2969 void BTA_VendorCleanup (void)
2970 {
2971 tBTM_BLE_VSC_CB cmn_ble_vsc_cb;
2972 BTM_BleGetVendorCapabilities(&cmn_ble_vsc_cb);
2973
2974 #if (BLE_INCLUDED == TRUE && BLE_ANDROID_CONTROLLER_SCAN_FILTER == TRUE)
2975 btm_ble_adv_filter_cleanup(); // when BLE_VND_INCLUDED is false, this function will be ignore, so move it out of "if"
2976
2977 #if 0 //by TH, comment out temporarily
2978 if (cmn_ble_vsc_cb.max_filter > 0) {
2979 btm_ble_adv_filter_cleanup();
2980 #if BLE_PRIVACY_SPT == TRUE
2981 btm_ble_resolving_list_cleanup ();
2982 #endif
2983 }
2984 #endif
2985
2986 if (cmn_ble_vsc_cb.tot_scan_results_strg > 0) {
2987 btm_ble_batchscan_cleanup();
2988 }
2989 #endif
2990
2991 }
2992 #if (BLE_50_FEATURE_SUPPORT == TRUE)
BTA_DmBleGapReadPHY(BD_ADDR addr)2993 void BTA_DmBleGapReadPHY(BD_ADDR addr)
2994 {
2995 tBTA_DM_API_READ_PHY *p_msg;
2996 APPL_TRACE_API("%s, read phy.", __func__);
2997 if ((p_msg = (tBTA_DM_API_READ_PHY *) osi_malloc(sizeof(tBTA_DM_API_READ_PHY))) != NULL) {
2998 memset(p_msg, 0, sizeof(tBTA_DM_API_READ_PHY));
2999 p_msg->hdr.event = BTA_DM_API_READ_PHY_EVT;
3000 memcpy(p_msg->bd_addr, addr, BD_ADDR_LEN);
3001 //start sent the msg to the bta system control module
3002 bta_sys_sendmsg(p_msg);
3003 } else {
3004 APPL_TRACE_ERROR("%s malloc failed", __func__);
3005 }
3006
3007 }
3008
BTA_DmBleGapSetPreferedDefaultPHY(tBTA_DM_BLE_GAP_PHY_MASK tx_phy_mask,tBTA_DM_BLE_GAP_PHY_MASK rx_phy_mask)3009 void BTA_DmBleGapSetPreferedDefaultPHY(tBTA_DM_BLE_GAP_PHY_MASK tx_phy_mask,
3010 tBTA_DM_BLE_GAP_PHY_MASK rx_phy_mask)
3011 {
3012 tBTA_DM_API_SET_PER_DEF_PHY *p_msg;
3013 APPL_TRACE_API("%s, Set preferred default phy.", __func__);
3014 if ((p_msg = (tBTA_DM_API_SET_PER_DEF_PHY *) osi_malloc(sizeof(tBTA_DM_API_SET_PER_DEF_PHY))) != NULL) {
3015 memset(p_msg, 0, sizeof(tBTA_DM_API_SET_PER_DEF_PHY));
3016 p_msg->hdr.event = BTA_DM_API_SET_PER_DEF_PHY_EVT;
3017 p_msg->tx_phy_mask = tx_phy_mask;
3018 p_msg->rx_phy_mask = rx_phy_mask;
3019 //start sent the msg to the bta system control module
3020 bta_sys_sendmsg(p_msg);
3021 } else {
3022 APPL_TRACE_ERROR("%s malloc failed", __func__);
3023 }
3024
3025 }
3026
BTA_DmBleGapSetPreferedPHY(BD_ADDR addr,UINT8 all_phys,tBTA_DM_BLE_GAP_PHY_MASK tx_phy_mask,tBTA_DM_BLE_GAP_PHY_MASK rx_phy_mask,UINT16 phy_options)3027 void BTA_DmBleGapSetPreferedPHY(BD_ADDR addr,
3028 UINT8 all_phys,
3029 tBTA_DM_BLE_GAP_PHY_MASK tx_phy_mask,
3030 tBTA_DM_BLE_GAP_PHY_MASK rx_phy_mask,
3031 UINT16 phy_options)
3032 {
3033 tBTA_DM_API_SET_PER_PHY *p_msg;
3034 APPL_TRACE_API("%s, Set preferred phy.", __func__);
3035 if ((p_msg = (tBTA_DM_API_SET_PER_PHY *) osi_malloc(sizeof(tBTA_DM_API_SET_PER_PHY))) != NULL) {
3036 memset(p_msg, 0, sizeof(tBTA_DM_API_SET_PER_PHY));
3037 p_msg->hdr.event = BTA_DM_API_SET_PER_PHY_EVT;
3038 memcpy(p_msg->bd_addr, addr, BD_ADDR_LEN);
3039 p_msg->all_phys = all_phys;
3040 p_msg->tx_phy_mask = tx_phy_mask;
3041 p_msg->rx_phy_mask = rx_phy_mask;
3042 p_msg->phy_options = phy_options;
3043 //start sent the msg to the bta system control module
3044 bta_sys_sendmsg(p_msg);
3045 } else {
3046 APPL_TRACE_ERROR("%s malloc failed", __func__);
3047 }
3048 }
3049
BTA_DmBleGapExtAdvSetRandaddr(UINT16 instance,BD_ADDR addr)3050 void BTA_DmBleGapExtAdvSetRandaddr(UINT16 instance, BD_ADDR addr)
3051 {
3052 tBTA_DM_API_EXT_ADV_SET_RAND_ADDR *p_msg;
3053 APPL_TRACE_API("%s, Set extended ADV parameters.", __func__);
3054 if ((p_msg = (tBTA_DM_API_EXT_ADV_SET_RAND_ADDR *) osi_malloc(sizeof(tBTA_DM_API_EXT_ADV_SET_RAND_ADDR))) != NULL) {
3055 memset(p_msg, 0, sizeof(tBTA_DM_API_EXT_ADV_SET_RAND_ADDR));
3056 p_msg->hdr.event = BTA_DM_API_SET_EXT_ADV_RAND_ADDR_EVT;
3057 p_msg->instance = instance;
3058 memcpy(&p_msg->rand_addr, addr, BD_ADDR_LEN);
3059 //start sent the msg to the bta system control module
3060 bta_sys_sendmsg(p_msg);
3061 } else {
3062 APPL_TRACE_ERROR("%s malloc failed", __func__);
3063 }
3064
3065 }
3066
BTA_DmBleGapExtAdvSetParams(UINT16 instance,const tBTA_DM_BLE_GAP_EXT_ADV_PARAMS * params)3067 void BTA_DmBleGapExtAdvSetParams(UINT16 instance,
3068 const tBTA_DM_BLE_GAP_EXT_ADV_PARAMS *params)
3069 {
3070 tBTA_DM_API_EXT_ADV_SET_PARAMS *p_msg;
3071 APPL_TRACE_API("%s, Set extended ADV parameters.", __func__);
3072 if ((p_msg = (tBTA_DM_API_EXT_ADV_SET_PARAMS *) osi_malloc(sizeof(tBTA_DM_API_EXT_ADV_SET_PARAMS))) != NULL) {
3073 memset(p_msg, 0, sizeof(tBTA_DM_API_EXT_ADV_SET_PARAMS));
3074 p_msg->hdr.event = BTA_DM_API_SET_EXT_ADV_PARAMS_EVT;
3075 p_msg->instance = instance;
3076 memcpy(&p_msg->params, params, sizeof(tBTA_DM_BLE_GAP_EXT_ADV_PARAMS));
3077 //start sent the msg to the bta system control module
3078 bta_sys_sendmsg(p_msg);
3079 } else {
3080 APPL_TRACE_ERROR("%s malloc failed", __func__);
3081 }
3082
3083 }
3084
BTA_DmBleGapConfigExtAdvDataRaw(BOOLEAN is_scan_rsp,UINT8 instance,UINT16 length,const UINT8 * data)3085 void BTA_DmBleGapConfigExtAdvDataRaw(BOOLEAN is_scan_rsp, UINT8 instance, UINT16 length,
3086 const UINT8 *data)
3087 {
3088 tBTA_DM_API_CFG_EXT_ADV_DATA *p_msg;
3089 APPL_TRACE_API("%s, Config extended %s data.", __func__, is_scan_rsp ? "Scan rsp" : "Adv");
3090 if ((p_msg = (tBTA_DM_API_CFG_EXT_ADV_DATA *) osi_malloc(sizeof(tBTA_DM_API_CFG_EXT_ADV_DATA) + length)) != NULL) {
3091 memset(p_msg, 0, sizeof(tBTA_DM_API_CFG_EXT_ADV_DATA) + length);
3092 p_msg->hdr.event = BTA_DM_API_CFG_ADV_DATA_RAW_EVT;
3093 p_msg->is_scan_rsp = is_scan_rsp;
3094 p_msg->instance = instance;
3095 p_msg->length = length;
3096 p_msg->data = length != 0 ? (UINT8 *)(p_msg + 1) : NULL;
3097 if (data) {
3098 memcpy(p_msg->data, data, length);
3099 }
3100 //start sent the msg to the bta system control module
3101 bta_sys_sendmsg(p_msg);
3102 } else {
3103 APPL_TRACE_ERROR("%s malloc failed", __func__);
3104 }
3105 }
3106
BTA_DmBleGapExtAdvEnable(BOOLEAN enable,UINT8 num,tBTA_DM_BLE_EXT_ADV * ext_adv)3107 void BTA_DmBleGapExtAdvEnable(BOOLEAN enable, UINT8 num, tBTA_DM_BLE_EXT_ADV *ext_adv)
3108 {
3109 tBTA_DM_API_BLE_EXT_ADV *p_msg;
3110 APPL_TRACE_API("%s, Start extended ADV", __func__);
3111 if ((p_msg = (tBTA_DM_API_BLE_EXT_ADV *) osi_malloc(sizeof(tBTA_DM_API_BLE_EXT_ADV) + sizeof(tBTA_DM_BLE_EXT_ADV)*num)) != NULL) {
3112 memset(p_msg, 0, sizeof(tBTA_DM_API_BLE_EXT_ADV) + sizeof(tBTA_DM_BLE_EXT_ADV)*num);
3113 p_msg->hdr.event = BTA_DM_API_EXT_ADV_ENABLE_EVT;
3114 p_msg->enable = enable;
3115 p_msg->num = num;
3116 p_msg->ext_adv = (tBTA_DM_BLE_EXT_ADV *)(p_msg + 1);
3117 if (ext_adv) {
3118 memcpy(p_msg->ext_adv, ext_adv, sizeof(tBTA_DM_BLE_EXT_ADV)*num);
3119 }
3120 //start sent the msg to the bta system control module
3121 bta_sys_sendmsg(p_msg);
3122 } else {
3123 APPL_TRACE_ERROR("%s malloc failed", __func__);
3124 }
3125 }
3126
BTA_DmBleGapExtAdvSetRemove(UINT8 instance)3127 void BTA_DmBleGapExtAdvSetRemove(UINT8 instance)
3128 {
3129 tBTA_DM_API_BLE_EXT_ADV_SET_REMOVE *p_msg;
3130 APPL_TRACE_API("%s, Remove extended ADV", __func__);
3131 if ((p_msg = (tBTA_DM_API_BLE_EXT_ADV_SET_REMOVE *) osi_malloc(sizeof(tBTA_DM_API_BLE_EXT_ADV_SET_REMOVE))) != NULL) {
3132 memset(p_msg, 0, sizeof(tBTA_DM_API_BLE_EXT_ADV_SET_REMOVE));
3133 p_msg->hdr.event = BTA_DM_API_EXT_ADV_SET_REMOVE_EVT;
3134 p_msg->instance = instance;
3135 //start sent the msg to the bta system control module
3136 bta_sys_sendmsg(p_msg);
3137 } else {
3138 APPL_TRACE_ERROR("%s malloc failed", __func__);
3139 }
3140 }
3141
BTA_DmBleGapExtAdvSetClear(void)3142 void BTA_DmBleGapExtAdvSetClear(void)
3143 {
3144 tBTA_DM_API_BLE_EXT_ADV_SET_CLEAR *p_msg;
3145 APPL_TRACE_API("%s, Clear extended ADV", __func__);
3146 if ((p_msg = (tBTA_DM_API_BLE_EXT_ADV_SET_CLEAR *) osi_malloc(sizeof(tBTA_DM_API_BLE_EXT_ADV_SET_CLEAR))) != NULL) {
3147 memset(p_msg, 0, sizeof(tBTA_DM_API_BLE_EXT_ADV_SET_CLEAR));
3148 p_msg->hdr.event = BTA_DM_API_EXT_ADV_SET_CLEAR_EVT;
3149 //start sent the msg to the bta system control module
3150 bta_sys_sendmsg(p_msg);
3151 } else {
3152 APPL_TRACE_ERROR("%s malloc failed", __func__);
3153 }
3154 }
3155
BTA_DmBleGapPeriodicAdvSetParams(UINT8 instance,tBTA_DM_BLE_Periodic_Adv_Params * params)3156 void BTA_DmBleGapPeriodicAdvSetParams(UINT8 instance,
3157 tBTA_DM_BLE_Periodic_Adv_Params *params)
3158 {
3159 tBTA_DM_API_BLE_PERIODIC_ADV_SET_PARAMS *p_msg;
3160 APPL_TRACE_API("%s, Periodic ADV set parameters.", __func__);
3161 if ((p_msg = (tBTA_DM_API_BLE_PERIODIC_ADV_SET_PARAMS *) osi_malloc(sizeof(tBTA_DM_API_BLE_PERIODIC_ADV_SET_PARAMS))) != NULL) {
3162 memset(p_msg, 0, sizeof(tBTA_DM_API_BLE_PERIODIC_ADV_SET_PARAMS));
3163 p_msg->hdr.event = BTA_DM_API_PERIODIC_ADV_SET_PARAMS_EVT;
3164 p_msg->instance = instance;
3165 memcpy(&p_msg->params, params, sizeof(tBTA_DM_BLE_Periodic_Adv_Params));
3166 //start sent the msg to the bta system control module
3167 bta_sys_sendmsg(p_msg);
3168 } else {
3169 APPL_TRACE_ERROR("%s malloc failed", __func__);
3170 }
3171
3172 }
3173
BTA_DmBleGapPeriodicAdvCfgDataRaw(UINT8 instance,UINT16 length,const UINT8 * data,bool only_update_did)3174 void BTA_DmBleGapPeriodicAdvCfgDataRaw(UINT8 instance, UINT16 length,
3175 const UINT8 *data,bool only_update_did)
3176 {
3177 tBTA_DM_API_CFG_PERIODIC_ADV_DATA *p_msg;
3178 APPL_TRACE_API("%s, Periodic ADV config data raw.", __func__);
3179 if ((p_msg = (tBTA_DM_API_CFG_PERIODIC_ADV_DATA *) osi_malloc(sizeof(tBTA_DM_API_CFG_PERIODIC_ADV_DATA) + length)) != NULL) {
3180 memset(p_msg, 0, sizeof(tBTA_DM_API_CFG_PERIODIC_ADV_DATA) + length);
3181 p_msg->hdr.event = BTA_DM_API_PERIODIC_ADV_CFG_DATA_EVT;
3182 p_msg->instance = instance;
3183 p_msg->length = length;
3184 p_msg->data = (UINT8 *)(p_msg + 1);
3185 memcpy(p_msg->data, data, length);
3186 p_msg->data = length != 0 ? (UINT8 *)(p_msg + 1) : NULL;
3187 p_msg->only_update_did = only_update_did;
3188 //start sent the msg to the bta system control module
3189 bta_sys_sendmsg(p_msg);
3190 } else {
3191 APPL_TRACE_ERROR("%s malloc failed", __func__);
3192 }
3193
3194 }
3195
BTA_DmBleGapPeriodicAdvEnable(UINT8 enable,UINT8 instance)3196 void BTA_DmBleGapPeriodicAdvEnable(UINT8 enable, UINT8 instance)
3197 {
3198 tBTA_DM_API_ENABLE_PERIODIC_ADV *p_msg;
3199 APPL_TRACE_API("%s, Periodic ADV %s.", __func__, enable ? "start" : "stop");
3200 if ((p_msg = (tBTA_DM_API_ENABLE_PERIODIC_ADV *) osi_malloc(sizeof(tBTA_DM_API_ENABLE_PERIODIC_ADV))) != NULL) {
3201 memset(p_msg, 0, sizeof(tBTA_DM_API_ENABLE_PERIODIC_ADV));
3202 p_msg->hdr.event = BTA_DM_API_PERIODIC_ADV_ENABLE_EVT;
3203 p_msg->instance = instance;
3204 p_msg->enable = enable;
3205 //start sent the msg to the bta system control module
3206 bta_sys_sendmsg(p_msg);
3207 } else {
3208 APPL_TRACE_ERROR("%s malloc failed", __func__);
3209 }
3210
3211 }
3212
BTA_DmBleGapPeriodicAdvCreateSync(tBTA_DM_BLE_Periodic_Sync_Params * params)3213 void BTA_DmBleGapPeriodicAdvCreateSync(tBTA_DM_BLE_Periodic_Sync_Params *params)
3214 {
3215 tBTA_DM_API_PERIODIC_ADV_SYNC *p_msg;
3216 APPL_TRACE_API("%s, Periodic ADV create sync.", __func__);
3217 if ((p_msg = (tBTA_DM_API_PERIODIC_ADV_SYNC *) osi_malloc(sizeof(tBTA_DM_API_PERIODIC_ADV_SYNC))) != NULL) {
3218 memset(p_msg, 0, sizeof(tBTA_DM_API_PERIODIC_ADV_SYNC));
3219 p_msg->hdr.event = BTA_DM_API_PERIODIC_ADV_SYNC_EVT;
3220 memcpy(&p_msg->params, params, sizeof(tBTA_DM_BLE_Periodic_Sync_Params));
3221 //start sent the msg to the bta system control module
3222 bta_sys_sendmsg(p_msg);
3223 } else {
3224 APPL_TRACE_ERROR("%s malloc failed", __func__);
3225 }
3226
3227 }
3228
BTA_DmBleGapPeriodicAdvSyncCancel(void)3229 void BTA_DmBleGapPeriodicAdvSyncCancel(void)
3230 {
3231 tBTA_DM_API_PERIODIC_ADV_SYNC_CANCEL *p_msg;
3232 APPL_TRACE_API("%s, Periodic ADV sync cancel.", __func__);
3233 if ((p_msg = (tBTA_DM_API_PERIODIC_ADV_SYNC_CANCEL *) osi_malloc(sizeof(tBTA_DM_API_PERIODIC_ADV_SYNC_CANCEL))) != NULL) {
3234 memset(p_msg, 0, sizeof(tBTA_DM_API_PERIODIC_ADV_SYNC_CANCEL));
3235 p_msg->hdr.event = BTA_DM_API_PERIODIC_ADV_SYNC_CANCEL_EVT;
3236 //start sent the msg to the bta system control module
3237 bta_sys_sendmsg(p_msg);
3238 } else {
3239 APPL_TRACE_ERROR("%s malloc failed", __func__);
3240 }
3241
3242 }
3243
BTA_DmBleGapPeriodicAdvSyncTerm(UINT16 sync_handle)3244 void BTA_DmBleGapPeriodicAdvSyncTerm(UINT16 sync_handle)
3245 {
3246 tBTA_DM_API_PERIODIC_ADV_SYNC_TERM *p_msg;
3247 APPL_TRACE_API("%s, Periodic ADV sync terminat.", __func__);
3248 if ((p_msg = (tBTA_DM_API_PERIODIC_ADV_SYNC_TERM *) osi_malloc(sizeof(tBTA_DM_API_PERIODIC_ADV_SYNC_TERM))) != NULL) {
3249 memset(p_msg, 0, sizeof(tBTA_DM_API_PERIODIC_ADV_SYNC_TERM));
3250 p_msg->hdr.event = BTA_DM_API_PERIODIC_ADV_SYNC_TERMINATE_EVT;
3251 p_msg->sync_handle = sync_handle;
3252 //start sent the msg to the bta system control module
3253 bta_sys_sendmsg(p_msg);
3254 } else {
3255 APPL_TRACE_ERROR("%s malloc failed", __func__);
3256 }
3257
3258 }
3259
BTA_DmBleGapPeriodicAdvAddDevToList(tBLE_ADDR_TYPE addr_type,BD_ADDR addr,UINT16 sid)3260 void BTA_DmBleGapPeriodicAdvAddDevToList(tBLE_ADDR_TYPE addr_type,
3261 BD_ADDR addr,
3262 UINT16 sid)
3263 {
3264 tBTA_DM_API_PERIODIC_ADV_ADD_DEV_TO_LIST *p_msg;
3265 APPL_TRACE_API("%s, Periodic ADV add device to list.", __func__);
3266 if ((p_msg = (tBTA_DM_API_PERIODIC_ADV_ADD_DEV_TO_LIST *) osi_malloc(sizeof(tBTA_DM_API_PERIODIC_ADV_ADD_DEV_TO_LIST))) != NULL) {
3267 memset(p_msg, 0, sizeof(tBTA_DM_API_PERIODIC_ADV_ADD_DEV_TO_LIST));
3268 p_msg->hdr.event = BTA_DM_API_PERIODIC_ADV_ADD_DEV_TO_LSIT_EVT;
3269 p_msg->addr_type = addr_type;
3270 p_msg->sid = sid;
3271 memcpy(p_msg->addr, addr, sizeof(BD_ADDR));
3272 //start sent the msg to the bta system control module
3273 bta_sys_sendmsg(p_msg);
3274 } else {
3275 APPL_TRACE_ERROR("%s malloc failed", __func__);
3276 }
3277
3278 }
3279
BTA_DmBleGapPeriodicAdvRemoveDevFromList(tBLE_ADDR_TYPE addr_type,BD_ADDR addr,UINT16 sid)3280 void BTA_DmBleGapPeriodicAdvRemoveDevFromList(tBLE_ADDR_TYPE addr_type,
3281 BD_ADDR addr,
3282 UINT16 sid)
3283 {
3284 tBTA_DM_API_PERIODIC_ADV_REMOVE_DEV_FROM_LIST *p_msg;
3285 APPL_TRACE_API("%s, Periodic ADV remove device from list.", __func__);
3286 if ((p_msg = (tBTA_DM_API_PERIODIC_ADV_REMOVE_DEV_FROM_LIST *) osi_malloc(sizeof(tBTA_DM_API_PERIODIC_ADV_REMOVE_DEV_FROM_LIST))) != NULL) {
3287 memset(p_msg, 0, sizeof(tBTA_DM_API_PERIODIC_ADV_REMOVE_DEV_FROM_LIST));
3288 p_msg->hdr.event = BTA_DM_API_PERIODIC_ADV_REMOVE_DEV_FROM_LSIT_EVT;
3289 p_msg->addr_type = addr_type;
3290 p_msg->sid = sid;
3291 memcpy(p_msg->addr, addr, sizeof(BD_ADDR));
3292 //start sent the msg to the bta system control module
3293 bta_sys_sendmsg(p_msg);
3294 } else {
3295 APPL_TRACE_ERROR("%s malloc failed", __func__);
3296 }
3297
3298 }
3299
BTA_DmBleGapPeriodicAdvClearDev(void)3300 void BTA_DmBleGapPeriodicAdvClearDev(void)
3301 {
3302 tBTA_DM_API_PERIODIC_ADV_DEV_CLEAR *p_msg;
3303 APPL_TRACE_API("%s, Periodic ADV clear device from list.", __func__);
3304 if ((p_msg = (tBTA_DM_API_PERIODIC_ADV_DEV_CLEAR *) osi_malloc(sizeof(tBTA_DM_API_PERIODIC_ADV_DEV_CLEAR))) != NULL) {
3305 memset(p_msg, 0, sizeof(tBTA_DM_API_PERIODIC_ADV_DEV_CLEAR));
3306 p_msg->hdr.event = BTA_DM_API_PERIODIC_ADV_CLEAR_DEV_EVT;
3307 //start sent the msg to the bta system control module
3308 bta_sys_sendmsg(p_msg);
3309 } else {
3310 APPL_TRACE_ERROR("%s malloc failed", __func__);
3311 }
3312
3313 }
3314
BTA_DmBleGapSetExtScanParams(tBTA_DM_BLE_EXT_SCAN_PARAMS * params)3315 void BTA_DmBleGapSetExtScanParams(tBTA_DM_BLE_EXT_SCAN_PARAMS *params)
3316 {
3317 tBTA_DM_API_SET_EXT_SCAN_PARAMS *p_msg;
3318 APPL_TRACE_API("%s, Set extended scan parameters.", __func__);
3319 if ((p_msg = (tBTA_DM_API_SET_EXT_SCAN_PARAMS *) osi_malloc(sizeof(tBTA_DM_API_SET_EXT_SCAN_PARAMS))) != NULL) {
3320 memset(p_msg, 0, sizeof(tBTA_DM_API_SET_EXT_SCAN_PARAMS));
3321 p_msg->hdr.event = BTA_DM_API_SET_EXT_SCAN_PARAMS_EVT;
3322 memcpy(&p_msg->params, params, sizeof(tBTA_DM_BLE_EXT_SCAN_PARAMS));
3323 //start sent the msg to the bta system control module
3324 bta_sys_sendmsg(p_msg);
3325 } else {
3326 APPL_TRACE_ERROR("%s malloc failed", __func__);
3327 }
3328
3329 }
3330
BTA_DmBleGapExtScan(BOOLEAN start,UINT32 duration,UINT16 period)3331 void BTA_DmBleGapExtScan(BOOLEAN start, UINT32 duration, UINT16 period)
3332 {
3333 tBTA_DM_API_EXT_SCAN *p_msg;
3334 APPL_TRACE_API("%s, %s extended scan.", __func__, start ? "Start" : "Stop");
3335 if ((p_msg = (tBTA_DM_API_EXT_SCAN *) osi_malloc(sizeof(tBTA_DM_API_EXT_SCAN))) != NULL) {
3336 memset(p_msg, 0, sizeof(tBTA_DM_API_EXT_SCAN));
3337 p_msg->hdr.event = BTA_DM_API_START_EXT_SCAN_EVT;
3338 p_msg->start = start;
3339 p_msg->duration = duration;
3340 p_msg->period = period;
3341 //start sent the msg to the bta system control module
3342 bta_sys_sendmsg(p_msg);
3343 } else {
3344 APPL_TRACE_ERROR("%s malloc failed", __func__);
3345 }
3346
3347 }
3348
BTA_DmBleGapPreferExtConnectParamsSet(BD_ADDR bd_addr,UINT8 phy_mask,const tBTA_DM_BLE_CONN_PARAMS * phy_1m_conn_params,const tBTA_DM_BLE_CONN_PARAMS * phy_2m_conn_params,const tBTA_DM_BLE_CONN_PARAMS * phy_coded_conn_params)3349 void BTA_DmBleGapPreferExtConnectParamsSet(BD_ADDR bd_addr,
3350 UINT8 phy_mask,
3351 const tBTA_DM_BLE_CONN_PARAMS *phy_1m_conn_params,
3352 const tBTA_DM_BLE_CONN_PARAMS *phy_2m_conn_params,
3353 const tBTA_DM_BLE_CONN_PARAMS *phy_coded_conn_params)
3354 {
3355 tBTA_DM_API_SET_PER_EXT_CONN_PARAMS *p_msg;
3356 APPL_TRACE_API("%s, Set prefer extended connection parameters.", __func__);
3357 if ((p_msg = (tBTA_DM_API_SET_PER_EXT_CONN_PARAMS *) osi_malloc(sizeof(tBTA_DM_API_SET_PER_EXT_CONN_PARAMS))) != NULL) {
3358 memset(p_msg, 0, sizeof(tBTA_DM_API_SET_PER_EXT_CONN_PARAMS));
3359 p_msg->hdr.event = BTA_DM_API_SET_PERF_EXT_CONN_PARAMS_EVT;
3360 p_msg->phy_mask = phy_mask;
3361
3362 memcpy(p_msg->bd_addr, bd_addr, sizeof(BD_ADDR));
3363
3364 if (phy_1m_conn_params) {
3365 memcpy(&p_msg->phy_1m_conn_params, phy_1m_conn_params, sizeof(tBTA_DM_BLE_CONN_PARAMS));
3366 }
3367
3368 if (phy_2m_conn_params) {
3369 memcpy(&p_msg->phy_2m_conn_params, phy_2m_conn_params, sizeof(tBTA_DM_BLE_CONN_PARAMS));
3370 }
3371
3372 if (phy_coded_conn_params) {
3373 memcpy(&p_msg->phy_coded_conn_params, phy_coded_conn_params, sizeof(tBTA_DM_BLE_CONN_PARAMS));
3374 }
3375 //start sent the msg to the bta system control module
3376 bta_sys_sendmsg(p_msg);
3377 } else {
3378 APPL_TRACE_ERROR("%s malloc failed", __func__);
3379 }
3380
3381
3382 }
3383
BTA_DmBleGapExtConnect(tBLE_ADDR_TYPE own_addr_type,const BD_ADDR peer_addr)3384 void BTA_DmBleGapExtConnect(tBLE_ADDR_TYPE own_addr_type, const BD_ADDR peer_addr)
3385 {
3386 tBTA_DM_API_EXT_CONN *p_msg;
3387 APPL_TRACE_API("%s, Start Extended connect.", __func__);
3388 APPL_TRACE_API("%s, Set prefer extended connection parameters.", __func__);
3389 if ((p_msg = (tBTA_DM_API_EXT_CONN *) osi_malloc(sizeof(tBTA_DM_API_EXT_CONN))) != NULL) {
3390 memset(p_msg, 0, sizeof(tBTA_DM_API_EXT_CONN));
3391 p_msg->hdr.event = BTA_DM_API_EXT_CONN_EVT;
3392 p_msg->own_addr_type = own_addr_type;
3393 memcpy(p_msg->peer_addr, peer_addr, sizeof(BD_ADDR));
3394 //start sent the msg to the bta system control module
3395 bta_sys_sendmsg(p_msg);
3396 } else {
3397 APPL_TRACE_ERROR("%s malloc failed", __func__);
3398 }
3399
3400 }
3401
BTA_DmBleDtmEnhTxStart(uint8_t tx_channel,uint8_t len_of_data,uint8_t pkt_payload,uint8_t phy,tBTA_DTM_CMD_CMPL_CBACK * p_dtm_cmpl_cback)3402 void BTA_DmBleDtmEnhTxStart(uint8_t tx_channel, uint8_t len_of_data, uint8_t pkt_payload, uint8_t phy, tBTA_DTM_CMD_CMPL_CBACK *p_dtm_cmpl_cback)
3403 {
3404 tBTA_DM_API_BLE_DTM_ENH_TX_START *p_msg;
3405
3406 if ((p_msg = (tBTA_DM_API_BLE_DTM_ENH_TX_START *)osi_malloc(sizeof(tBTA_DM_API_BLE_DTM_ENH_TX_START)))
3407 != NULL) {
3408 p_msg->hdr.event = BTA_DM_API_DTM_ENH_TX_START_EVT;
3409 p_msg->tx_channel = tx_channel;
3410 p_msg->len_of_data = len_of_data;
3411 p_msg->pkt_payload = pkt_payload;
3412 p_msg->phy = phy;
3413 p_msg->p_dtm_cmpl_cback = p_dtm_cmpl_cback;
3414
3415 bta_sys_sendmsg(p_msg);
3416 }
3417 }
3418
BTA_DmBleDtmEnhRxStart(uint8_t rx_channel,uint8_t phy,uint8_t modulation_index,tBTA_DTM_CMD_CMPL_CBACK * p_dtm_cmpl_cback)3419 void BTA_DmBleDtmEnhRxStart(uint8_t rx_channel, uint8_t phy, uint8_t modulation_index, tBTA_DTM_CMD_CMPL_CBACK *p_dtm_cmpl_cback)
3420 {
3421 tBTA_DM_API_BLE_DTM_ENH_RX_START *p_msg;
3422
3423 if ((p_msg = (tBTA_DM_API_BLE_DTM_ENH_RX_START *)osi_malloc(sizeof(tBTA_DM_API_BLE_DTM_ENH_RX_START)))
3424 != NULL) {
3425 p_msg->hdr.event = BTA_DM_API_DTM_ENH_RX_START_EVT;
3426 p_msg->rx_channel= rx_channel;
3427 p_msg->phy = phy;
3428 p_msg->modulation_index = modulation_index;
3429 p_msg->p_dtm_cmpl_cback = p_dtm_cmpl_cback;
3430
3431 bta_sys_sendmsg(p_msg);
3432 }
3433 }
3434
3435 #endif // #if (BLE_50_FEATURE_SUPPORT == TRUE)
3436
3437 #if (BLE_FEAT_PERIODIC_ADV_SYNC_TRANSFER == TRUE)
BTA_DmBleGapPeriodicAdvRecvEnable(UINT16 sync_handle,UINT8 enable)3438 void BTA_DmBleGapPeriodicAdvRecvEnable(UINT16 sync_handle, UINT8 enable)
3439 {
3440 tBTA_DM_API_PERIODIC_ADV_RECV_ENABLE *p_msg;
3441 p_msg = (tBTA_DM_API_PERIODIC_ADV_RECV_ENABLE *) osi_malloc(sizeof(tBTA_DM_API_PERIODIC_ADV_RECV_ENABLE));
3442 if (p_msg != NULL) {
3443 memset(p_msg, 0, sizeof(tBTA_DM_API_PERIODIC_ADV_RECV_ENABLE));
3444 p_msg->hdr.event = BTA_DM_API_PERIODIC_ADV_RECV_ENABLE_EVT;
3445 p_msg->sync_handle = sync_handle;
3446 p_msg->enable = enable;
3447 //start sent the msg to the bta system control module
3448 bta_sys_sendmsg(p_msg);
3449 } else {
3450 APPL_TRACE_ERROR("%s malloc failed", __func__);
3451 }
3452 }
3453
BTA_DmBleGapPeriodicAdvSyncTrans(BD_ADDR peer_addr,UINT16 service_data,UINT16 sync_handle)3454 void BTA_DmBleGapPeriodicAdvSyncTrans(BD_ADDR peer_addr, UINT16 service_data, UINT16 sync_handle)
3455 {
3456 tBTA_DM_API_PERIODIC_ADV_SYNC_TRANS *p_msg;
3457 p_msg = (tBTA_DM_API_PERIODIC_ADV_SYNC_TRANS *) osi_malloc(sizeof(tBTA_DM_API_PERIODIC_ADV_SYNC_TRANS));
3458 if (p_msg != NULL) {
3459 memset(p_msg, 0, sizeof(tBTA_DM_API_PERIODIC_ADV_SYNC_TRANS));
3460 p_msg->hdr.event = BTA_DM_API_PERIODIC_ADV_SYNC_TRANS_EVT;
3461 memcpy(p_msg->addr, peer_addr, sizeof(BD_ADDR));
3462 p_msg->service_data = service_data;
3463 p_msg->sync_handle = sync_handle;
3464 //start sent the msg to the bta system control module
3465 bta_sys_sendmsg(p_msg);
3466 } else {
3467 APPL_TRACE_ERROR("%s malloc failed", __func__);
3468 }
3469 }
3470
BTA_DmBleGapPeriodicAdvSetInfoTrans(BD_ADDR peer_addr,UINT16 service_data,UINT8 adv_handle)3471 void BTA_DmBleGapPeriodicAdvSetInfoTrans(BD_ADDR peer_addr, UINT16 service_data, UINT8 adv_handle)
3472 {
3473 tBTA_DM_API_PERIODIC_ADV_SET_INFO_TRANS *p_msg;
3474 p_msg = (tBTA_DM_API_PERIODIC_ADV_SET_INFO_TRANS *) osi_malloc(sizeof(tBTA_DM_API_PERIODIC_ADV_SET_INFO_TRANS));
3475 if (p_msg != NULL) {
3476 memset(p_msg, 0, sizeof(tBTA_DM_API_PERIODIC_ADV_SET_INFO_TRANS));
3477 p_msg->hdr.event = BTA_DM_API_PERIODIC_ADV_SET_INFO_TRANS_EVT;
3478 memcpy(p_msg->addr, peer_addr, sizeof(BD_ADDR));
3479 p_msg->service_data = service_data;
3480 p_msg->adv_hanlde = adv_handle;
3481 //start sent the msg to the bta system control module
3482 bta_sys_sendmsg(p_msg);
3483 } else {
3484 APPL_TRACE_ERROR("%s malloc failed", __func__);
3485 }
3486 }
3487
BTA_DmBleGapSetPeriodicAdvSyncTransParams(BD_ADDR peer_addr,tBTA_DM_BLE_PAST_PARAMS * params)3488 void BTA_DmBleGapSetPeriodicAdvSyncTransParams(BD_ADDR peer_addr, tBTA_DM_BLE_PAST_PARAMS *params)
3489 {
3490 tBTA_DM_API_SET_PAST_PARAMS *p_msg;
3491 p_msg = (tBTA_DM_API_SET_PAST_PARAMS *) osi_malloc(sizeof(tBTA_DM_API_SET_PAST_PARAMS));
3492 if (p_msg != NULL) {
3493 memset(p_msg, 0, sizeof(tBTA_DM_API_SET_PAST_PARAMS));
3494 p_msg->hdr.event = BTA_DM_API_SET_PERIODIC_ADV_SYNC_TRANS_PARAMS_EVT;
3495 memcpy(p_msg->addr, peer_addr, sizeof(BD_ADDR));
3496 memcpy(&p_msg->params, params, sizeof(tBTA_DM_BLE_PAST_PARAMS));
3497 //start sent the msg to the bta system control module
3498 bta_sys_sendmsg(p_msg);
3499 } else {
3500 APPL_TRACE_ERROR("%s malloc failed", __func__);
3501 }
3502 }
3503 #endif // #if (BLE_FEAT_PERIODIC_ADV_SYNC_TRANSFER == TRUE)
3504
3505 #endif
3506
