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