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 #include <stdio.h>
28 #include <stdlib.h>
29 #include <string.h>
30 #include <unistd.h>
31 
32 #include <hardware/bluetooth.h>
33 #include <hardware/bt_hf.h>
34 #include <hardware/bt_hf_client.h>
35 #include <hardware/bt_av.h>
36 #include <hardware/bt_sock.h>
37 #include <hardware/bt_hh.h>
38 #include <hardware/bt_hl.h>
39 #include <hardware/bt_pan.h>
40 #include <hardware/bt_mce.h>
41 #include <hardware/bt_gatt.h>
42 #include <hardware/bt_rc.h>
43 #include <hardware/bt_sdp.h>
44 
45 #define LOG_NDDEBUG 0
46 #define LOG_TAG "bt_bluedroid"
47 
48 #include "btif_api.h"
49 #include "btif_debug.h"
50 #include "btsnoop.h"
51 #include "btsnoop_mem.h"
52 #include "bt_utils.h"
53 #include "osi/include/osi.h"
54 #include "osi/include/allocation_tracker.h"
55 #include "osi/include/log.h"
56 #include "stack_manager.h"
57 #include "btif_config.h"
58 
59 /************************************************************************************
60 **  Constants & Macros
61 ************************************************************************************/
62 
63 #define is_profile(profile, str) ((strlen(str) == strlen(profile)) && strncmp((const char *)profile, str, strlen(str)) == 0)
64 
65 /************************************************************************************
66 **  Static variables
67 ************************************************************************************/
68 
69 bt_callbacks_t *bt_hal_cbacks = NULL;
70 
71 /** Operating System specific callouts for resource management */
72 bt_os_callouts_t *bt_os_callouts = NULL;
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 
116 /*****************************************************************************
117 **
118 **   BLUETOOTH HAL INTERFACE FUNCTIONS
119 **
120 *****************************************************************************/
121 
init(bt_callbacks_t * callbacks)122 static int init(bt_callbacks_t *callbacks) {
123   LOG_INFO("%s", __func__);
124 
125   if (interface_ready())
126     return BT_STATUS_DONE;
127 
128 #ifdef BLUEDROID_DEBUG
129   allocation_tracker_init();
130 #endif
131 
132   bt_hal_cbacks = callbacks;
133   stack_manager_get_interface()->init_stack();
134   btif_debug_init();
135   return BT_STATUS_SUCCESS;
136 }
137 
enable(void)138 static int enable(void) {
139   LOG_INFO("%s", __func__);
140 
141   if (!interface_ready())
142     return BT_STATUS_NOT_READY;
143 
144   stack_manager_get_interface()->start_up_stack_async();
145   return BT_STATUS_SUCCESS;
146 }
147 
disable(void)148 static int disable(void) {
149   if (!interface_ready())
150     return BT_STATUS_NOT_READY;
151 
152   stack_manager_get_interface()->shut_down_stack_async();
153   return BT_STATUS_SUCCESS;
154 }
155 
cleanup(void)156 static void cleanup(void) {
157   stack_manager_get_interface()->clean_up_stack_async();
158 }
159 
get_adapter_properties(void)160 static int get_adapter_properties(void)
161 {
162     /* sanity check */
163     if (interface_ready() == FALSE)
164         return BT_STATUS_NOT_READY;
165 
166     return btif_get_adapter_properties();
167 }
168 
get_adapter_property(bt_property_type_t type)169 static int get_adapter_property(bt_property_type_t type)
170 {
171     /* sanity check */
172     if (interface_ready() == FALSE)
173         return BT_STATUS_NOT_READY;
174 
175     return btif_get_adapter_property(type);
176 }
177 
set_adapter_property(const bt_property_t * property)178 static int set_adapter_property(const bt_property_t *property)
179 {
180     /* sanity check */
181     if (interface_ready() == FALSE)
182         return BT_STATUS_NOT_READY;
183 
184     return btif_set_adapter_property(property);
185 }
186 
get_remote_device_properties(bt_bdaddr_t * remote_addr)187 int get_remote_device_properties(bt_bdaddr_t *remote_addr)
188 {
189     /* sanity check */
190     if (interface_ready() == FALSE)
191         return BT_STATUS_NOT_READY;
192 
193     return btif_get_remote_device_properties(remote_addr);
194 }
195 
get_remote_device_property(bt_bdaddr_t * remote_addr,bt_property_type_t type)196 int get_remote_device_property(bt_bdaddr_t *remote_addr, bt_property_type_t type)
197 {
198     /* sanity check */
199     if (interface_ready() == FALSE)
200         return BT_STATUS_NOT_READY;
201 
202     return btif_get_remote_device_property(remote_addr, type);
203 }
204 
set_remote_device_property(bt_bdaddr_t * remote_addr,const bt_property_t * property)205 int set_remote_device_property(bt_bdaddr_t *remote_addr, const bt_property_t *property)
206 {
207     /* sanity check */
208     if (interface_ready() == FALSE)
209         return BT_STATUS_NOT_READY;
210 
211     return btif_set_remote_device_property(remote_addr, property);
212 }
213 
get_remote_service_record(bt_bdaddr_t * remote_addr,bt_uuid_t * uuid)214 int get_remote_service_record(bt_bdaddr_t *remote_addr, bt_uuid_t *uuid)
215 {
216     /* sanity check */
217     if (interface_ready() == FALSE)
218         return BT_STATUS_NOT_READY;
219 
220     return btif_get_remote_service_record(remote_addr, uuid);
221 }
222 
get_remote_services(bt_bdaddr_t * remote_addr)223 int get_remote_services(bt_bdaddr_t *remote_addr)
224 {
225     /* sanity check */
226     if (interface_ready() == FALSE)
227         return BT_STATUS_NOT_READY;
228 
229     return btif_dm_get_remote_services(remote_addr);
230 }
231 
start_discovery(void)232 static int start_discovery(void)
233 {
234     /* sanity check */
235     if (interface_ready() == FALSE)
236         return BT_STATUS_NOT_READY;
237 
238     return btif_dm_start_discovery();
239 }
240 
cancel_discovery(void)241 static int cancel_discovery(void)
242 {
243     /* sanity check */
244     if (interface_ready() == FALSE)
245         return BT_STATUS_NOT_READY;
246 
247     return btif_dm_cancel_discovery();
248 }
249 
create_bond(const bt_bdaddr_t * bd_addr,int transport)250 static int create_bond(const bt_bdaddr_t *bd_addr, int transport)
251 {
252     /* sanity check */
253     if (interface_ready() == FALSE)
254         return BT_STATUS_NOT_READY;
255 
256     return btif_dm_create_bond(bd_addr, transport);
257 }
258 
cancel_bond(const bt_bdaddr_t * bd_addr)259 static int cancel_bond(const bt_bdaddr_t *bd_addr)
260 {
261     /* sanity check */
262     if (interface_ready() == FALSE)
263         return BT_STATUS_NOT_READY;
264 
265     return btif_dm_cancel_bond(bd_addr);
266 }
267 
remove_bond(const bt_bdaddr_t * bd_addr)268 static int remove_bond(const bt_bdaddr_t *bd_addr)
269 {
270     /* sanity check */
271     if (interface_ready() == FALSE)
272         return BT_STATUS_NOT_READY;
273 
274     return btif_dm_remove_bond(bd_addr);
275 }
276 
get_connection_state(const bt_bdaddr_t * bd_addr)277 static int get_connection_state(const bt_bdaddr_t *bd_addr)
278 {
279     /* sanity check */
280     if (interface_ready() == FALSE)
281         return 0;
282 
283     return btif_dm_get_connection_state(bd_addr);
284 }
285 
pin_reply(const bt_bdaddr_t * bd_addr,uint8_t accept,uint8_t pin_len,bt_pin_code_t * pin_code)286 static int pin_reply(const bt_bdaddr_t *bd_addr, uint8_t accept,
287                  uint8_t pin_len, bt_pin_code_t *pin_code)
288 {
289     /* sanity check */
290     if (interface_ready() == FALSE)
291         return BT_STATUS_NOT_READY;
292 
293     return btif_dm_pin_reply(bd_addr, accept, pin_len, pin_code);
294 }
295 
ssp_reply(const bt_bdaddr_t * bd_addr,bt_ssp_variant_t variant,uint8_t accept,uint32_t passkey)296 static int ssp_reply(const bt_bdaddr_t *bd_addr, bt_ssp_variant_t variant,
297                        uint8_t accept, uint32_t passkey)
298 {
299     /* sanity check */
300     if (interface_ready() == FALSE)
301         return BT_STATUS_NOT_READY;
302 
303     return btif_dm_ssp_reply(bd_addr, variant, accept, passkey);
304 }
305 
read_energy_info()306 static int read_energy_info()
307 {
308     if (interface_ready() == FALSE)
309         return BT_STATUS_NOT_READY;
310     btif_dm_read_energy_info();
311     return BT_STATUS_SUCCESS;
312 }
313 
dump(int fd)314 static void dump(int fd)
315 {
316     btif_debug_dump(fd);
317 }
318 
get_profile_interface(const char * profile_id)319 static const void* get_profile_interface (const char *profile_id)
320 {
321     LOG_INFO("get_profile_interface %s", profile_id);
322 
323     /* sanity check */
324     if (interface_ready() == FALSE)
325         return NULL;
326 
327     /* check for supported profile interfaces */
328     if (is_profile(profile_id, BT_PROFILE_HANDSFREE_ID))
329         return btif_hf_get_interface();
330 
331     if (is_profile(profile_id, BT_PROFILE_HANDSFREE_CLIENT_ID))
332         return btif_hf_client_get_interface();
333 
334     if (is_profile(profile_id, BT_PROFILE_SOCKETS_ID))
335         return btif_sock_get_interface();
336 
337     if (is_profile(profile_id, BT_PROFILE_PAN_ID))
338         return btif_pan_get_interface();
339 
340     if (is_profile(profile_id, BT_PROFILE_ADVANCED_AUDIO_ID))
341         return btif_av_get_src_interface();
342 
343     if (is_profile(profile_id, BT_PROFILE_ADVANCED_AUDIO_SINK_ID))
344         return btif_av_get_sink_interface();
345 
346     if (is_profile(profile_id, BT_PROFILE_HIDHOST_ID))
347         return btif_hh_get_interface();
348 
349     if (is_profile(profile_id, BT_PROFILE_HEALTH_ID))
350         return btif_hl_get_interface();
351 
352     if (is_profile(profile_id, BT_PROFILE_SDP_CLIENT_ID))
353         return btif_sdp_get_interface();
354 
355 #if ( BTA_GATT_INCLUDED == TRUE && BLE_INCLUDED == TRUE)
356     if (is_profile(profile_id, BT_PROFILE_GATT_ID))
357         return btif_gatt_get_interface();
358 #endif
359 
360     if (is_profile(profile_id, BT_PROFILE_AV_RC_ID))
361         return btif_rc_get_interface();
362 
363     if (is_profile(profile_id, BT_PROFILE_AV_RC_CTRL_ID))
364         return btif_rc_ctrl_get_interface();
365 
366     return NULL;
367 }
368 
dut_mode_configure(uint8_t enable)369 int dut_mode_configure(uint8_t enable)
370 {
371     LOG_INFO("dut_mode_configure");
372 
373     /* sanity check */
374     if (interface_ready() == FALSE)
375         return BT_STATUS_NOT_READY;
376 
377     return btif_dut_mode_configure(enable);
378 }
379 
dut_mode_send(uint16_t opcode,uint8_t * buf,uint8_t len)380 int dut_mode_send(uint16_t opcode, uint8_t* buf, uint8_t len)
381 {
382     LOG_INFO("dut_mode_send");
383 
384     /* sanity check */
385     if (interface_ready() == FALSE)
386         return BT_STATUS_NOT_READY;
387 
388     return btif_dut_mode_send(opcode, buf, len);
389 }
390 
391 #if BLE_INCLUDED == TRUE
le_test_mode(uint16_t opcode,uint8_t * buf,uint8_t len)392 int le_test_mode(uint16_t opcode, uint8_t* buf, uint8_t len)
393 {
394     LOG_INFO("le_test_mode");
395 
396     /* sanity check */
397     if (interface_ready() == FALSE)
398         return BT_STATUS_NOT_READY;
399 
400     return btif_le_test_mode(opcode, buf, len);
401 }
402 #endif
403 
config_hci_snoop_log(uint8_t enable)404 int config_hci_snoop_log(uint8_t enable)
405 {
406     LOG_INFO("config_hci_snoop_log");
407 
408     if (!interface_ready())
409         return BT_STATUS_NOT_READY;
410 
411     btsnoop_get_interface()->set_api_wants_to_log(enable);
412     return BT_STATUS_SUCCESS;
413 }
414 
set_os_callouts(bt_os_callouts_t * callouts)415 static int set_os_callouts(bt_os_callouts_t *callouts) {
416     bt_os_callouts = callouts;
417     return BT_STATUS_SUCCESS;
418 }
419 
config_clear(void)420 static int config_clear(void) {
421     LOG_INFO("%s", __func__);
422     return btif_config_clear();
423 }
424 
425 static const bt_interface_t bluetoothInterface = {
426     sizeof(bluetoothInterface),
427     init,
428     enable,
429     disable,
430     cleanup,
431     get_adapter_properties,
432     get_adapter_property,
433     set_adapter_property,
434     get_remote_device_properties,
435     get_remote_device_property,
436     set_remote_device_property,
437     get_remote_service_record,
438     get_remote_services,
439     start_discovery,
440     cancel_discovery,
441     create_bond,
442     remove_bond,
443     cancel_bond,
444     get_connection_state,
445     pin_reply,
446     ssp_reply,
447     get_profile_interface,
448     dut_mode_configure,
449     dut_mode_send,
450 #if BLE_INCLUDED == TRUE
451     le_test_mode,
452 #else
453     NULL,
454 #endif
455     config_hci_snoop_log,
456     set_os_callouts,
457     read_energy_info,
458     dump,
459     config_clear
460 };
461 
bluetooth__get_bluetooth_interface()462 const bt_interface_t* bluetooth__get_bluetooth_interface ()
463 {
464     /* fixme -- add property to disable bt interface ? */
465 
466     return &bluetoothInterface;
467 }
468 
close_bluetooth_stack(struct hw_device_t * device)469 static int close_bluetooth_stack(struct hw_device_t* device)
470 {
471     UNUSED(device);
472     cleanup();
473     return 0;
474 }
475 
open_bluetooth_stack(const struct hw_module_t * module,UNUSED_ATTR char const * name,struct hw_device_t ** abstraction)476 static int open_bluetooth_stack(const struct hw_module_t *module, UNUSED_ATTR char const *name, struct hw_device_t **abstraction) {
477   static bluetooth_device_t device = {
478     .common = {
479       .tag = HARDWARE_DEVICE_TAG,
480       .version = 0,
481       .close = close_bluetooth_stack,
482     },
483     .get_bluetooth_interface = bluetooth__get_bluetooth_interface
484   };
485 
486   device.common.module = (struct hw_module_t *)module;
487   *abstraction = (struct hw_device_t *)&device;
488   return 0;
489 }
490 
491 
492 static struct hw_module_methods_t bt_stack_module_methods = {
493     .open = open_bluetooth_stack,
494 };
495 
496 struct hw_module_t HAL_MODULE_INFO_SYM = {
497     .tag = HARDWARE_MODULE_TAG,
498     .version_major = 1,
499     .version_minor = 0,
500     .id = BT_HARDWARE_MODULE_ID,
501     .name = "Bluetooth Stack",
502     .author = "The Android Open Source Project",
503     .methods = &bt_stack_module_methods
504 };
505