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:      bluetooth.c
22  *
23  *  Description:   Bluetooth HAL implementation
24  *
25  ***********************************************************************************/
26 
27 #define LOG_TAG "bt_btif"
28 
29 #include <assert.h>
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <string.h>
33 #include <unistd.h>
34 
35 #include <hardware/bluetooth.h>
36 #include <hardware/bt_av.h>
37 #include <hardware/bt_gatt.h>
38 #include <hardware/bt_hf.h>
39 #include <hardware/bt_hf_client.h>
40 #include <hardware/bt_hh.h>
41 #include <hardware/bt_hl.h>
42 #include <hardware/bt_mce.h>
43 #include <hardware/bt_pan.h>
44 #include <hardware/bt_rc.h>
45 #include <hardware/bt_sdp.h>
46 #include <hardware/bt_sock.h>
47 
48 #include "bt_utils.h"
49 #include "btif_api.h"
50 #include "btif_debug.h"
51 #include "btsnoop.h"
52 #include "btsnoop_mem.h"
53 #include "device/include/interop.h"
54 #include "osi/include/allocation_tracker.h"
55 #include "osi/include/alarm.h"
56 #include "osi/include/log.h"
57 #include "osi/include/metrics.h"
58 #include "osi/include/osi.h"
59 #include "osi/include/wakelock.h"
60 #include "stack_manager.h"
61 #include "btif_config.h"
62 #include "btif_storage.h"
63 #include "btif/include/btif_debug_btsnoop.h"
64 #include "btif/include/btif_debug_conn.h"
65 #include "btif/include/btif_media.h"
66 
67 /************************************************************************************
68 **  Static variables
69 ************************************************************************************/
70 
71 bt_callbacks_t *bt_hal_cbacks = NULL;
72 bool restricted_mode = FALSE;
73 
74 /************************************************************************************
75 **  Externs
76 ************************************************************************************/
77 
78 /* list all extended interfaces here */
79 
80 /* handsfree profile */
81 extern bthf_interface_t *btif_hf_get_interface();
82 /* handsfree profile - client */
83 extern bthf_client_interface_t *btif_hf_client_get_interface();
84 /* advanced audio profile */
85 extern btav_interface_t *btif_av_get_src_interface();
86 extern btav_interface_t *btif_av_get_sink_interface();
87 /*rfc l2cap*/
88 extern btsock_interface_t *btif_sock_get_interface();
89 /* hid host profile */
90 extern bthh_interface_t *btif_hh_get_interface();
91 /* health device profile */
92 extern bthl_interface_t *btif_hl_get_interface();
93 /*pan*/
94 extern btpan_interface_t *btif_pan_get_interface();
95 /*map client*/
96 extern btmce_interface_t *btif_mce_get_interface();
97 #if BLE_INCLUDED == TRUE
98 /* gatt */
99 extern btgatt_interface_t *btif_gatt_get_interface();
100 #endif
101 /* avrc target */
102 extern btrc_interface_t *btif_rc_get_interface();
103 /* avrc controller */
104 extern btrc_interface_t *btif_rc_ctrl_get_interface();
105 /*SDP search client*/
106 extern btsdp_interface_t *btif_sdp_get_interface();
107 
108 /************************************************************************************
109 **  Functions
110 ************************************************************************************/
111 
interface_ready(void)112 static bool interface_ready(void) {
113   return bt_hal_cbacks != NULL;
114 }
115 
is_profile(const char * p1,const char * p2)116 static bool is_profile(const char *p1, const char *p2) {
117   assert(p1);
118   assert(p2);
119   return strlen(p1) == strlen(p2) && strncmp(p1, p2, strlen(p2)) == 0;
120 }
121 
122 /*****************************************************************************
123 **
124 **   BLUETOOTH HAL INTERFACE FUNCTIONS
125 **
126 *****************************************************************************/
127 
init(bt_callbacks_t * callbacks)128 static int init(bt_callbacks_t *callbacks) {
129   LOG_INFO(LOG_TAG, "%s", __func__);
130 
131   if (interface_ready())
132     return BT_STATUS_DONE;
133 
134 #ifdef BLUEDROID_DEBUG
135   allocation_tracker_init();
136 #endif
137 
138   bt_hal_cbacks = callbacks;
139   stack_manager_get_interface()->init_stack();
140   btif_debug_init();
141   return BT_STATUS_SUCCESS;
142 }
143 
enable(bool start_restricted)144 static int enable(bool start_restricted) {
145   LOG_INFO(LOG_TAG, "%s: start restricted = %d", __func__, start_restricted);
146 
147   restricted_mode = start_restricted;
148 
149   if (!interface_ready())
150     return BT_STATUS_NOT_READY;
151 
152   stack_manager_get_interface()->start_up_stack_async();
153   return BT_STATUS_SUCCESS;
154 }
155 
disable(void)156 static int disable(void) {
157   if (!interface_ready())
158     return BT_STATUS_NOT_READY;
159 
160   stack_manager_get_interface()->shut_down_stack_async();
161   return BT_STATUS_SUCCESS;
162 }
163 
cleanup(void)164 static void cleanup(void) {
165   stack_manager_get_interface()->clean_up_stack();
166 }
167 
is_restricted_mode()168 bool is_restricted_mode() {
169   return restricted_mode;
170 }
171 
get_adapter_properties(void)172 static int get_adapter_properties(void)
173 {
174     /* sanity check */
175     if (interface_ready() == FALSE)
176         return BT_STATUS_NOT_READY;
177 
178     return btif_get_adapter_properties();
179 }
180 
get_adapter_property(bt_property_type_t type)181 static int get_adapter_property(bt_property_type_t type)
182 {
183     /* sanity check */
184     if (interface_ready() == FALSE)
185         return BT_STATUS_NOT_READY;
186 
187     return btif_get_adapter_property(type);
188 }
189 
set_adapter_property(const bt_property_t * property)190 static int set_adapter_property(const bt_property_t *property)
191 {
192     /* sanity check */
193     if (interface_ready() == FALSE)
194         return BT_STATUS_NOT_READY;
195 
196     return btif_set_adapter_property(property);
197 }
198 
get_remote_device_properties(bt_bdaddr_t * remote_addr)199 int get_remote_device_properties(bt_bdaddr_t *remote_addr)
200 {
201     /* sanity check */
202     if (interface_ready() == FALSE)
203         return BT_STATUS_NOT_READY;
204 
205     return btif_get_remote_device_properties(remote_addr);
206 }
207 
get_remote_device_property(bt_bdaddr_t * remote_addr,bt_property_type_t type)208 int get_remote_device_property(bt_bdaddr_t *remote_addr, bt_property_type_t type)
209 {
210     /* sanity check */
211     if (interface_ready() == FALSE)
212         return BT_STATUS_NOT_READY;
213 
214     return btif_get_remote_device_property(remote_addr, type);
215 }
216 
set_remote_device_property(bt_bdaddr_t * remote_addr,const bt_property_t * property)217 int set_remote_device_property(bt_bdaddr_t *remote_addr, const bt_property_t *property)
218 {
219     /* sanity check */
220     if (interface_ready() == FALSE)
221         return BT_STATUS_NOT_READY;
222 
223     return btif_set_remote_device_property(remote_addr, property);
224 }
225 
get_remote_service_record(bt_bdaddr_t * remote_addr,bt_uuid_t * uuid)226 int get_remote_service_record(bt_bdaddr_t *remote_addr, bt_uuid_t *uuid)
227 {
228     /* sanity check */
229     if (interface_ready() == FALSE)
230         return BT_STATUS_NOT_READY;
231 
232     return btif_get_remote_service_record(remote_addr, uuid);
233 }
234 
get_remote_services(bt_bdaddr_t * remote_addr)235 int get_remote_services(bt_bdaddr_t *remote_addr)
236 {
237     /* sanity check */
238     if (interface_ready() == FALSE)
239         return BT_STATUS_NOT_READY;
240 
241     return btif_dm_get_remote_services(remote_addr);
242 }
243 
start_discovery(void)244 static int start_discovery(void)
245 {
246     /* sanity check */
247     if (interface_ready() == FALSE)
248         return BT_STATUS_NOT_READY;
249 
250     return btif_dm_start_discovery();
251 }
252 
cancel_discovery(void)253 static int cancel_discovery(void)
254 {
255     /* sanity check */
256     if (interface_ready() == FALSE)
257         return BT_STATUS_NOT_READY;
258 
259     return btif_dm_cancel_discovery();
260 }
261 
create_bond(const bt_bdaddr_t * bd_addr,int transport)262 static int create_bond(const bt_bdaddr_t *bd_addr, int transport)
263 {
264     /* sanity check */
265     if (interface_ready() == FALSE)
266         return BT_STATUS_NOT_READY;
267 
268     return btif_dm_create_bond(bd_addr, transport);
269 }
270 
create_bond_out_of_band(const bt_bdaddr_t * bd_addr,int transport,const bt_out_of_band_data_t * oob_data)271 static int create_bond_out_of_band(const bt_bdaddr_t *bd_addr, int transport,
272                                    const bt_out_of_band_data_t *oob_data)
273 {
274     /* sanity check */
275     if (interface_ready() == FALSE)
276         return BT_STATUS_NOT_READY;
277 
278     return btif_dm_create_bond_out_of_band(bd_addr, transport, oob_data);
279 }
280 
cancel_bond(const bt_bdaddr_t * bd_addr)281 static int cancel_bond(const bt_bdaddr_t *bd_addr)
282 {
283     /* sanity check */
284     if (interface_ready() == FALSE)
285         return BT_STATUS_NOT_READY;
286 
287     return btif_dm_cancel_bond(bd_addr);
288 }
289 
remove_bond(const bt_bdaddr_t * bd_addr)290 static int remove_bond(const bt_bdaddr_t *bd_addr)
291 {
292     if (is_restricted_mode() && !btif_storage_is_restricted_device(bd_addr))
293         return BT_STATUS_SUCCESS;
294 
295     /* sanity check */
296     if (interface_ready() == FALSE)
297         return BT_STATUS_NOT_READY;
298 
299     return btif_dm_remove_bond(bd_addr);
300 }
301 
get_connection_state(const bt_bdaddr_t * bd_addr)302 static int get_connection_state(const bt_bdaddr_t *bd_addr)
303 {
304     /* sanity check */
305     if (interface_ready() == FALSE)
306         return 0;
307 
308     return btif_dm_get_connection_state(bd_addr);
309 }
310 
pin_reply(const bt_bdaddr_t * bd_addr,uint8_t accept,uint8_t pin_len,bt_pin_code_t * pin_code)311 static int pin_reply(const bt_bdaddr_t *bd_addr, uint8_t accept,
312                  uint8_t pin_len, bt_pin_code_t *pin_code)
313 {
314     /* sanity check */
315     if (interface_ready() == FALSE)
316         return BT_STATUS_NOT_READY;
317 
318     return btif_dm_pin_reply(bd_addr, accept, pin_len, pin_code);
319 }
320 
ssp_reply(const bt_bdaddr_t * bd_addr,bt_ssp_variant_t variant,uint8_t accept,uint32_t passkey)321 static int ssp_reply(const bt_bdaddr_t *bd_addr, bt_ssp_variant_t variant,
322                        uint8_t accept, uint32_t passkey)
323 {
324     /* sanity check */
325     if (interface_ready() == FALSE)
326         return BT_STATUS_NOT_READY;
327 
328     return btif_dm_ssp_reply(bd_addr, variant, accept, passkey);
329 }
330 
read_energy_info()331 static int read_energy_info()
332 {
333     if (interface_ready() == FALSE)
334         return BT_STATUS_NOT_READY;
335     btif_dm_read_energy_info();
336     return BT_STATUS_SUCCESS;
337 }
338 
dump(int fd,const char ** arguments)339 static void dump(int fd, const char **arguments)
340 {
341     if (arguments != NULL && arguments[0] != NULL) {
342       if (strncmp(arguments[0], "--proto-text", 12) == 0) {
343         btif_update_a2dp_metrics();
344         metrics_print(fd, true);
345         return;
346       }
347       if (strncmp(arguments[0], "--proto-bin", 11) == 0) {
348         btif_update_a2dp_metrics();
349         metrics_write(fd, true);
350         return;
351       }
352     }
353     btif_debug_conn_dump(fd);
354     btif_debug_bond_event_dump(fd);
355     btif_debug_a2dp_dump(fd);
356     btif_debug_config_dump(fd);
357     wakelock_debug_dump(fd);
358     alarm_debug_dump(fd);
359 #if defined(BTSNOOP_MEM) && (BTSNOOP_MEM == TRUE)
360     btif_debug_btsnoop_dump(fd);
361 #endif
362 
363     close(fd);
364 }
365 
get_profile_interface(const char * profile_id)366 static const void* get_profile_interface (const char *profile_id)
367 {
368     LOG_INFO(LOG_TAG, "get_profile_interface %s", profile_id);
369 
370     /* sanity check */
371     if (interface_ready() == FALSE)
372         return NULL;
373 
374     /* check for supported profile interfaces */
375     if (is_profile(profile_id, BT_PROFILE_HANDSFREE_ID))
376         return btif_hf_get_interface();
377 
378     if (is_profile(profile_id, BT_PROFILE_HANDSFREE_CLIENT_ID))
379         return btif_hf_client_get_interface();
380 
381     if (is_profile(profile_id, BT_PROFILE_SOCKETS_ID))
382         return btif_sock_get_interface();
383 
384     if (is_profile(profile_id, BT_PROFILE_PAN_ID))
385         return btif_pan_get_interface();
386 
387     if (is_profile(profile_id, BT_PROFILE_ADVANCED_AUDIO_ID))
388         return btif_av_get_src_interface();
389 
390     if (is_profile(profile_id, BT_PROFILE_ADVANCED_AUDIO_SINK_ID))
391         return btif_av_get_sink_interface();
392 
393     if (is_profile(profile_id, BT_PROFILE_HIDHOST_ID))
394         return btif_hh_get_interface();
395 
396     if (is_profile(profile_id, BT_PROFILE_HEALTH_ID))
397         return btif_hl_get_interface();
398 
399     if (is_profile(profile_id, BT_PROFILE_SDP_CLIENT_ID))
400         return btif_sdp_get_interface();
401 
402 #if ( BTA_GATT_INCLUDED == TRUE && BLE_INCLUDED == TRUE)
403     if (is_profile(profile_id, BT_PROFILE_GATT_ID))
404         return btif_gatt_get_interface();
405 #endif
406 
407     if (is_profile(profile_id, BT_PROFILE_AV_RC_ID))
408         return btif_rc_get_interface();
409 
410     if (is_profile(profile_id, BT_PROFILE_AV_RC_CTRL_ID))
411         return btif_rc_ctrl_get_interface();
412 
413     return NULL;
414 }
415 
dut_mode_configure(uint8_t enable)416 int dut_mode_configure(uint8_t enable)
417 {
418     LOG_INFO(LOG_TAG, "dut_mode_configure");
419 
420     /* sanity check */
421     if (interface_ready() == FALSE)
422         return BT_STATUS_NOT_READY;
423 
424     return btif_dut_mode_configure(enable);
425 }
426 
dut_mode_send(uint16_t opcode,uint8_t * buf,uint8_t len)427 int dut_mode_send(uint16_t opcode, uint8_t* buf, uint8_t len)
428 {
429     LOG_INFO(LOG_TAG, "dut_mode_send");
430 
431     /* sanity check */
432     if (interface_ready() == FALSE)
433         return BT_STATUS_NOT_READY;
434 
435     return btif_dut_mode_send(opcode, buf, len);
436 }
437 
438 #if BLE_INCLUDED == TRUE
le_test_mode(uint16_t opcode,uint8_t * buf,uint8_t len)439 int le_test_mode(uint16_t opcode, uint8_t* buf, uint8_t len)
440 {
441     LOG_INFO(LOG_TAG, "le_test_mode");
442 
443     /* sanity check */
444     if (interface_ready() == FALSE)
445         return BT_STATUS_NOT_READY;
446 
447     return btif_le_test_mode(opcode, buf, len);
448 }
449 #endif
450 
config_hci_snoop_log(uint8_t enable)451 int config_hci_snoop_log(uint8_t enable)
452 {
453     LOG_INFO(LOG_TAG, "config_hci_snoop_log");
454 
455     if (!interface_ready())
456         return BT_STATUS_NOT_READY;
457 
458     btsnoop_get_interface()->set_api_wants_to_log(enable);
459     return BT_STATUS_SUCCESS;
460 }
461 
set_os_callouts(bt_os_callouts_t * callouts)462 static int set_os_callouts(bt_os_callouts_t *callouts) {
463     wakelock_set_os_callouts(callouts);
464     return BT_STATUS_SUCCESS;
465 }
466 
config_clear(void)467 static int config_clear(void) {
468     LOG_INFO(LOG_TAG, "%s", __func__);
469     return btif_config_clear() ? BT_STATUS_SUCCESS : BT_STATUS_FAIL;
470 }
471 
472 static const bt_interface_t bluetoothInterface = {
473     sizeof(bluetoothInterface),
474     init,
475     enable,
476     disable,
477     cleanup,
478     get_adapter_properties,
479     get_adapter_property,
480     set_adapter_property,
481     get_remote_device_properties,
482     get_remote_device_property,
483     set_remote_device_property,
484     get_remote_service_record,
485     get_remote_services,
486     start_discovery,
487     cancel_discovery,
488     create_bond,
489     create_bond_out_of_band,
490     remove_bond,
491     cancel_bond,
492     get_connection_state,
493     pin_reply,
494     ssp_reply,
495     get_profile_interface,
496     dut_mode_configure,
497     dut_mode_send,
498 #if BLE_INCLUDED == TRUE
499     le_test_mode,
500 #else
501     NULL,
502 #endif
503     config_hci_snoop_log,
504     set_os_callouts,
505     read_energy_info,
506     dump,
507     config_clear,
508     interop_database_clear,
509     interop_database_add,
510 };
511 
bluetooth__get_bluetooth_interface()512 const bt_interface_t* bluetooth__get_bluetooth_interface ()
513 {
514     /* fixme -- add property to disable bt interface ? */
515 
516     return &bluetoothInterface;
517 }
518 
close_bluetooth_stack(struct hw_device_t * device)519 static int close_bluetooth_stack(struct hw_device_t* device)
520 {
521     UNUSED(device);
522     cleanup();
523     return 0;
524 }
525 
open_bluetooth_stack(const struct hw_module_t * module,UNUSED_ATTR char const * name,struct hw_device_t ** abstraction)526 static int open_bluetooth_stack(const struct hw_module_t *module, UNUSED_ATTR char const *name, struct hw_device_t **abstraction) {
527   static bluetooth_device_t device = {
528     .common = {
529       .tag = HARDWARE_DEVICE_TAG,
530       .version = 0,
531       .close = close_bluetooth_stack,
532     },
533     .get_bluetooth_interface = bluetooth__get_bluetooth_interface
534   };
535 
536   device.common.module = (struct hw_module_t *)module;
537   *abstraction = (struct hw_device_t *)&device;
538   return 0;
539 }
540 
541 static struct hw_module_methods_t bt_stack_module_methods = {
542     .open = open_bluetooth_stack,
543 };
544 
545 EXPORT_SYMBOL struct hw_module_t HAL_MODULE_INFO_SYM = {
546     .tag = HARDWARE_MODULE_TAG,
547     .version_major = 1,
548     .version_minor = 0,
549     .id = BT_HARDWARE_MODULE_ID,
550     .name = "Bluetooth Stack",
551     .author = "The Android Open Source Project",
552     .methods = &bt_stack_module_methods
553 };
554