1 /******************************************************************************
2 *
3 * Copyright (C) 2014 The Android Open Source Project
4 * Copyright (C) 2009-2012 Broadcom Corporation
5 *
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at:
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 *
18 ******************************************************************************/
19
20 /************************************************************************************
21 *
22 * Filename: btif_core.c
23 *
24 * Description: Contains core functionality related to interfacing between
25 * Bluetooth HAL and BTE core stack.
26 *
27 ***********************************************************************************/
28
29 #include <stdlib.h>
30 #include <hardware/bluetooth.h>
31 #include <string.h>
32 #include <sys/types.h>
33 #include <sys/stat.h>
34 #include <fcntl.h>
35 #include <dirent.h>
36 #include <ctype.h>
37 #include <cutils/properties.h>
38
39 #define LOG_TAG "BTIF_CORE"
40 #include "btif_api.h"
41 #include "bt_utils.h"
42 #include "bta_api.h"
43 #include "gki.h"
44 #include "btu.h"
45 #include "bte.h"
46 #include "bd.h"
47 #include "btif_av.h"
48 #include "btif_storage.h"
49 #include "btif_util.h"
50 #include "btif_sock.h"
51 #include "btif_pan.h"
52 #include "btif_mce.h"
53 #include "btif_profile_queue.h"
54 #include "btif_config.h"
55 /************************************************************************************
56 ** Constants & Macros
57 ************************************************************************************/
58
59 #ifndef BTIF_TASK_STACK_SIZE
60 #define BTIF_TASK_STACK_SIZE 0x2000 /* In bytes */
61 #endif
62
63 #ifndef BTE_DID_CONF_FILE
64 #define BTE_DID_CONF_FILE "/etc/bluetooth/bt_did.conf"
65 #endif
66
67 #define BTIF_TASK_STR ((INT8 *) "BTIF")
68
69 /************************************************************************************
70 ** Local type definitions
71 ************************************************************************************/
72
73 /* These type definitions are used when passing data from the HAL to BTIF context
74 * in the downstream path for the adapter and remote_device property APIs */
75
76 typedef struct {
77 bt_bdaddr_t bd_addr;
78 bt_property_type_t type;
79 } btif_storage_read_t;
80
81 typedef struct {
82 bt_bdaddr_t bd_addr;
83 bt_property_t prop;
84 } btif_storage_write_t;
85
86 typedef union {
87 btif_storage_read_t read_req;
88 btif_storage_write_t write_req;
89 } btif_storage_req_t;
90
91 typedef enum {
92 BTIF_CORE_STATE_DISABLED = 0,
93 BTIF_CORE_STATE_ENABLING,
94 BTIF_CORE_STATE_ENABLED,
95 BTIF_CORE_STATE_DISABLING
96 } btif_core_state_t;
97
98 /************************************************************************************
99 ** Static variables
100 ************************************************************************************/
101
102 bt_bdaddr_t btif_local_bd_addr;
103
104 static UINT32 btif_task_stack[(BTIF_TASK_STACK_SIZE + 3) / 4];
105
106 /* holds main adapter state */
107 static btif_core_state_t btif_core_state = BTIF_CORE_STATE_DISABLED;
108
109 static int btif_shutdown_pending = 0;
110 static tBTA_SERVICE_MASK btif_enabled_services = 0;
111
112 /*
113 * This variable should be set to 1, if the Bluedroid+BTIF libraries are to
114 * function in DUT mode.
115 *
116 * To set this, the btif_init_bluetooth needs to be called with argument as 1
117 */
118 static UINT8 btif_dut_mode = 0;
119
120 /************************************************************************************
121 ** Static functions
122 ************************************************************************************/
123 static bt_status_t btif_associate_evt(void);
124 static bt_status_t btif_disassociate_evt(void);
125
126 /* sends message to btif task */
127 static void btif_sendmsg(void *p_msg);
128
129 /************************************************************************************
130 ** Externs
131 ************************************************************************************/
132 extern void bte_load_did_conf(const char *p_path);
133
134 /** TODO: Move these to _common.h */
135 void bte_main_boot_entry(void);
136 void bte_main_enable();
137 void bte_main_disable(void);
138 void bte_main_shutdown(void);
139 #if (defined(HCILP_INCLUDED) && HCILP_INCLUDED == TRUE)
140 void bte_main_enable_lpm(BOOLEAN enable);
141 #endif
142 void bte_main_postload_cfg(void);
143 void btif_dm_execute_service_request(UINT16 event, char *p_param);
144 #ifdef BTIF_DM_OOB_TEST
145 void btif_dm_load_local_oob(void);
146 #endif
147 void bte_main_config_hci_logging(BOOLEAN enable, BOOLEAN bt_disabled);
148
149 /************************************************************************************
150 ** Functions
151 ************************************************************************************/
152
153
154 /*****************************************************************************
155 ** Context switching functions
156 *****************************************************************************/
157
158
159 /*******************************************************************************
160 **
161 ** Function btif_context_switched
162 **
163 ** Description Callback used to execute transferred context callback
164 **
165 ** p_msg : message to be executed in btif context
166 **
167 ** Returns void
168 **
169 *******************************************************************************/
170
btif_context_switched(void * p_msg)171 static void btif_context_switched(void *p_msg)
172 {
173 tBTIF_CONTEXT_SWITCH_CBACK *p;
174
175 BTIF_TRACE_VERBOSE("btif_context_switched");
176
177 p = (tBTIF_CONTEXT_SWITCH_CBACK *) p_msg;
178
179 /* each callback knows how to parse the data */
180 if (p->p_cb)
181 p->p_cb(p->event, p->p_param);
182 }
183
184
185 /*******************************************************************************
186 **
187 ** Function btif_transfer_context
188 **
189 ** Description This function switches context to btif task
190 **
191 ** p_cback : callback used to process message in btif context
192 ** event : event id of message
193 ** p_params : parameter area passed to callback (copied)
194 ** param_len : length of parameter area
195 ** p_copy_cback : If set this function will be invoked for deep copy
196 **
197 ** Returns void
198 **
199 *******************************************************************************/
200
btif_transfer_context(tBTIF_CBACK * p_cback,UINT16 event,char * p_params,int param_len,tBTIF_COPY_CBACK * p_copy_cback)201 bt_status_t btif_transfer_context (tBTIF_CBACK *p_cback, UINT16 event, char* p_params, int param_len, tBTIF_COPY_CBACK *p_copy_cback)
202 {
203 tBTIF_CONTEXT_SWITCH_CBACK *p_msg;
204
205 BTIF_TRACE_VERBOSE("btif_transfer_context event %d, len %d", event, param_len);
206
207 /* allocate and send message that will be executed in btif context */
208 if ((p_msg = (tBTIF_CONTEXT_SWITCH_CBACK *) GKI_getbuf(sizeof(tBTIF_CONTEXT_SWITCH_CBACK) + param_len)) != NULL)
209 {
210 p_msg->hdr.event = BT_EVT_CONTEXT_SWITCH_EVT; /* internal event */
211 p_msg->p_cb = p_cback;
212
213 p_msg->event = event; /* callback event */
214
215 /* check if caller has provided a copy callback to do the deep copy */
216 if (p_copy_cback)
217 {
218 p_copy_cback(event, p_msg->p_param, p_params);
219 }
220 else if (p_params)
221 {
222 memcpy(p_msg->p_param, p_params, param_len); /* callback parameter data */
223 }
224
225 btif_sendmsg(p_msg);
226 return BT_STATUS_SUCCESS;
227 }
228 else
229 {
230 /* let caller deal with a failed allocation */
231 return BT_STATUS_NOMEM;
232 }
233 }
234
235 /*******************************************************************************
236 **
237 ** Function btif_is_dut_mode
238 **
239 ** Description checks if BTIF is currently in DUT mode
240 **
241 ** Returns 1 if test mode, otherwize 0
242 **
243 *******************************************************************************/
244
btif_is_dut_mode(void)245 UINT8 btif_is_dut_mode(void)
246 {
247 return (btif_dut_mode == 1);
248 }
249
250 /*******************************************************************************
251 **
252 ** Function btif_is_enabled
253 **
254 ** Description checks if main adapter is fully enabled
255 **
256 ** Returns 1 if fully enabled, otherwize 0
257 **
258 *******************************************************************************/
259
btif_is_enabled(void)260 int btif_is_enabled(void)
261 {
262 return ((!btif_is_dut_mode()) && (btif_core_state == BTIF_CORE_STATE_ENABLED));
263 }
264
265 /*******************************************************************************
266 **
267 ** Function btif_task
268 **
269 ** Description BTIF task handler managing all messages being passed
270 ** Bluetooth HAL and BTA.
271 **
272 ** Returns void
273 **
274 *******************************************************************************/
275
btif_task(UINT32 params)276 static void btif_task(UINT32 params)
277 {
278 UINT16 event;
279 BT_HDR *p_msg;
280 UNUSED(params);
281
282 BTIF_TRACE_DEBUG("btif task starting");
283
284 btif_associate_evt();
285
286 for(;;)
287 {
288 /* wait for specified events */
289 event = GKI_wait(0xFFFF, 0);
290
291 /*
292 * Wait for the trigger to init chip and stack. This trigger will
293 * be received by btu_task once the UART is opened and ready
294 */
295 if (event == BT_EVT_TRIGGER_STACK_INIT)
296 {
297 BTIF_TRACE_DEBUG("btif_task: received trigger stack init event");
298 #if (BLE_INCLUDED == TRUE)
299 btif_dm_load_ble_local_keys();
300 #endif
301 BTA_EnableBluetooth(bte_dm_evt);
302 }
303
304 /*
305 * Failed to initialize controller hardware, reset state and bring
306 * down all threads
307 */
308 if (event == BT_EVT_HARDWARE_INIT_FAIL)
309 {
310 BTIF_TRACE_DEBUG("btif_task: hardware init failed");
311 bte_main_disable();
312 btif_queue_release();
313 GKI_task_self_cleanup(BTIF_TASK);
314 bte_main_shutdown();
315 btif_dut_mode = 0;
316 btif_core_state = BTIF_CORE_STATE_DISABLED;
317 HAL_CBACK(bt_hal_cbacks,adapter_state_changed_cb,BT_STATE_OFF);
318 break;
319 }
320
321 if (event & EVENT_MASK(GKI_SHUTDOWN_EVT))
322 break;
323
324 if(event & TASK_MBOX_1_EVT_MASK)
325 {
326 while((p_msg = GKI_read_mbox(BTU_BTIF_MBOX)) != NULL)
327 {
328 BTIF_TRACE_VERBOSE("btif task fetched event %x", p_msg->event);
329
330 switch (p_msg->event)
331 {
332 case BT_EVT_CONTEXT_SWITCH_EVT:
333 btif_context_switched(p_msg);
334 break;
335 default:
336 BTIF_TRACE_ERROR("unhandled btif event (%d)", p_msg->event & BT_EVT_MASK);
337 break;
338 }
339
340 GKI_freebuf(p_msg);
341 }
342 }
343 }
344
345 btif_disassociate_evt();
346
347 BTIF_TRACE_DEBUG("btif task exiting");
348 }
349
350
351 /*******************************************************************************
352 **
353 ** Function btif_sendmsg
354 **
355 ** Description Sends msg to BTIF task
356 **
357 ** Returns void
358 **
359 *******************************************************************************/
360
btif_sendmsg(void * p_msg)361 void btif_sendmsg(void *p_msg)
362 {
363 GKI_send_msg(BTIF_TASK, BTU_BTIF_MBOX, p_msg);
364 }
365
btif_fetch_local_bdaddr(bt_bdaddr_t * local_addr)366 static void btif_fetch_local_bdaddr(bt_bdaddr_t *local_addr)
367 {
368 char val[256];
369 uint8_t valid_bda = FALSE;
370 int val_size = 0;
371 const uint8_t null_bdaddr[BD_ADDR_LEN] = {0,0,0,0,0,0};
372
373 /* Get local bdaddr storage path from property */
374 if (property_get(PROPERTY_BT_BDADDR_PATH, val, NULL))
375 {
376 int addr_fd;
377
378 BTIF_TRACE_DEBUG("local bdaddr is stored in %s", val);
379
380 if ((addr_fd = open(val, O_RDONLY)) != -1)
381 {
382 memset(val, 0, sizeof(val));
383 read(addr_fd, val, FACTORY_BT_BDADDR_STORAGE_LEN);
384 str2bd(val, local_addr);
385 /* If this is not a reserved/special bda, then use it */
386 if (memcmp(local_addr->address, null_bdaddr, BD_ADDR_LEN) != 0)
387 {
388 valid_bda = TRUE;
389 BTIF_TRACE_DEBUG("Got Factory BDA %02X:%02X:%02X:%02X:%02X:%02X",
390 local_addr->address[0], local_addr->address[1], local_addr->address[2],
391 local_addr->address[3], local_addr->address[4], local_addr->address[5]);
392 }
393
394 close(addr_fd);
395 }
396 }
397
398 if(!valid_bda)
399 {
400 val_size = sizeof(val);
401 if(btif_config_get_str("Local", "Adapter", "Address", val, &val_size))
402 {
403 str2bd(val, local_addr);
404 BTIF_TRACE_DEBUG("local bdaddr from bt_config.xml is %s", val);
405 return;
406 }
407 }
408
409 /* No factory BDADDR found. Look for previously generated random BDA */
410 if ((!valid_bda) && \
411 (property_get(PERSIST_BDADDR_PROPERTY, val, NULL)))
412 {
413 str2bd(val, local_addr);
414 valid_bda = TRUE;
415 BTIF_TRACE_DEBUG("Got prior random BDA %02X:%02X:%02X:%02X:%02X:%02X",
416 local_addr->address[0], local_addr->address[1], local_addr->address[2],
417 local_addr->address[3], local_addr->address[4], local_addr->address[5]);
418 }
419
420 /* Generate new BDA if necessary */
421 if (!valid_bda)
422 {
423 bdstr_t bdstr;
424 /* Seed the random number generator */
425 srand((unsigned int) (time(0)));
426
427 /* No autogen BDA. Generate one now. */
428 local_addr->address[0] = 0x22;
429 local_addr->address[1] = 0x22;
430 local_addr->address[2] = (uint8_t) ((rand() >> 8) & 0xFF);
431 local_addr->address[3] = (uint8_t) ((rand() >> 8) & 0xFF);
432 local_addr->address[4] = (uint8_t) ((rand() >> 8) & 0xFF);
433 local_addr->address[5] = (uint8_t) ((rand() >> 8) & 0xFF);
434
435 /* Convert to ascii, and store as a persistent property */
436 bd2str(local_addr, &bdstr);
437
438 BTIF_TRACE_DEBUG("No preset BDA. Generating BDA: %s for prop %s",
439 (char*)bdstr, PERSIST_BDADDR_PROPERTY);
440
441 if (property_set(PERSIST_BDADDR_PROPERTY, (char*)bdstr) < 0)
442 BTIF_TRACE_ERROR("Failed to set random BDA in prop %s",PERSIST_BDADDR_PROPERTY);
443 }
444
445 //save the bd address to config file
446 bdstr_t bdstr;
447 bd2str(local_addr, &bdstr);
448 val_size = sizeof(val);
449 if (btif_config_get_str("Local", "Adapter", "Address", val, &val_size))
450 {
451 if (strcmp(bdstr, val) ==0)
452 {
453 // BDA is already present in the config file.
454 return;
455 }
456 }
457 btif_config_set_str("Local", "Adapter", "Address", bdstr);
458 btif_config_save();
459 }
460
461 /*****************************************************************************
462 **
463 ** btif core api functions
464 **
465 *****************************************************************************/
466
467 /*******************************************************************************
468 **
469 ** Function btif_init_bluetooth
470 **
471 ** Description Creates BTIF task and prepares BT scheduler for startup
472 **
473 ** Returns bt_status_t
474 **
475 *******************************************************************************/
476
btif_init_bluetooth()477 bt_status_t btif_init_bluetooth()
478 {
479 UINT8 status;
480 btif_config_init();
481 bte_main_boot_entry();
482
483 /* As part of the init, fetch the local BD ADDR */
484 memset(&btif_local_bd_addr, 0, sizeof(bt_bdaddr_t));
485 btif_fetch_local_bdaddr(&btif_local_bd_addr);
486
487 /* start btif task */
488 status = GKI_create_task(btif_task, BTIF_TASK, BTIF_TASK_STR,
489 (UINT16 *) ((UINT8 *)btif_task_stack + BTIF_TASK_STACK_SIZE),
490 sizeof(btif_task_stack));
491
492 if (status != GKI_SUCCESS)
493 return BT_STATUS_FAIL;
494
495 return BT_STATUS_SUCCESS;
496 }
497
498 /*******************************************************************************
499 **
500 ** Function btif_associate_evt
501 **
502 ** Description Event indicating btif_task is up
503 ** Attach btif_task to JVM
504 **
505 ** Returns void
506 **
507 *******************************************************************************/
508
btif_associate_evt(void)509 static bt_status_t btif_associate_evt(void)
510 {
511 BTIF_TRACE_DEBUG("%s: notify ASSOCIATE_JVM", __FUNCTION__);
512 HAL_CBACK(bt_hal_cbacks, thread_evt_cb, ASSOCIATE_JVM);
513
514 return BT_STATUS_SUCCESS;
515 }
516
517
518 /*******************************************************************************
519 **
520 ** Function btif_enable_bluetooth
521 **
522 ** Description Performs chip power on and kickstarts OS scheduler
523 **
524 ** Returns bt_status_t
525 **
526 *******************************************************************************/
527
btif_enable_bluetooth(void)528 bt_status_t btif_enable_bluetooth(void)
529 {
530 BTIF_TRACE_DEBUG("BTIF ENABLE BLUETOOTH");
531
532 if (btif_core_state != BTIF_CORE_STATE_DISABLED)
533 {
534 ALOGD("not disabled\n");
535 return BT_STATUS_DONE;
536 }
537
538 btif_core_state = BTIF_CORE_STATE_ENABLING;
539
540 /* Create the GKI tasks and run them */
541 bte_main_enable();
542
543 return BT_STATUS_SUCCESS;
544 }
545
546
547 /*******************************************************************************
548 **
549 ** Function btif_enable_bluetooth_evt
550 **
551 ** Description Event indicating bluetooth enable is completed
552 ** Notifies HAL user with updated adapter state
553 **
554 ** Returns void
555 **
556 *******************************************************************************/
557
btif_enable_bluetooth_evt(tBTA_STATUS status,BD_ADDR local_bd)558 void btif_enable_bluetooth_evt(tBTA_STATUS status, BD_ADDR local_bd)
559 {
560 bt_bdaddr_t bd_addr;
561 bdstr_t bdstr;
562
563 bdcpy(bd_addr.address, local_bd);
564 BTIF_TRACE_DEBUG("%s: status %d, local bd [%s]", __FUNCTION__, status,
565 bd2str(&bd_addr, &bdstr));
566
567 if (bdcmp(btif_local_bd_addr.address,local_bd))
568 {
569 bdstr_t buf;
570 bt_property_t prop;
571
572 /**
573 * The Controller's BDADDR does not match to the BTIF's initial BDADDR!
574 * This could be because the factory BDADDR was stored separatley in
575 * the Controller's non-volatile memory rather than in device's file
576 * system.
577 **/
578 BTIF_TRACE_WARNING("***********************************************");
579 BTIF_TRACE_WARNING("BTIF init BDA was %02X:%02X:%02X:%02X:%02X:%02X",
580 btif_local_bd_addr.address[0], btif_local_bd_addr.address[1],
581 btif_local_bd_addr.address[2], btif_local_bd_addr.address[3],
582 btif_local_bd_addr.address[4], btif_local_bd_addr.address[5]);
583 BTIF_TRACE_WARNING("Controller BDA is %02X:%02X:%02X:%02X:%02X:%02X",
584 local_bd[0], local_bd[1], local_bd[2],
585 local_bd[3], local_bd[4], local_bd[5]);
586 BTIF_TRACE_WARNING("***********************************************");
587
588 bdcpy(btif_local_bd_addr.address, local_bd);
589
590 //save the bd address to config file
591 bd2str(&btif_local_bd_addr, &buf);
592 btif_config_set_str("Local", "Adapter", "Address", buf);
593 btif_config_save();
594
595 //fire HAL callback for property change
596 memcpy(buf, &btif_local_bd_addr, sizeof(bt_bdaddr_t));
597 prop.type = BT_PROPERTY_BDADDR;
598 prop.val = (void*)buf;
599 prop.len = sizeof(bt_bdaddr_t);
600 HAL_CBACK(bt_hal_cbacks, adapter_properties_cb, BT_STATUS_SUCCESS, 1, &prop);
601 }
602
603 bte_main_postload_cfg();
604 #if (defined(HCILP_INCLUDED) && HCILP_INCLUDED == TRUE)
605 bte_main_enable_lpm(TRUE);
606 #endif
607 /* add passing up bd address as well ? */
608
609 /* callback to HAL */
610 if (status == BTA_SUCCESS)
611 {
612 /* initialize a2dp service */
613 btif_av_init();
614
615 /* init rfcomm & l2cap api */
616 btif_sock_init();
617
618 /* init pan */
619 btif_pan_init();
620
621 /* load did configuration */
622 bte_load_did_conf(BTE_DID_CONF_FILE);
623
624 #ifdef BTIF_DM_OOB_TEST
625 btif_dm_load_local_oob();
626 #endif
627 /* now fully enabled, update state */
628 btif_core_state = BTIF_CORE_STATE_ENABLED;
629
630 HAL_CBACK(bt_hal_cbacks, adapter_state_changed_cb, BT_STATE_ON);
631 }
632 else
633 {
634 /* cleanup rfcomm & l2cap api */
635 btif_sock_cleanup();
636
637 btif_pan_cleanup();
638
639 /* we failed to enable, reset state */
640 btif_core_state = BTIF_CORE_STATE_DISABLED;
641
642 HAL_CBACK(bt_hal_cbacks, adapter_state_changed_cb, BT_STATE_OFF);
643 }
644 }
645
646 /*******************************************************************************
647 **
648 ** Function btif_disable_bluetooth
649 **
650 ** Description Inititates shutdown of Bluetooth system.
651 ** Any active links will be dropped and device entering
652 ** non connectable/discoverable mode
653 **
654 ** Returns void
655 **
656 *******************************************************************************/
btif_disable_bluetooth(void)657 bt_status_t btif_disable_bluetooth(void)
658 {
659 tBTA_STATUS status;
660
661 if (!btif_is_enabled())
662 {
663 BTIF_TRACE_ERROR("btif_disable_bluetooth : not yet enabled");
664 return BT_STATUS_NOT_READY;
665 }
666
667 BTIF_TRACE_DEBUG("BTIF DISABLE BLUETOOTH");
668
669 btif_dm_on_disable();
670 btif_core_state = BTIF_CORE_STATE_DISABLING;
671
672 /* cleanup rfcomm & l2cap api */
673 btif_sock_cleanup();
674
675 btif_pan_cleanup();
676
677 status = BTA_DisableBluetooth();
678
679 btif_config_flush();
680
681 if (status != BTA_SUCCESS)
682 {
683 BTIF_TRACE_ERROR("disable bt failed (%d)", status);
684
685 /* reset the original state to allow attempting disable again */
686 btif_core_state = BTIF_CORE_STATE_ENABLED;
687
688 return BT_STATUS_FAIL;
689 }
690 return BT_STATUS_SUCCESS;
691 }
692
693 /*******************************************************************************
694 **
695 ** Function btif_disable_bluetooth_evt
696 **
697 ** Description Event notifying BT disable is now complete.
698 ** Terminates main stack tasks and notifies HAL
699 ** user with updated BT state.
700 **
701 ** Returns void
702 **
703 *******************************************************************************/
704
btif_disable_bluetooth_evt(void)705 void btif_disable_bluetooth_evt(void)
706 {
707 BTIF_TRACE_DEBUG("%s", __FUNCTION__);
708
709 #if (defined(HCILP_INCLUDED) && HCILP_INCLUDED == TRUE)
710 bte_main_enable_lpm(FALSE);
711 #endif
712
713 #if (BLE_INCLUDED == TRUE)
714 BTA_VendorCleanup();
715 #endif
716
717 bte_main_disable();
718
719 /* update local state */
720 btif_core_state = BTIF_CORE_STATE_DISABLED;
721
722 /* callback to HAL */
723 HAL_CBACK(bt_hal_cbacks, adapter_state_changed_cb, BT_STATE_OFF);
724
725 if (btif_shutdown_pending)
726 {
727 BTIF_TRACE_DEBUG("%s: calling btif_shutdown_bluetooth", __FUNCTION__);
728 btif_shutdown_bluetooth();
729 }
730 }
731
732
733 /*******************************************************************************
734 **
735 ** Function btif_shutdown_bluetooth
736 **
737 ** Description Finalizes BT scheduler shutdown and terminates BTIF
738 ** task.
739 **
740 ** Returns void
741 **
742 *******************************************************************************/
743
btif_shutdown_bluetooth(void)744 bt_status_t btif_shutdown_bluetooth(void)
745 {
746 BTIF_TRACE_DEBUG("%s", __FUNCTION__);
747
748 if (btif_core_state == BTIF_CORE_STATE_DISABLING)
749 {
750 BTIF_TRACE_WARNING("shutdown during disabling");
751 /* shutdown called before disabling is done */
752 btif_shutdown_pending = 1;
753 return BT_STATUS_NOT_READY;
754 }
755
756 if (btif_is_enabled())
757 {
758 BTIF_TRACE_WARNING("shutdown while still enabled, initiate disable");
759
760 /* shutdown called prior to disabling, initiate disable */
761 btif_disable_bluetooth();
762 btif_shutdown_pending = 1;
763 return BT_STATUS_NOT_READY;
764 }
765
766 btif_shutdown_pending = 0;
767
768 if (btif_core_state == BTIF_CORE_STATE_ENABLING)
769 {
770 // Java layer abort BT ENABLING, could be due to ENABLE TIMEOUT
771 // Direct call from cleanup()@bluetooth.c
772 // bring down HCI/Vendor lib
773 bte_main_disable();
774 btif_core_state = BTIF_CORE_STATE_DISABLED;
775 HAL_CBACK(bt_hal_cbacks, adapter_state_changed_cb, BT_STATE_OFF);
776 }
777
778 GKI_destroy_task(BTIF_TASK);
779 btif_queue_release();
780 bte_main_shutdown();
781
782 btif_dut_mode = 0;
783
784 bt_utils_cleanup();
785
786 BTIF_TRACE_DEBUG("%s done", __FUNCTION__);
787
788 return BT_STATUS_SUCCESS;
789 }
790
791
792 /*******************************************************************************
793 **
794 ** Function btif_disassociate_evt
795 **
796 ** Description Event indicating btif_task is going down
797 ** Detach btif_task to JVM
798 **
799 ** Returns void
800 **
801 *******************************************************************************/
802
btif_disassociate_evt(void)803 static bt_status_t btif_disassociate_evt(void)
804 {
805 BTIF_TRACE_DEBUG("%s: notify DISASSOCIATE_JVM", __FUNCTION__);
806
807 HAL_CBACK(bt_hal_cbacks, thread_evt_cb, DISASSOCIATE_JVM);
808
809 /* shutdown complete, all events notified and we reset HAL callbacks */
810 bt_hal_cbacks = NULL;
811
812 return BT_STATUS_SUCCESS;
813 }
814
815 /****************************************************************************
816 **
817 ** BTIF Test Mode APIs
818 **
819 *****************************************************************************/
820 /*******************************************************************************
821 **
822 ** Function btif_dut_mode_cback
823 **
824 ** Description Callback invoked on completion of vendor specific test mode command
825 **
826 ** Returns None
827 **
828 *******************************************************************************/
btif_dut_mode_cback(tBTM_VSC_CMPL * p)829 static void btif_dut_mode_cback( tBTM_VSC_CMPL *p )
830 {
831 UNUSED(p);
832 /* For now nothing to be done. */
833 }
834
835 /*******************************************************************************
836 **
837 ** Function btif_dut_mode_configure
838 **
839 ** Description Configure Test Mode - 'enable' to 1 puts the device in test mode and 0 exits
840 ** test mode
841 **
842 ** Returns BT_STATUS_SUCCESS on success
843 **
844 *******************************************************************************/
btif_dut_mode_configure(uint8_t enable)845 bt_status_t btif_dut_mode_configure(uint8_t enable)
846 {
847 BTIF_TRACE_DEBUG("%s", __FUNCTION__);
848
849 if (btif_core_state != BTIF_CORE_STATE_ENABLED) {
850 BTIF_TRACE_ERROR("btif_dut_mode_configure : Bluetooth not enabled");
851 return BT_STATUS_NOT_READY;
852 }
853
854 btif_dut_mode = enable;
855 if (enable == 1) {
856 BTA_EnableTestMode();
857 } else {
858 BTA_DisableTestMode();
859 }
860 return BT_STATUS_SUCCESS;
861 }
862
863 /*******************************************************************************
864 **
865 ** Function btif_dut_mode_send
866 **
867 ** Description Sends a HCI Vendor specific command to the controller
868 **
869 ** Returns BT_STATUS_SUCCESS on success
870 **
871 *******************************************************************************/
btif_dut_mode_send(uint16_t opcode,uint8_t * buf,uint8_t len)872 bt_status_t btif_dut_mode_send(uint16_t opcode, uint8_t *buf, uint8_t len)
873 {
874 /* TODO: Check that opcode is a vendor command group */
875 BTIF_TRACE_DEBUG("%s", __FUNCTION__);
876 if (!btif_is_dut_mode()) {
877 BTIF_TRACE_ERROR("Bluedroid HAL needs to be init with test_mode set to 1.");
878 return BT_STATUS_FAIL;
879 }
880 BTM_VendorSpecificCommand(opcode, len, buf, btif_dut_mode_cback);
881 return BT_STATUS_SUCCESS;
882 }
883
884 /*****************************************************************************
885 **
886 ** btif api adapter property functions
887 **
888 *****************************************************************************/
889
btif_in_get_adapter_properties(void)890 static bt_status_t btif_in_get_adapter_properties(void)
891 {
892 bt_property_t properties[6];
893 uint32_t num_props;
894
895 bt_bdaddr_t addr;
896 bt_bdname_t name;
897 bt_scan_mode_t mode;
898 uint32_t disc_timeout;
899 bt_bdaddr_t bonded_devices[BTM_SEC_MAX_DEVICE_RECORDS];
900 bt_uuid_t local_uuids[BT_MAX_NUM_UUIDS];
901 num_props = 0;
902
903 /* BD_ADDR */
904 BTIF_STORAGE_FILL_PROPERTY(&properties[num_props], BT_PROPERTY_BDADDR,
905 sizeof(addr), &addr);
906 btif_storage_get_adapter_property(&properties[num_props]);
907 num_props++;
908
909 /* BD_NAME */
910 BTIF_STORAGE_FILL_PROPERTY(&properties[num_props], BT_PROPERTY_BDNAME,
911 sizeof(name), &name);
912 btif_storage_get_adapter_property(&properties[num_props]);
913 num_props++;
914
915 /* SCAN_MODE */
916 BTIF_STORAGE_FILL_PROPERTY(&properties[num_props], BT_PROPERTY_ADAPTER_SCAN_MODE,
917 sizeof(mode), &mode);
918 btif_storage_get_adapter_property(&properties[num_props]);
919 num_props++;
920
921 /* DISC_TIMEOUT */
922 BTIF_STORAGE_FILL_PROPERTY(&properties[num_props], BT_PROPERTY_ADAPTER_DISCOVERY_TIMEOUT,
923 sizeof(disc_timeout), &disc_timeout);
924 btif_storage_get_adapter_property(&properties[num_props]);
925 num_props++;
926
927 /* BONDED_DEVICES */
928 BTIF_STORAGE_FILL_PROPERTY(&properties[num_props], BT_PROPERTY_ADAPTER_BONDED_DEVICES,
929 sizeof(bonded_devices), bonded_devices);
930 btif_storage_get_adapter_property(&properties[num_props]);
931 num_props++;
932
933 /* LOCAL UUIDs */
934 BTIF_STORAGE_FILL_PROPERTY(&properties[num_props], BT_PROPERTY_UUIDS,
935 sizeof(local_uuids), local_uuids);
936 btif_storage_get_adapter_property(&properties[num_props]);
937 num_props++;
938
939 HAL_CBACK(bt_hal_cbacks, adapter_properties_cb,
940 BT_STATUS_SUCCESS, num_props, properties);
941
942 return BT_STATUS_SUCCESS;
943 }
944
btif_in_get_remote_device_properties(bt_bdaddr_t * bd_addr)945 static bt_status_t btif_in_get_remote_device_properties(bt_bdaddr_t *bd_addr)
946 {
947 bt_property_t remote_properties[8];
948 uint32_t num_props = 0;
949
950 bt_bdname_t name, alias;
951 uint32_t cod, devtype;
952 bt_uuid_t remote_uuids[BT_MAX_NUM_UUIDS];
953
954 memset(remote_properties, 0, sizeof(remote_properties));
955 BTIF_STORAGE_FILL_PROPERTY(&remote_properties[num_props], BT_PROPERTY_BDNAME,
956 sizeof(name), &name);
957 btif_storage_get_remote_device_property(bd_addr,
958 &remote_properties[num_props]);
959 num_props++;
960
961 BTIF_STORAGE_FILL_PROPERTY(&remote_properties[num_props], BT_PROPERTY_REMOTE_FRIENDLY_NAME,
962 sizeof(alias), &alias);
963 btif_storage_get_remote_device_property(bd_addr,
964 &remote_properties[num_props]);
965 num_props++;
966
967 BTIF_STORAGE_FILL_PROPERTY(&remote_properties[num_props], BT_PROPERTY_CLASS_OF_DEVICE,
968 sizeof(cod), &cod);
969 btif_storage_get_remote_device_property(bd_addr,
970 &remote_properties[num_props]);
971 num_props++;
972
973 BTIF_STORAGE_FILL_PROPERTY(&remote_properties[num_props], BT_PROPERTY_TYPE_OF_DEVICE,
974 sizeof(devtype), &devtype);
975 btif_storage_get_remote_device_property(bd_addr,
976 &remote_properties[num_props]);
977 num_props++;
978
979 BTIF_STORAGE_FILL_PROPERTY(&remote_properties[num_props], BT_PROPERTY_UUIDS,
980 sizeof(remote_uuids), remote_uuids);
981 btif_storage_get_remote_device_property(bd_addr,
982 &remote_properties[num_props]);
983 num_props++;
984
985 HAL_CBACK(bt_hal_cbacks, remote_device_properties_cb,
986 BT_STATUS_SUCCESS, bd_addr, num_props, remote_properties);
987
988 return BT_STATUS_SUCCESS;
989 }
990
991
992 /*******************************************************************************
993 **
994 ** Function execute_storage_request
995 **
996 ** Description Executes adapter storage request in BTIF context
997 **
998 ** Returns bt_status_t
999 **
1000 *******************************************************************************/
1001
execute_storage_request(UINT16 event,char * p_param)1002 static void execute_storage_request(UINT16 event, char *p_param)
1003 {
1004 uint8_t is_local;
1005 int num_entries = 0;
1006 bt_status_t status = BT_STATUS_SUCCESS;
1007
1008 BTIF_TRACE_EVENT("execute storage request event : %d", event);
1009
1010 switch(event)
1011 {
1012 case BTIF_CORE_STORAGE_ADAPTER_WRITE:
1013 {
1014 btif_storage_req_t *p_req = (btif_storage_req_t*)p_param;
1015 bt_property_t *p_prop = &(p_req->write_req.prop);
1016 BTIF_TRACE_EVENT("type: %d, len %d, 0x%x", p_prop->type,
1017 p_prop->len, p_prop->val);
1018
1019 status = btif_storage_set_adapter_property(p_prop);
1020 HAL_CBACK(bt_hal_cbacks, adapter_properties_cb, status, 1, p_prop);
1021 } break;
1022
1023 case BTIF_CORE_STORAGE_ADAPTER_READ:
1024 {
1025 btif_storage_req_t *p_req = (btif_storage_req_t*)p_param;
1026 char buf[512];
1027 bt_property_t prop;
1028 prop.type = p_req->read_req.type;
1029 prop.val = (void*)buf;
1030 prop.len = sizeof(buf);
1031 if (prop.type == BT_PROPERTY_LOCAL_LE_FEATURES)
1032 {
1033 #if (BLE_INCLUDED == TRUE)
1034 tBTM_BLE_VSC_CB cmn_vsc_cb;
1035 bt_local_le_features_t local_le_features;
1036
1037 /* LE features are not stored in storage. Should be retrived from stack */
1038 BTM_BleGetVendorCapabilities(&cmn_vsc_cb);
1039 local_le_features.local_privacy_enabled = BTM_BleLocalPrivacyEnabled();
1040
1041 prop.len = sizeof (bt_local_le_features_t);
1042 if (cmn_vsc_cb.filter_support == 1)
1043 local_le_features.max_adv_filter_supported = cmn_vsc_cb.max_filter;
1044 else
1045 local_le_features.max_adv_filter_supported = 0;
1046 local_le_features.max_adv_instance = cmn_vsc_cb.adv_inst_max;
1047 local_le_features.max_irk_list_size = cmn_vsc_cb.max_irk_list_sz;
1048 local_le_features.rpa_offload_supported = cmn_vsc_cb.rpa_offloading;
1049 local_le_features.scan_result_storage_size_hibyte =
1050 (cmn_vsc_cb.tot_scan_results_strg >> 8) & (0xFF);
1051 local_le_features.scan_result_storage_size_lobyte =
1052 (cmn_vsc_cb.tot_scan_results_strg) & (0xFF);
1053 local_le_features.activity_energy_info_supported = cmn_vsc_cb.energy_support;
1054 memcpy(prop.val, &local_le_features, prop.len);
1055 #endif
1056 }
1057 else
1058 {
1059 status = btif_storage_get_adapter_property(&prop);
1060 }
1061 HAL_CBACK(bt_hal_cbacks, adapter_properties_cb, status, 1, &prop);
1062 } break;
1063
1064 case BTIF_CORE_STORAGE_ADAPTER_READ_ALL:
1065 {
1066 status = btif_in_get_adapter_properties();
1067 } break;
1068
1069 case BTIF_CORE_STORAGE_NOTIFY_STATUS:
1070 {
1071 HAL_CBACK(bt_hal_cbacks, adapter_properties_cb, status, 0, NULL);
1072 } break;
1073
1074 default:
1075 BTIF_TRACE_ERROR("%s invalid event id (%d)", __FUNCTION__, event);
1076 break;
1077 }
1078 }
1079
execute_storage_remote_request(UINT16 event,char * p_param)1080 static void execute_storage_remote_request(UINT16 event, char *p_param)
1081 {
1082 bt_status_t status = BT_STATUS_FAIL;
1083 bt_property_t prop;
1084
1085 BTIF_TRACE_EVENT("execute storage remote request event : %d", event);
1086
1087 switch (event)
1088 {
1089 case BTIF_CORE_STORAGE_REMOTE_READ:
1090 {
1091 char buf[1024];
1092 btif_storage_req_t *p_req = (btif_storage_req_t*)p_param;
1093 prop.type = p_req->read_req.type;
1094 prop.val = (void*) buf;
1095 prop.len = sizeof(buf);
1096
1097 status = btif_storage_get_remote_device_property(&(p_req->read_req.bd_addr),
1098 &prop);
1099 HAL_CBACK(bt_hal_cbacks, remote_device_properties_cb,
1100 status, &(p_req->read_req.bd_addr), 1, &prop);
1101 }break;
1102 case BTIF_CORE_STORAGE_REMOTE_WRITE:
1103 {
1104 btif_storage_req_t *p_req = (btif_storage_req_t*)p_param;
1105 status = btif_storage_set_remote_device_property(&(p_req->write_req.bd_addr),
1106 &(p_req->write_req.prop));
1107 }break;
1108 case BTIF_CORE_STORAGE_REMOTE_READ_ALL:
1109 {
1110 btif_storage_req_t *p_req = (btif_storage_req_t*)p_param;
1111 btif_in_get_remote_device_properties(&p_req->read_req.bd_addr);
1112 }break;
1113 }
1114 }
1115
btif_adapter_properties_evt(bt_status_t status,uint32_t num_props,bt_property_t * p_props)1116 void btif_adapter_properties_evt(bt_status_t status, uint32_t num_props,
1117 bt_property_t *p_props)
1118 {
1119 HAL_CBACK(bt_hal_cbacks, adapter_properties_cb,
1120 status, num_props, p_props);
1121
1122 }
btif_remote_properties_evt(bt_status_t status,bt_bdaddr_t * remote_addr,uint32_t num_props,bt_property_t * p_props)1123 void btif_remote_properties_evt(bt_status_t status, bt_bdaddr_t *remote_addr,
1124 uint32_t num_props, bt_property_t *p_props)
1125 {
1126 HAL_CBACK(bt_hal_cbacks, remote_device_properties_cb,
1127 status, remote_addr, num_props, p_props);
1128 }
1129
1130 /*******************************************************************************
1131 **
1132 ** Function btif_in_storage_request_copy_cb
1133 **
1134 ** Description Switch context callback function to perform the deep copy for
1135 ** both the adapter and remote_device property API
1136 **
1137 ** Returns None
1138 **
1139 *******************************************************************************/
btif_in_storage_request_copy_cb(UINT16 event,char * p_new_buf,char * p_old_buf)1140 static void btif_in_storage_request_copy_cb(UINT16 event,
1141 char *p_new_buf, char *p_old_buf)
1142 {
1143 btif_storage_req_t *new_req = (btif_storage_req_t*)p_new_buf;
1144 btif_storage_req_t *old_req = (btif_storage_req_t*)p_old_buf;
1145
1146 BTIF_TRACE_EVENT("%s", __FUNCTION__);
1147 switch (event)
1148 {
1149 case BTIF_CORE_STORAGE_REMOTE_WRITE:
1150 case BTIF_CORE_STORAGE_ADAPTER_WRITE:
1151 {
1152 bdcpy(new_req->write_req.bd_addr.address, old_req->write_req.bd_addr.address);
1153 /* Copy the member variables one at a time */
1154 new_req->write_req.prop.type = old_req->write_req.prop.type;
1155 new_req->write_req.prop.len = old_req->write_req.prop.len;
1156
1157 new_req->write_req.prop.val = (UINT8 *)(p_new_buf + sizeof(btif_storage_req_t));
1158 memcpy(new_req->write_req.prop.val, old_req->write_req.prop.val,
1159 old_req->write_req.prop.len);
1160 }break;
1161 }
1162 }
1163
1164 /*******************************************************************************
1165 **
1166 ** Function btif_get_adapter_properties
1167 **
1168 ** Description Fetch all available properties (local & remote)
1169 **
1170 ** Returns bt_status_t
1171 **
1172 *******************************************************************************/
1173
btif_get_adapter_properties(void)1174 bt_status_t btif_get_adapter_properties(void)
1175 {
1176 BTIF_TRACE_EVENT("%s", __FUNCTION__);
1177
1178 if (!btif_is_enabled())
1179 return BT_STATUS_NOT_READY;
1180
1181 return btif_transfer_context(execute_storage_request,
1182 BTIF_CORE_STORAGE_ADAPTER_READ_ALL,
1183 NULL, 0, NULL);
1184 }
1185
1186 /*******************************************************************************
1187 **
1188 ** Function btif_get_adapter_property
1189 **
1190 ** Description Fetches property value from local cache
1191 **
1192 ** Returns bt_status_t
1193 **
1194 *******************************************************************************/
1195
btif_get_adapter_property(bt_property_type_t type)1196 bt_status_t btif_get_adapter_property(bt_property_type_t type)
1197 {
1198 btif_storage_req_t req;
1199
1200 BTIF_TRACE_EVENT("%s %d", __FUNCTION__, type);
1201
1202 /* Allow get_adapter_property only for BDADDR and BDNAME if BT is disabled */
1203 if (!btif_is_enabled() && (type != BT_PROPERTY_BDADDR) && (type != BT_PROPERTY_BDNAME))
1204 return BT_STATUS_NOT_READY;
1205
1206 memset(&(req.read_req.bd_addr), 0, sizeof(bt_bdaddr_t));
1207 req.read_req.type = type;
1208
1209 return btif_transfer_context(execute_storage_request,
1210 BTIF_CORE_STORAGE_ADAPTER_READ,
1211 (char*)&req, sizeof(btif_storage_req_t), NULL);
1212 }
1213
1214 /*******************************************************************************
1215 **
1216 ** Function btif_set_adapter_property
1217 **
1218 ** Description Updates core stack with property value and stores it in
1219 ** local cache
1220 **
1221 ** Returns bt_status_t
1222 **
1223 *******************************************************************************/
1224
btif_set_adapter_property(const bt_property_t * property)1225 bt_status_t btif_set_adapter_property(const bt_property_t *property)
1226 {
1227 btif_storage_req_t req;
1228 bt_status_t status = BT_STATUS_SUCCESS;
1229 int storage_req_id = BTIF_CORE_STORAGE_NOTIFY_STATUS; /* default */
1230 char bd_name[BTM_MAX_LOC_BD_NAME_LEN +1];
1231 UINT16 name_len = 0;
1232
1233 BTIF_TRACE_EVENT("btif_set_adapter_property type: %d, len %d, 0x%x",
1234 property->type, property->len, property->val);
1235
1236 if (!btif_is_enabled())
1237 return BT_STATUS_NOT_READY;
1238
1239 switch(property->type)
1240 {
1241 case BT_PROPERTY_BDNAME:
1242 {
1243 name_len = property->len > BTM_MAX_LOC_BD_NAME_LEN ? BTM_MAX_LOC_BD_NAME_LEN:
1244 property->len;
1245 memcpy(bd_name,property->val, name_len);
1246 bd_name[name_len] = '\0';
1247
1248 BTIF_TRACE_EVENT("set property name : %s", (char *)bd_name);
1249
1250 BTA_DmSetDeviceName((char *)bd_name);
1251
1252 storage_req_id = BTIF_CORE_STORAGE_ADAPTER_WRITE;
1253 }
1254 break;
1255
1256 case BT_PROPERTY_ADAPTER_SCAN_MODE:
1257 {
1258 bt_scan_mode_t mode = *(bt_scan_mode_t*)property->val;
1259 tBTA_DM_DISC disc_mode;
1260 tBTA_DM_CONN conn_mode;
1261
1262 switch(mode)
1263 {
1264 case BT_SCAN_MODE_NONE:
1265 disc_mode = BTA_DM_NON_DISC;
1266 conn_mode = BTA_DM_NON_CONN;
1267 break;
1268
1269 case BT_SCAN_MODE_CONNECTABLE:
1270 disc_mode = BTA_DM_NON_DISC;
1271 conn_mode = BTA_DM_CONN;
1272 break;
1273
1274 case BT_SCAN_MODE_CONNECTABLE_DISCOVERABLE:
1275 disc_mode = BTA_DM_GENERAL_DISC;
1276 conn_mode = BTA_DM_CONN;
1277 break;
1278
1279 default:
1280 BTIF_TRACE_ERROR("invalid scan mode (0x%x)", mode);
1281 return BT_STATUS_PARM_INVALID;
1282 }
1283
1284 BTIF_TRACE_EVENT("set property scan mode : %x", mode);
1285
1286 BTA_DmSetVisibility(disc_mode, conn_mode, BTA_DM_IGNORE, BTA_DM_IGNORE);
1287
1288 storage_req_id = BTIF_CORE_STORAGE_ADAPTER_WRITE;
1289 }
1290 break;
1291 case BT_PROPERTY_ADAPTER_DISCOVERY_TIMEOUT:
1292 {
1293 /* Nothing to do beside store the value in NV. Java
1294 will change the SCAN_MODE property after setting timeout,
1295 if required */
1296 storage_req_id = BTIF_CORE_STORAGE_ADAPTER_WRITE;
1297 }
1298 break;
1299 case BT_PROPERTY_BDADDR:
1300 case BT_PROPERTY_UUIDS:
1301 case BT_PROPERTY_ADAPTER_BONDED_DEVICES:
1302 case BT_PROPERTY_REMOTE_FRIENDLY_NAME:
1303 /* no write support through HAL, these properties are only populated from BTA events */
1304 status = BT_STATUS_FAIL;
1305 break;
1306 default:
1307 BTIF_TRACE_ERROR("btif_get_adapter_property : invalid type %d",
1308 property->type);
1309 status = BT_STATUS_FAIL;
1310 break;
1311 }
1312
1313 if (storage_req_id != BTIF_CORE_STORAGE_NO_ACTION)
1314 {
1315 int btif_status;
1316 /* pass on to storage for updating local database */
1317
1318 memset(&(req.write_req.bd_addr), 0, sizeof(bt_bdaddr_t));
1319 memcpy(&(req.write_req.prop), property, sizeof(bt_property_t));
1320
1321 return btif_transfer_context(execute_storage_request,
1322 storage_req_id,
1323 (char*)&req,
1324 sizeof(btif_storage_req_t)+property->len,
1325 btif_in_storage_request_copy_cb);
1326 }
1327
1328 return status;
1329
1330 }
1331
1332 /*******************************************************************************
1333 **
1334 ** Function btif_get_remote_device_property
1335 **
1336 ** Description Fetches the remote device property from the NVRAM
1337 **
1338 ** Returns bt_status_t
1339 **
1340 *******************************************************************************/
btif_get_remote_device_property(bt_bdaddr_t * remote_addr,bt_property_type_t type)1341 bt_status_t btif_get_remote_device_property(bt_bdaddr_t *remote_addr,
1342 bt_property_type_t type)
1343 {
1344 btif_storage_req_t req;
1345
1346 if (!btif_is_enabled())
1347 return BT_STATUS_NOT_READY;
1348
1349 memcpy(&(req.read_req.bd_addr), remote_addr, sizeof(bt_bdaddr_t));
1350 req.read_req.type = type;
1351 return btif_transfer_context(execute_storage_remote_request,
1352 BTIF_CORE_STORAGE_REMOTE_READ,
1353 (char*)&req, sizeof(btif_storage_req_t),
1354 NULL);
1355 }
1356
1357 /*******************************************************************************
1358 **
1359 ** Function btif_get_remote_device_properties
1360 **
1361 ** Description Fetches all the remote device properties from NVRAM
1362 **
1363 ** Returns bt_status_t
1364 **
1365 *******************************************************************************/
btif_get_remote_device_properties(bt_bdaddr_t * remote_addr)1366 bt_status_t btif_get_remote_device_properties(bt_bdaddr_t *remote_addr)
1367 {
1368 btif_storage_req_t req;
1369
1370 if (!btif_is_enabled())
1371 return BT_STATUS_NOT_READY;
1372
1373 memcpy(&(req.read_req.bd_addr), remote_addr, sizeof(bt_bdaddr_t));
1374 return btif_transfer_context(execute_storage_remote_request,
1375 BTIF_CORE_STORAGE_REMOTE_READ_ALL,
1376 (char*)&req, sizeof(btif_storage_req_t),
1377 NULL);
1378 }
1379
1380 /*******************************************************************************
1381 **
1382 ** Function btif_set_remote_device_property
1383 **
1384 ** Description Writes the remote device property to NVRAM.
1385 ** Currently, BT_PROPERTY_REMOTE_FRIENDLY_NAME is the only
1386 ** remote device property that can be set
1387 **
1388 ** Returns bt_status_t
1389 **
1390 *******************************************************************************/
btif_set_remote_device_property(bt_bdaddr_t * remote_addr,const bt_property_t * property)1391 bt_status_t btif_set_remote_device_property(bt_bdaddr_t *remote_addr,
1392 const bt_property_t *property)
1393 {
1394 btif_storage_req_t req;
1395
1396 if (!btif_is_enabled())
1397 return BT_STATUS_NOT_READY;
1398
1399 memcpy(&(req.write_req.bd_addr), remote_addr, sizeof(bt_bdaddr_t));
1400 memcpy(&(req.write_req.prop), property, sizeof(bt_property_t));
1401
1402 return btif_transfer_context(execute_storage_remote_request,
1403 BTIF_CORE_STORAGE_REMOTE_WRITE,
1404 (char*)&req,
1405 sizeof(btif_storage_req_t)+property->len,
1406 btif_in_storage_request_copy_cb);
1407 }
1408
1409
1410 /*******************************************************************************
1411 **
1412 ** Function btif_get_remote_service_record
1413 **
1414 ** Description Looks up the service matching uuid on the remote device
1415 ** and fetches the SCN and service_name if the UUID is found
1416 **
1417 ** Returns bt_status_t
1418 **
1419 *******************************************************************************/
btif_get_remote_service_record(bt_bdaddr_t * remote_addr,bt_uuid_t * uuid)1420 bt_status_t btif_get_remote_service_record(bt_bdaddr_t *remote_addr,
1421 bt_uuid_t *uuid)
1422 {
1423 if (!btif_is_enabled())
1424 return BT_STATUS_NOT_READY;
1425
1426 return btif_dm_get_remote_service_record(remote_addr, uuid);
1427 }
1428
1429
1430 /*******************************************************************************
1431 **
1432 ** Function btif_get_enabled_services_mask
1433 **
1434 ** Description Fetches currently enabled services
1435 **
1436 ** Returns tBTA_SERVICE_MASK
1437 **
1438 *******************************************************************************/
1439
btif_get_enabled_services_mask(void)1440 tBTA_SERVICE_MASK btif_get_enabled_services_mask(void)
1441 {
1442 return btif_enabled_services;
1443 }
1444
1445 /*******************************************************************************
1446 **
1447 ** Function btif_enable_service
1448 **
1449 ** Description Enables the service 'service_ID' to the service_mask.
1450 ** Upon BT enable, BTIF core shall invoke the BTA APIs to
1451 ** enable the profiles
1452 **
1453 ** Returns bt_status_t
1454 **
1455 *******************************************************************************/
btif_enable_service(tBTA_SERVICE_ID service_id)1456 bt_status_t btif_enable_service(tBTA_SERVICE_ID service_id)
1457 {
1458 tBTA_SERVICE_ID *p_id = &service_id;
1459
1460 /* If BT is enabled, we need to switch to BTIF context and trigger the
1461 * enable for that profile
1462 *
1463 * Otherwise, we just set the flag. On BT_Enable, the DM will trigger
1464 * enable for the profiles that have been enabled */
1465
1466 btif_enabled_services |= (1 << service_id);
1467
1468 BTIF_TRACE_DEBUG("%s: current services:0x%x", __FUNCTION__, btif_enabled_services);
1469
1470 if (btif_is_enabled())
1471 {
1472 btif_transfer_context(btif_dm_execute_service_request,
1473 BTIF_DM_ENABLE_SERVICE,
1474 (char*)p_id, sizeof(tBTA_SERVICE_ID), NULL);
1475 }
1476
1477 return BT_STATUS_SUCCESS;
1478 }
1479 /*******************************************************************************
1480 **
1481 ** Function btif_disable_service
1482 **
1483 ** Description Disables the service 'service_ID' to the service_mask.
1484 ** Upon BT disable, BTIF core shall invoke the BTA APIs to
1485 ** disable the profiles
1486 **
1487 ** Returns bt_status_t
1488 **
1489 *******************************************************************************/
btif_disable_service(tBTA_SERVICE_ID service_id)1490 bt_status_t btif_disable_service(tBTA_SERVICE_ID service_id)
1491 {
1492 tBTA_SERVICE_ID *p_id = &service_id;
1493
1494 /* If BT is enabled, we need to switch to BTIF context and trigger the
1495 * disable for that profile so that the appropriate uuid_property_changed will
1496 * be triggerred. Otherwise, we just need to clear the service_id in the mask
1497 */
1498
1499 btif_enabled_services &= (tBTA_SERVICE_MASK)(~(1<<service_id));
1500
1501 BTIF_TRACE_DEBUG("%s: Current Services:0x%x", __FUNCTION__, btif_enabled_services);
1502
1503 if (btif_is_enabled())
1504 {
1505 btif_transfer_context(btif_dm_execute_service_request,
1506 BTIF_DM_DISABLE_SERVICE,
1507 (char*)p_id, sizeof(tBTA_SERVICE_ID), NULL);
1508 }
1509
1510 return BT_STATUS_SUCCESS;
1511 }
1512
1513 /*******************************************************************************
1514 **
1515 ** Function btif_config_hci_snoop_log
1516 **
1517 ** Description enable or disable HCI snoop log
1518 **
1519 ** Returns bt_status_t
1520 **
1521 *******************************************************************************/
btif_config_hci_snoop_log(uint8_t enable)1522 bt_status_t btif_config_hci_snoop_log(uint8_t enable)
1523 {
1524 bte_main_config_hci_logging(enable != 0,
1525 btif_core_state == BTIF_CORE_STATE_DISABLED);
1526 return BT_STATUS_SUCCESS;
1527 }
1528