bluetooth.cc revision 713993d1784ab7c23aee1fa3cf1ab8676cc0aa69 
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
71bt_callbacks_t *bt_hal_cbacks = NULL;
72bool restricted_mode = FALSE;
73
74/************************************************************************************
75**  Externs
76************************************************************************************/
77
78/* list all extended interfaces here */
79
80/* handsfree profile */
81extern bthf_interface_t *btif_hf_get_interface();
82/* handsfree profile - client */
83extern bthf_client_interface_t *btif_hf_client_get_interface();
84/* advanced audio profile */
85extern btav_interface_t *btif_av_get_src_interface();
86extern btav_interface_t *btif_av_get_sink_interface();
87/*rfc l2cap*/
88extern btsock_interface_t *btif_sock_get_interface();
89/* hid host profile */
90extern bthh_interface_t *btif_hh_get_interface();
91/* health device profile */
92extern bthl_interface_t *btif_hl_get_interface();
93/*pan*/
94extern btpan_interface_t *btif_pan_get_interface();
95/*map client*/
96extern btmce_interface_t *btif_mce_get_interface();
97#if BLE_INCLUDED == TRUE
98/* gatt */
99extern const btgatt_interface_t *btif_gatt_get_interface();
100#endif
101/* avrc target */
102extern btrc_interface_t *btif_rc_get_interface();
103/* avrc controller */
104extern btrc_interface_t *btif_rc_ctrl_get_interface();
105/*SDP search client*/
106extern btsdp_interface_t *btif_sdp_get_interface();
107
108/************************************************************************************
109**  Functions
110************************************************************************************/
111
112static bool interface_ready(void) {
113  return bt_hal_cbacks != NULL;
114}
115
116static 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
128static 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
144static 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
156static 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
164static void cleanup(void) {
165  stack_manager_get_interface()->clean_up_stack();
166}
167
168bool is_restricted_mode() {
169  return restricted_mode;
170}
171
172static 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
181static 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
190static 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
199int 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
208int 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
217int 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
226int 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
235int 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
244static 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
253static 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
262static 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
271static 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
281static 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
290static 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
302static 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
311static 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
321static 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
331static 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
339static 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
366static 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
416int 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
427int 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
439int 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
451int 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
462static int set_os_callouts(bt_os_callouts_t *callouts) {
463    wakelock_set_os_callouts(callouts);
464    return BT_STATUS_SUCCESS;
465}
466
467static int config_clear(void) {
468    LOG_INFO(LOG_TAG, "%s", __func__);
469    return btif_config_clear() ? BT_STATUS_SUCCESS : BT_STATUS_FAIL;
470}
471
472static 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
512const bt_interface_t* bluetooth__get_bluetooth_interface ()
513{
514    /* fixme -- add property to disable bt interface ? */
515
516    return &bluetoothInterface;
517}
518
519static int close_bluetooth_stack(struct hw_device_t* device)
520{
521    UNUSED(device);
522    cleanup();
523    return 0;
524}
525
526static 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  device.common.tag = HARDWARE_DEVICE_TAG;
529  device.common.version = 0;
530  device.common.close = close_bluetooth_stack;
531  device.get_bluetooth_interface = bluetooth__get_bluetooth_interface;
532  device.common.module = (struct hw_module_t *)module;
533  *abstraction = (struct hw_device_t *)&device;
534  return 0;
535}
536
537static struct hw_module_methods_t bt_stack_module_methods = {
538    .open = open_bluetooth_stack,
539};
540
541EXPORT_SYMBOL struct hw_module_t HAL_MODULE_INFO_SYM = {
542    .tag = HARDWARE_MODULE_TAG,
543    .version_major = 1,
544    .version_minor = 0,
545    .id = BT_HARDWARE_MODULE_ID,
546    .name = "Bluetooth Stack",
547    .author = "The Android Open Source Project",
548    .methods = &bt_stack_module_methods
549};
550