/******************************************************************************
*
* Copyright (C) 2009-2012 Broadcom Corporation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
******************************************************************************/
/************************************************************************************
*
* Filename: btif_core.c
*
* Description: Contains core functionality related to interfacing between
* Bluetooth HAL and BTE core stack.
*
***********************************************************************************/
#include <stdlib.h>
#include <hardware/bluetooth.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <dirent.h>
#include <ctype.h>
#include <cutils/properties.h>
#define LOG_TAG "BTIF_CORE"
#include "btif_api.h"
#include "bta_api.h"
#include "gki.h"
#include "btu.h"
#include "bte.h"
#include "bd.h"
#include "btif_av.h"
#include "btif_storage.h"
#include "btif_util.h"
#include "btif_sock.h"
#include "btif_pan.h"
#include "btif_profile_queue.h"
#include "btif_config.h"
/************************************************************************************
** Constants & Macros
************************************************************************************/
#ifndef BTIF_TASK_STACK_SIZE
#define BTIF_TASK_STACK_SIZE 0x2000 /* In bytes */
#endif
#ifndef BTE_DID_CONF_FILE
#define BTE_DID_CONF_FILE "/etc/bluetooth/bt_did.conf"
#endif
#define BTIF_TASK_STR ((INT8 *) "BTIF")
/************************************************************************************
** Local type definitions
************************************************************************************/
/* These type definitions are used when passing data from the HAL to BTIF context
* in the downstream path for the adapter and remote_device property APIs */
typedef struct {
bt_bdaddr_t bd_addr;
bt_property_type_t type;
} btif_storage_read_t;
typedef struct {
bt_bdaddr_t bd_addr;
bt_property_t prop;
} btif_storage_write_t;
typedef union {
btif_storage_read_t read_req;
btif_storage_write_t write_req;
} btif_storage_req_t;
typedef enum {
BTIF_CORE_STATE_DISABLED = 0,
BTIF_CORE_STATE_ENABLING,
BTIF_CORE_STATE_ENABLED,
BTIF_CORE_STATE_DISABLING
} btif_core_state_t;
/************************************************************************************
** Static variables
************************************************************************************/
bt_bdaddr_t btif_local_bd_addr;
static UINT32 btif_task_stack[(BTIF_TASK_STACK_SIZE + 3) / 4];
/* holds main adapter state */
static btif_core_state_t btif_core_state = BTIF_CORE_STATE_DISABLED;
static int btif_shutdown_pending = 0;
static tBTA_SERVICE_MASK btif_enabled_services = 0;
/*
* This variable should be set to 1, if the Bluedroid+BTIF libraries are to
* function in DUT mode.
*
* To set this, the btif_init_bluetooth needs to be called with argument as 1
*/
static UINT8 btif_dut_mode = 0;
/************************************************************************************
** Static functions
************************************************************************************/
static bt_status_t btif_associate_evt(void);
static bt_status_t btif_disassociate_evt(void);
/* sends message to btif task */
static void btif_sendmsg(void *p_msg);
/************************************************************************************
** Externs
************************************************************************************/
extern void bte_load_did_conf(const char *p_path);
/** TODO: Move these to _common.h */
void bte_main_boot_entry(void);
void bte_main_enable(uint8_t *local_addr);
void bte_main_disable(void);
void bte_main_shutdown(void);
#if (defined(HCILP_INCLUDED) && HCILP_INCLUDED == TRUE)
void bte_main_enable_lpm(BOOLEAN enable);
#endif
void bte_main_postload_cfg(void);
void btif_dm_execute_service_request(UINT16 event, char *p_param);
#ifdef BTIF_DM_OOB_TEST
void btif_dm_load_local_oob(void);
#endif
/************************************************************************************
** Functions
************************************************************************************/
/*****************************************************************************
** Context switching functions
*****************************************************************************/
/*******************************************************************************
**
** Function btif_context_switched
**
** Description Callback used to execute transferred context callback
**
** p_msg : message to be executed in btif context
**
** Returns void
**
*******************************************************************************/
static void btif_context_switched(void *p_msg)
{
tBTIF_CONTEXT_SWITCH_CBACK *p;
BTIF_TRACE_VERBOSE0("btif_context_switched");
p = (tBTIF_CONTEXT_SWITCH_CBACK *) p_msg;
/* each callback knows how to parse the data */
if (p->p_cb)
p->p_cb(p->event, p->p_param);
}
/*******************************************************************************
**
** Function btif_transfer_context
**
** Description This function switches context to btif task
**
** p_cback : callback used to process message in btif context
** event : event id of message
** p_params : parameter area passed to callback (copied)
** param_len : length of parameter area
** p_copy_cback : If set this function will be invoked for deep copy
**
** Returns void
**
*******************************************************************************/
bt_status_t btif_transfer_context (tBTIF_CBACK *p_cback, UINT16 event, char* p_params, int param_len, tBTIF_COPY_CBACK *p_copy_cback)
{
tBTIF_CONTEXT_SWITCH_CBACK *p_msg;
BTIF_TRACE_VERBOSE2("btif_transfer_context event %d, len %d", event, param_len);
/* allocate and send message that will be executed in btif context */
if ((p_msg = (tBTIF_CONTEXT_SWITCH_CBACK *) GKI_getbuf(sizeof(tBTIF_CONTEXT_SWITCH_CBACK) + param_len)) != NULL)
{
p_msg->hdr.event = BT_EVT_CONTEXT_SWITCH_EVT; /* internal event */
p_msg->p_cb = p_cback;
p_msg->event = event; /* callback event */
/* check if caller has provided a copy callback to do the deep copy */
if (p_copy_cback)
{
p_copy_cback(event, p_msg->p_param, p_params);
}
else if (p_params)
{
memcpy(p_msg->p_param, p_params, param_len); /* callback parameter data */
}
btif_sendmsg(p_msg);
return BT_STATUS_SUCCESS;
}
else
{
/* let caller deal with a failed allocation */
return BT_STATUS_NOMEM;
}
}
/*******************************************************************************
**
** Function btif_is_dut_mode
**
** Description checks if BTIF is currently in DUT mode
**
** Returns 1 if test mode, otherwize 0
**
*******************************************************************************/
UINT8 btif_is_dut_mode(void)
{
return (btif_dut_mode == 1);
}
/*******************************************************************************
**
** Function btif_is_enabled
**
** Description checks if main adapter is fully enabled
**
** Returns 1 if fully enabled, otherwize 0
**
*******************************************************************************/
int btif_is_enabled(void)
{
return ((!btif_is_dut_mode()) && (btif_core_state == BTIF_CORE_STATE_ENABLED));
}
/*******************************************************************************
**
** Function btif_task
**
** Description BTIF task handler managing all messages being passed
** Bluetooth HAL and BTA.
**
** Returns void
**
*******************************************************************************/
static void btif_task(UINT32 params)
{
UINT16 event;
BT_HDR *p_msg;
BTIF_TRACE_DEBUG0("btif task starting");
btif_associate_evt();
for(;;)
{
/* wait for specified events */
event = GKI_wait(0xFFFF, 0);
/*
* Wait for the trigger to init chip and stack. This trigger will
* be received by btu_task once the UART is opened and ready
*/
if (event == BT_EVT_TRIGGER_STACK_INIT)
{
BTIF_TRACE_DEBUG0("btif_task: received trigger stack init event");
BTA_EnableBluetooth(bte_dm_evt);
}
if (event & EVENT_MASK(GKI_SHUTDOWN_EVT))
break;
if(event & TASK_MBOX_1_EVT_MASK)
{
while((p_msg = GKI_read_mbox(BTU_BTIF_MBOX)) != NULL)
{
BTIF_TRACE_VERBOSE1("btif task fetched event %x", p_msg->event);
switch (p_msg->event)
{
case BT_EVT_CONTEXT_SWITCH_EVT:
btif_context_switched(p_msg);
break;
default:
BTIF_TRACE_ERROR1("unhandled btif event (%d)", p_msg->event & BT_EVT_MASK);
break;
}
GKI_freebuf(p_msg);
}
}
}
btif_disassociate_evt();
BTIF_TRACE_DEBUG0("btif task exiting");
}
/*******************************************************************************
**
** Function btif_sendmsg
**
** Description Sends msg to BTIF task
**
** Returns void
**
*******************************************************************************/
void btif_sendmsg(void *p_msg)
{
GKI_send_msg(BTIF_TASK, BTU_BTIF_MBOX, p_msg);
}
static void btif_fetch_local_bdaddr(bt_bdaddr_t *local_addr)
{
char val[256];
uint8_t valid_bda = FALSE;
int val_size = 0;
const uint8_t null_bdaddr[BD_ADDR_LEN] = {0,0,0,0,0,0};
/* Get local bdaddr storage path from property */
if (property_get(PROPERTY_BT_BDADDR_PATH, val, NULL))
{
int addr_fd;
BTIF_TRACE_DEBUG1("local bdaddr is stored in %s", val);
if ((addr_fd = open(val, O_RDONLY)) != -1)
{
memset(val, 0, sizeof(val));
read(addr_fd, val, FACTORY_BT_BDADDR_STORAGE_LEN);
str2bd(val, local_addr);
/* If this is not a reserved/special bda, then use it */
if (memcmp(local_addr->address, null_bdaddr, BD_ADDR_LEN) != 0)
{
valid_bda = TRUE;
BTIF_TRACE_DEBUG6("Got Factory BDA %02X:%02X:%02X:%02X:%02X:%02X",
local_addr->address[0], local_addr->address[1], local_addr->address[2],
local_addr->address[3], local_addr->address[4], local_addr->address[5]);
}
close(addr_fd);
}
}
if(!valid_bda)
{
val_size = sizeof(val);
if(btif_config_get_str("Local", "Adapter", "Address", val, &val_size))
{
str2bd(val, local_addr);
BTIF_TRACE_DEBUG1("local bdaddr from bt_config.xml is %s", val);
return;
}
}
/* No factory BDADDR found. Look for previously generated random BDA */
if ((!valid_bda) && \
(property_get(PERSIST_BDADDR_PROPERTY, val, NULL)))
{
str2bd(val, local_addr);
valid_bda = TRUE;
BTIF_TRACE_DEBUG6("Got prior random BDA %02X:%02X:%02X:%02X:%02X:%02X",
local_addr->address[0], local_addr->address[1], local_addr->address[2],
local_addr->address[3], local_addr->address[4], local_addr->address[5]);
}
/* Generate new BDA if necessary */
if (!valid_bda)
{
bdstr_t bdstr;
/* Seed the random number generator */
srand((unsigned int) (time(0)));
/* No autogen BDA. Generate one now. */
local_addr->address[0] = 0x22;
local_addr->address[1] = 0x22;
local_addr->address[2] = (uint8_t) ((rand() >> 8) & 0xFF);
local_addr->address[3] = (uint8_t) ((rand() >> 8) & 0xFF);
local_addr->address[4] = (uint8_t) ((rand() >> 8) & 0xFF);
local_addr->address[5] = (uint8_t) ((rand() >> 8) & 0xFF);
/* Convert to ascii, and store as a persistent property */
bd2str(local_addr, &bdstr);
BTIF_TRACE_DEBUG2("No preset BDA. Generating BDA: %s for prop %s",
(char*)bdstr, PERSIST_BDADDR_PROPERTY);
if (property_set(PERSIST_BDADDR_PROPERTY, (char*)bdstr) < 0)
BTIF_TRACE_ERROR1("Failed to set random BDA in prop %s",PERSIST_BDADDR_PROPERTY);
}
//save the bd address to config file
bdstr_t bdstr;
bd2str(local_addr, &bdstr);
val_size = sizeof(val);
if (btif_config_get_str("Local", "Adapter", "Address", val, &val_size))
{
if (strcmp(bdstr, val) ==0)
{
// BDA is already present in the config file.
return;
}
}
btif_config_set_str("Local", "Adapter", "Address", bdstr);
btif_config_save();
}
/*****************************************************************************
**
** btif core api functions
**
*****************************************************************************/
/*******************************************************************************
**
** Function btif_init_bluetooth
**
** Description Creates BTIF task and prepares BT scheduler for startup
**
** Returns bt_status_t
**
*******************************************************************************/
bt_status_t btif_init_bluetooth()
{
UINT8 status;
btif_config_init();
bte_main_boot_entry();
/* As part of the init, fetch the local BD ADDR */
memset(&btif_local_bd_addr, 0, sizeof(bt_bdaddr_t));
btif_fetch_local_bdaddr(&btif_local_bd_addr);
/* start btif task */
status = GKI_create_task(btif_task, BTIF_TASK, BTIF_TASK_STR,
(UINT16 *) ((UINT8 *)btif_task_stack + BTIF_TASK_STACK_SIZE),
sizeof(btif_task_stack));
if (status != GKI_SUCCESS)
return BT_STATUS_FAIL;
return BT_STATUS_SUCCESS;
}
/*******************************************************************************
**
** Function btif_associate_evt
**
** Description Event indicating btif_task is up
** Attach btif_task to JVM
**
** Returns void
**
*******************************************************************************/
static bt_status_t btif_associate_evt(void)
{
BTIF_TRACE_DEBUG1("%s: notify ASSOCIATE_JVM", __FUNCTION__);
HAL_CBACK(bt_hal_cbacks, thread_evt_cb, ASSOCIATE_JVM);
return BT_STATUS_SUCCESS;
}
/*******************************************************************************
**
** Function btif_enable_bluetooth
**
** Description Performs chip power on and kickstarts OS scheduler
**
** Returns bt_status_t
**
*******************************************************************************/
bt_status_t btif_enable_bluetooth(void)
{
BTIF_TRACE_DEBUG0("BTIF ENABLE BLUETOOTH");
if (btif_core_state != BTIF_CORE_STATE_DISABLED)
{
ALOGD("not disabled\n");
return BT_STATUS_DONE;
}
btif_core_state = BTIF_CORE_STATE_ENABLING;
/* Create the GKI tasks and run them */
bte_main_enable(btif_local_bd_addr.address);
return BT_STATUS_SUCCESS;
}
/*******************************************************************************
**
** Function btif_enable_bluetooth_evt
**
** Description Event indicating bluetooth enable is completed
** Notifies HAL user with updated adapter state
**
** Returns void
**
*******************************************************************************/
void btif_enable_bluetooth_evt(tBTA_STATUS status, BD_ADDR local_bd)
{
bt_bdaddr_t bd_addr;
bdstr_t bdstr;
bdcpy(bd_addr.address, local_bd);
BTIF_TRACE_DEBUG3("%s: status %d, local bd [%s]", __FUNCTION__, status,
bd2str(&bd_addr, &bdstr));
if (bdcmp(btif_local_bd_addr.address,local_bd))
{
bdstr_t buf;
bt_property_t prop;
/**
* The Controller's BDADDR does not match to the BTIF's initial BDADDR!
* This could be because the factory BDADDR was stored separatley in
* the Controller's non-volatile memory rather than in device's file
* system.
**/
BTIF_TRACE_WARNING0("***********************************************");
BTIF_TRACE_WARNING6("BTIF init BDA was %02X:%02X:%02X:%02X:%02X:%02X",
btif_local_bd_addr.address[0], btif_local_bd_addr.address[1],
btif_local_bd_addr.address[2], btif_local_bd_addr.address[3],
btif_local_bd_addr.address[4], btif_local_bd_addr.address[5]);
BTIF_TRACE_WARNING6("Controller BDA is %02X:%02X:%02X:%02X:%02X:%02X",
local_bd[0], local_bd[1], local_bd[2],
local_bd[3], local_bd[4], local_bd[5]);
BTIF_TRACE_WARNING0("***********************************************");
bdcpy(btif_local_bd_addr.address, local_bd);
//save the bd address to config file
bd2str(&btif_local_bd_addr, &buf);
btif_config_set_str("Local", "Adapter", "Address", buf);
btif_config_save();
//fire HAL callback for property change
memcpy(buf, &btif_local_bd_addr, sizeof(bt_bdaddr_t));
prop.type = BT_PROPERTY_BDADDR;
prop.val = (void*)buf;
prop.len = sizeof(bt_bdaddr_t);
HAL_CBACK(bt_hal_cbacks, adapter_properties_cb, BT_STATUS_SUCCESS, 1, &prop);
}
bte_main_postload_cfg();
#if (defined(HCILP_INCLUDED) && HCILP_INCLUDED == TRUE)
bte_main_enable_lpm(TRUE);
#endif
/* add passing up bd address as well ? */
/* callback to HAL */
if (status == BTA_SUCCESS)
{
/* initialize a2dp service */
btif_av_init();
/* init rfcomm & l2cap api */
btif_sock_init();
/* init pan */
btif_pan_init();
/* load did configuration */
bte_load_did_conf(BTE_DID_CONF_FILE);
#ifdef BTIF_DM_OOB_TEST
btif_dm_load_local_oob();
#endif
/* now fully enabled, update state */
btif_core_state = BTIF_CORE_STATE_ENABLED;
HAL_CBACK(bt_hal_cbacks, adapter_state_changed_cb, BT_STATE_ON);
}
else
{
/* cleanup rfcomm & l2cap api */
btif_sock_cleanup();
btif_pan_cleanup();
/* we failed to enable, reset state */
btif_core_state = BTIF_CORE_STATE_DISABLED;
HAL_CBACK(bt_hal_cbacks, adapter_state_changed_cb, BT_STATE_OFF);
}
}
/*******************************************************************************
**
** Function btif_disable_bluetooth
**
** Description Inititates shutdown of Bluetooth system.
** Any active links will be dropped and device entering
** non connectable/discoverable mode
**
** Returns void
**
*******************************************************************************/
bt_status_t btif_disable_bluetooth(void)
{
tBTA_STATUS status;
if (!btif_is_enabled())
{
BTIF_TRACE_ERROR0("btif_disable_bluetooth : not yet enabled");
return BT_STATUS_NOT_READY;
}
BTIF_TRACE_DEBUG0("BTIF DISABLE BLUETOOTH");
btif_dm_on_disable();
btif_core_state = BTIF_CORE_STATE_DISABLING;
/* cleanup rfcomm & l2cap api */
btif_sock_cleanup();
btif_pan_cleanup();
status = BTA_DisableBluetooth();
btif_config_flush();
if (status != BTA_SUCCESS)
{
BTIF_TRACE_ERROR1("disable bt failed (%d)", status);
/* reset the original state to allow attempting disable again */
btif_core_state = BTIF_CORE_STATE_ENABLED;
return BT_STATUS_FAIL;
}
return BT_STATUS_SUCCESS;
}
/*******************************************************************************
**
** Function btif_disable_bluetooth_evt
**
** Description Event notifying BT disable is now complete.
** Terminates main stack tasks and notifies HAL
** user with updated BT state.
**
** Returns void
**
*******************************************************************************/
void btif_disable_bluetooth_evt(void)
{
BTIF_TRACE_DEBUG1("%s", __FUNCTION__);
#if (defined(HCILP_INCLUDED) && HCILP_INCLUDED == TRUE)
bte_main_enable_lpm(FALSE);
#endif
bte_main_disable();
/* update local state */
btif_core_state = BTIF_CORE_STATE_DISABLED;
/* callback to HAL */
HAL_CBACK(bt_hal_cbacks, adapter_state_changed_cb, BT_STATE_OFF);
if (btif_shutdown_pending)
{
BTIF_TRACE_DEBUG1("%s: calling btif_shutdown_bluetooth", __FUNCTION__);
btif_shutdown_bluetooth();
}
}
/*******************************************************************************
**
** Function btif_shutdown_bluetooth
**
** Description Finalizes BT scheduler shutdown and terminates BTIF
** task.
**
** Returns void
**
*******************************************************************************/
bt_status_t btif_shutdown_bluetooth(void)
{
BTIF_TRACE_DEBUG1("%s", __FUNCTION__);
if (btif_is_enabled())
{
BTIF_TRACE_WARNING0("shutdown while still enabled, initiate disable");
/* shutdown called prior to disabling, initiate disable */
btif_disable_bluetooth();
btif_shutdown_pending = 1;
return BT_STATUS_NOT_READY;
}
btif_shutdown_pending = 0;
GKI_destroy_task(BTIF_TASK);
btif_queue_release();
bte_main_shutdown();
btif_dut_mode = 0;
BTIF_TRACE_DEBUG1("%s done", __FUNCTION__);
return BT_STATUS_SUCCESS;
}
/*******************************************************************************
**
** Function btif_disassociate_evt
**
** Description Event indicating btif_task is going down
** Detach btif_task to JVM
**
** Returns void
**
*******************************************************************************/
static bt_status_t btif_disassociate_evt(void)
{
BTIF_TRACE_DEBUG1("%s: notify DISASSOCIATE_JVM", __FUNCTION__);
HAL_CBACK(bt_hal_cbacks, thread_evt_cb, DISASSOCIATE_JVM);
/* shutdown complete, all events notified and we reset HAL callbacks */
bt_hal_cbacks = NULL;
return BT_STATUS_SUCCESS;
}
/****************************************************************************
**
** BTIF Test Mode APIs
**
*****************************************************************************/
/*******************************************************************************
**
** Function btif_dut_mode_cback
**
** Description Callback invoked on completion of vendor specific test mode command
**
** Returns None
**
*******************************************************************************/
static void btif_dut_mode_cback( tBTM_VSC_CMPL *p )
{
/* For now nothing to be done. */
}
/*******************************************************************************
**
** Function btif_dut_mode_configure
**
** Description Configure Test Mode - 'enable' to 1 puts the device in test mode and 0 exits
** test mode
**
** Returns BT_STATUS_SUCCESS on success
**
*******************************************************************************/
bt_status_t btif_dut_mode_configure(uint8_t enable)
{
BTIF_TRACE_DEBUG1("%s", __FUNCTION__);
if (btif_core_state != BTIF_CORE_STATE_ENABLED) {
BTIF_TRACE_ERROR0("btif_dut_mode_configure : Bluetooth not enabled");
return BT_STATUS_NOT_READY;
}
btif_dut_mode = enable;
if (enable == 1) {
BTA_EnableTestMode();
} else {
BTA_DisableTestMode();
}
return BT_STATUS_SUCCESS;
}
/*******************************************************************************
**
** Function btif_dut_mode_send
**
** Description Sends a HCI Vendor specific command to the controller
**
** Returns BT_STATUS_SUCCESS on success
**
*******************************************************************************/
bt_status_t btif_dut_mode_send(uint16_t opcode, uint8_t *buf, uint8_t len)
{
/* TODO: Check that opcode is a vendor command group */
BTIF_TRACE_DEBUG1("%s", __FUNCTION__);
if (!btif_is_dut_mode()) {
BTIF_TRACE_ERROR0("Bluedroid HAL needs to be init with test_mode set to 1.");
return BT_STATUS_FAIL;
}
BTM_VendorSpecificCommand(opcode, len, buf, btif_dut_mode_cback);
return BT_STATUS_SUCCESS;
}
/*****************************************************************************
**
** btif api adapter property functions
**
*****************************************************************************/
static bt_status_t btif_in_get_adapter_properties(void)
{
bt_property_t properties[6];
uint32_t num_props;
bt_bdaddr_t addr;
bt_bdname_t name;
bt_scan_mode_t mode;
uint32_t disc_timeout;
bt_bdaddr_t bonded_devices[BTM_SEC_MAX_DEVICE_RECORDS];
bt_uuid_t local_uuids[BT_MAX_NUM_UUIDS];
num_props = 0;
/* BD_ADDR */
BTIF_STORAGE_FILL_PROPERTY(&properties[num_props], BT_PROPERTY_BDADDR,
sizeof(addr), &addr);
btif_storage_get_adapter_property(&properties[num_props]);
num_props++;
/* BD_NAME */
BTIF_STORAGE_FILL_PROPERTY(&properties[num_props], BT_PROPERTY_BDNAME,
sizeof(name), &name);
btif_storage_get_adapter_property(&properties[num_props]);
num_props++;
/* SCAN_MODE */
BTIF_STORAGE_FILL_PROPERTY(&properties[num_props], BT_PROPERTY_ADAPTER_SCAN_MODE,
sizeof(mode), &mode);
btif_storage_get_adapter_property(&properties[num_props]);
num_props++;
/* DISC_TIMEOUT */
BTIF_STORAGE_FILL_PROPERTY(&properties[num_props], BT_PROPERTY_ADAPTER_DISCOVERY_TIMEOUT,
sizeof(disc_timeout), &disc_timeout);
btif_storage_get_adapter_property(&properties[num_props]);
num_props++;
/* BONDED_DEVICES */
BTIF_STORAGE_FILL_PROPERTY(&properties[num_props], BT_PROPERTY_ADAPTER_BONDED_DEVICES,
sizeof(bonded_devices), bonded_devices);
btif_storage_get_adapter_property(&properties[num_props]);
num_props++;
/* LOCAL UUIDs */
BTIF_STORAGE_FILL_PROPERTY(&properties[num_props], BT_PROPERTY_UUIDS,
sizeof(local_uuids), local_uuids);
btif_storage_get_adapter_property(&properties[num_props]);
num_props++;
HAL_CBACK(bt_hal_cbacks, adapter_properties_cb,
BT_STATUS_SUCCESS, num_props, properties);
return BT_STATUS_SUCCESS;
}
static bt_status_t btif_in_get_remote_device_properties(bt_bdaddr_t *bd_addr)
{
bt_property_t remote_properties[8];
uint32_t num_props = 0;
bt_bdname_t name, alias;
uint32_t cod, devtype;
bt_uuid_t remote_uuids[BT_MAX_NUM_UUIDS];
memset(remote_properties, 0, sizeof(remote_properties));
BTIF_STORAGE_FILL_PROPERTY(&remote_properties[num_props], BT_PROPERTY_BDNAME,
sizeof(name), &name);
btif_storage_get_remote_device_property(bd_addr,
&remote_properties[num_props]);
num_props++;
BTIF_STORAGE_FILL_PROPERTY(&remote_properties[num_props], BT_PROPERTY_REMOTE_FRIENDLY_NAME,
sizeof(alias), &alias);
btif_storage_get_remote_device_property(bd_addr,
&remote_properties[num_props]);
num_props++;
BTIF_STORAGE_FILL_PROPERTY(&remote_properties[num_props], BT_PROPERTY_CLASS_OF_DEVICE,
sizeof(cod), &cod);
btif_storage_get_remote_device_property(bd_addr,
&remote_properties[num_props]);
num_props++;
BTIF_STORAGE_FILL_PROPERTY(&remote_properties[num_props], BT_PROPERTY_TYPE_OF_DEVICE,
sizeof(devtype), &devtype);
btif_storage_get_remote_device_property(bd_addr,
&remote_properties[num_props]);
num_props++;
BTIF_STORAGE_FILL_PROPERTY(&remote_properties[num_props], BT_PROPERTY_UUIDS,
sizeof(remote_uuids), remote_uuids);
btif_storage_get_remote_device_property(bd_addr,
&remote_properties[num_props]);
num_props++;
HAL_CBACK(bt_hal_cbacks, remote_device_properties_cb,
BT_STATUS_SUCCESS, bd_addr, num_props, remote_properties);
return BT_STATUS_SUCCESS;
}
/*******************************************************************************
**
** Function execute_storage_request
**
** Description Executes adapter storage request in BTIF context
**
** Returns bt_status_t
**
*******************************************************************************/
static void execute_storage_request(UINT16 event, char *p_param)
{
uint8_t is_local;
int num_entries = 0;
bt_status_t status = BT_STATUS_SUCCESS;
BTIF_TRACE_EVENT1("execute storage request event : %d", event);
switch(event)
{
case BTIF_CORE_STORAGE_ADAPTER_WRITE:
{
btif_storage_req_t *p_req = (btif_storage_req_t*)p_param;
bt_property_t *p_prop = &(p_req->write_req.prop);
BTIF_TRACE_EVENT3("type: %d, len %d, 0x%x", p_prop->type,
p_prop->len, p_prop->val);
status = btif_storage_set_adapter_property(p_prop);
HAL_CBACK(bt_hal_cbacks, adapter_properties_cb, status, 1, p_prop);
} break;
case BTIF_CORE_STORAGE_ADAPTER_READ:
{
btif_storage_req_t *p_req = (btif_storage_req_t*)p_param;
char buf[512];
bt_property_t prop;
prop.type = p_req->read_req.type;
prop.val = (void*)buf;
prop.len = sizeof(buf);
status = btif_storage_get_adapter_property(&prop);
HAL_CBACK(bt_hal_cbacks, adapter_properties_cb, status, 1, &prop);
} break;
case BTIF_CORE_STORAGE_ADAPTER_READ_ALL:
{
status = btif_in_get_adapter_properties();
} break;
case BTIF_CORE_STORAGE_NOTIFY_STATUS:
{
HAL_CBACK(bt_hal_cbacks, adapter_properties_cb, status, 0, NULL);
} break;
default:
BTIF_TRACE_ERROR2("%s invalid event id (%d)", __FUNCTION__, event);
break;
}
}
static void execute_storage_remote_request(UINT16 event, char *p_param)
{
bt_status_t status = BT_STATUS_FAIL;
bt_property_t prop;
BTIF_TRACE_EVENT1("execute storage remote request event : %d", event);
switch (event)
{
case BTIF_CORE_STORAGE_REMOTE_READ:
{
char buf[1024];
btif_storage_req_t *p_req = (btif_storage_req_t*)p_param;
prop.type = p_req->read_req.type;
prop.val = (void*) buf;
prop.len = sizeof(buf);
status = btif_storage_get_remote_device_property(&(p_req->read_req.bd_addr),
&prop);
HAL_CBACK(bt_hal_cbacks, remote_device_properties_cb,
status, &(p_req->read_req.bd_addr), 1, &prop);
}break;
case BTIF_CORE_STORAGE_REMOTE_WRITE:
{
btif_storage_req_t *p_req = (btif_storage_req_t*)p_param;
status = btif_storage_set_remote_device_property(&(p_req->write_req.bd_addr),
&(p_req->write_req.prop));
}break;
case BTIF_CORE_STORAGE_REMOTE_READ_ALL:
{
btif_storage_req_t *p_req = (btif_storage_req_t*)p_param;
btif_in_get_remote_device_properties(&p_req->read_req.bd_addr);
}break;
}
}
void btif_adapter_properties_evt(bt_status_t status, uint32_t num_props,
bt_property_t *p_props)
{
HAL_CBACK(bt_hal_cbacks, adapter_properties_cb,
status, num_props, p_props);
}
void btif_remote_properties_evt(bt_status_t status, bt_bdaddr_t *remote_addr,
uint32_t num_props, bt_property_t *p_props)
{
HAL_CBACK(bt_hal_cbacks, remote_device_properties_cb,
status, remote_addr, num_props, p_props);
}
/*******************************************************************************
**
** Function btif_in_storage_request_copy_cb
**
** Description Switch context callback function to perform the deep copy for
** both the adapter and remote_device property API
**
** Returns None
**
*******************************************************************************/
static void btif_in_storage_request_copy_cb(UINT16 event,
char *p_new_buf, char *p_old_buf)
{
btif_storage_req_t *new_req = (btif_storage_req_t*)p_new_buf;
btif_storage_req_t *old_req = (btif_storage_req_t*)p_old_buf;
BTIF_TRACE_EVENT1("%s", __FUNCTION__);
switch (event)
{
case BTIF_CORE_STORAGE_REMOTE_WRITE:
case BTIF_CORE_STORAGE_ADAPTER_WRITE:
{
bdcpy(new_req->write_req.bd_addr.address, old_req->write_req.bd_addr.address);
/* Copy the member variables one at a time */
new_req->write_req.prop.type = old_req->write_req.prop.type;
new_req->write_req.prop.len = old_req->write_req.prop.len;
new_req->write_req.prop.val = (UINT8 *)(p_new_buf + sizeof(btif_storage_req_t));
memcpy(new_req->write_req.prop.val, old_req->write_req.prop.val,
old_req->write_req.prop.len);
}break;
}
}
/*******************************************************************************
**
** Function btif_get_adapter_properties
**
** Description Fetch all available properties (local & remote)
**
** Returns bt_status_t
**
*******************************************************************************/
bt_status_t btif_get_adapter_properties(void)
{
BTIF_TRACE_EVENT1("%s", __FUNCTION__);
if (!btif_is_enabled())
return BT_STATUS_NOT_READY;
return btif_transfer_context(execute_storage_request,
BTIF_CORE_STORAGE_ADAPTER_READ_ALL,
NULL, 0, NULL);
}
/*******************************************************************************
**
** Function btif_get_adapter_property
**
** Description Fetches property value from local cache
**
** Returns bt_status_t
**
*******************************************************************************/
bt_status_t btif_get_adapter_property(bt_property_type_t type)
{
btif_storage_req_t req;
BTIF_TRACE_EVENT2("%s %d", __FUNCTION__, type);
/* Allow get_adapter_property only for BDADDR and BDNAME if BT is disabled */
if (!btif_is_enabled() && (type != BT_PROPERTY_BDADDR) && (type != BT_PROPERTY_BDNAME))
return BT_STATUS_NOT_READY;
memset(&(req.read_req.bd_addr), 0, sizeof(bt_bdaddr_t));
req.read_req.type = type;
return btif_transfer_context(execute_storage_request,
BTIF_CORE_STORAGE_ADAPTER_READ,
(char*)&req, sizeof(btif_storage_req_t), NULL);
}
/*******************************************************************************
**
** Function btif_set_adapter_property
**
** Description Updates core stack with property value and stores it in
** local cache
**
** Returns bt_status_t
**
*******************************************************************************/
bt_status_t btif_set_adapter_property(const bt_property_t *property)
{
btif_storage_req_t req;
bt_status_t status = BT_STATUS_SUCCESS;
int storage_req_id = BTIF_CORE_STORAGE_NOTIFY_STATUS; /* default */
char bd_name[BTM_MAX_LOC_BD_NAME_LEN +1];
UINT16 name_len = 0;
BTIF_TRACE_EVENT3("btif_set_adapter_property type: %d, len %d, 0x%x",
property->type, property->len, property->val);
if (!btif_is_enabled())
return BT_STATUS_NOT_READY;
switch(property->type)
{
case BT_PROPERTY_BDNAME:
{
name_len = property->len > BTM_MAX_LOC_BD_NAME_LEN ? BTM_MAX_LOC_BD_NAME_LEN:
property->len;
memcpy(bd_name,property->val, name_len);
bd_name[name_len] = '\0';
BTIF_TRACE_EVENT1("set property name : %s", (char *)bd_name);
BTA_DmSetDeviceName((char *)bd_name);
storage_req_id = BTIF_CORE_STORAGE_ADAPTER_WRITE;
}
break;
case BT_PROPERTY_ADAPTER_SCAN_MODE:
{
bt_scan_mode_t mode = *(bt_scan_mode_t*)property->val;
tBTA_DM_DISC disc_mode;
tBTA_DM_CONN conn_mode;
switch(mode)
{
case BT_SCAN_MODE_NONE:
disc_mode = BTA_DM_NON_DISC;
conn_mode = BTA_DM_NON_CONN;
break;
case BT_SCAN_MODE_CONNECTABLE:
disc_mode = BTA_DM_NON_DISC;
conn_mode = BTA_DM_CONN;
break;
case BT_SCAN_MODE_CONNECTABLE_DISCOVERABLE:
disc_mode = BTA_DM_GENERAL_DISC;
conn_mode = BTA_DM_CONN;
break;
default:
BTIF_TRACE_ERROR1("invalid scan mode (0x%x)", mode);
return BT_STATUS_PARM_INVALID;
}
BTIF_TRACE_EVENT1("set property scan mode : %x", mode);
BTA_DmSetVisibility(disc_mode, conn_mode, BTA_DM_IGNORE, BTA_DM_IGNORE);
storage_req_id = BTIF_CORE_STORAGE_ADAPTER_WRITE;
}
break;
case BT_PROPERTY_ADAPTER_DISCOVERY_TIMEOUT:
{
/* Nothing to do beside store the value in NV. Java
will change the SCAN_MODE property after setting timeout,
if required */
storage_req_id = BTIF_CORE_STORAGE_ADAPTER_WRITE;
}
break;
case BT_PROPERTY_BDADDR:
case BT_PROPERTY_UUIDS:
case BT_PROPERTY_ADAPTER_BONDED_DEVICES:
case BT_PROPERTY_REMOTE_FRIENDLY_NAME:
/* no write support through HAL, these properties are only populated from BTA events */
status = BT_STATUS_FAIL;
break;
default:
BTIF_TRACE_ERROR1("btif_get_adapter_property : invalid type %d",
property->type);
status = BT_STATUS_FAIL;
break;
}
if (storage_req_id != BTIF_CORE_STORAGE_NO_ACTION)
{
int btif_status;
/* pass on to storage for updating local database */
memset(&(req.write_req.bd_addr), 0, sizeof(bt_bdaddr_t));
memcpy(&(req.write_req.prop), property, sizeof(bt_property_t));
return btif_transfer_context(execute_storage_request,
storage_req_id,
(char*)&req,
sizeof(btif_storage_req_t)+property->len,
btif_in_storage_request_copy_cb);
}
return status;
}
/*******************************************************************************
**
** Function btif_get_remote_device_property
**
** Description Fetches the remote device property from the NVRAM
**
** Returns bt_status_t
**
*******************************************************************************/
bt_status_t btif_get_remote_device_property(bt_bdaddr_t *remote_addr,
bt_property_type_t type)
{
btif_storage_req_t req;
if (!btif_is_enabled())
return BT_STATUS_NOT_READY;
memcpy(&(req.read_req.bd_addr), remote_addr, sizeof(bt_bdaddr_t));
req.read_req.type = type;
return btif_transfer_context(execute_storage_remote_request,
BTIF_CORE_STORAGE_REMOTE_READ,
(char*)&req, sizeof(btif_storage_req_t),
NULL);
}
/*******************************************************************************
**
** Function btif_get_remote_device_properties
**
** Description Fetches all the remote device properties from NVRAM
**
** Returns bt_status_t
**
*******************************************************************************/
bt_status_t btif_get_remote_device_properties(bt_bdaddr_t *remote_addr)
{
btif_storage_req_t req;
if (!btif_is_enabled())
return BT_STATUS_NOT_READY;
memcpy(&(req.read_req.bd_addr), remote_addr, sizeof(bt_bdaddr_t));
return btif_transfer_context(execute_storage_remote_request,
BTIF_CORE_STORAGE_REMOTE_READ_ALL,
(char*)&req, sizeof(btif_storage_req_t),
NULL);
}
/*******************************************************************************
**
** Function btif_set_remote_device_property
**
** Description Writes the remote device property to NVRAM.
** Currently, BT_PROPERTY_REMOTE_FRIENDLY_NAME is the only
** remote device property that can be set
**
** Returns bt_status_t
**
*******************************************************************************/
bt_status_t btif_set_remote_device_property(bt_bdaddr_t *remote_addr,
const bt_property_t *property)
{
btif_storage_req_t req;
if (!btif_is_enabled())
return BT_STATUS_NOT_READY;
memcpy(&(req.write_req.bd_addr), remote_addr, sizeof(bt_bdaddr_t));
memcpy(&(req.write_req.prop), property, sizeof(bt_property_t));
return btif_transfer_context(execute_storage_remote_request,
BTIF_CORE_STORAGE_REMOTE_WRITE,
(char*)&req,
sizeof(btif_storage_req_t)+property->len,
btif_in_storage_request_copy_cb);
}
/*******************************************************************************
**
** Function btif_get_remote_service_record
**
** Description Looks up the service matching uuid on the remote device
** and fetches the SCN and service_name if the UUID is found
**
** Returns bt_status_t
**
*******************************************************************************/
bt_status_t btif_get_remote_service_record(bt_bdaddr_t *remote_addr,
bt_uuid_t *uuid)
{
if (!btif_is_enabled())
return BT_STATUS_NOT_READY;
return btif_dm_get_remote_service_record(remote_addr, uuid);
}
/*******************************************************************************
**
** Function btif_get_enabled_services_mask
**
** Description Fetches currently enabled services
**
** Returns tBTA_SERVICE_MASK
**
*******************************************************************************/
tBTA_SERVICE_MASK btif_get_enabled_services_mask(void)
{
return btif_enabled_services;
}
/*******************************************************************************
**
** Function btif_enable_service
**
** Description Enables the service 'service_ID' to the service_mask.
** Upon BT enable, BTIF core shall invoke the BTA APIs to
** enable the profiles
**
** Returns bt_status_t
**
*******************************************************************************/
bt_status_t btif_enable_service(tBTA_SERVICE_ID service_id)
{
tBTA_SERVICE_ID *p_id = &service_id;
/* If BT is enabled, we need to switch to BTIF context and trigger the
* enable for that profile
*
* Otherwise, we just set the flag. On BT_Enable, the DM will trigger
* enable for the profiles that have been enabled */
btif_enabled_services |= (1 << service_id);
BTIF_TRACE_ERROR2("%s: current services:0x%x", __FUNCTION__, btif_enabled_services);
if (btif_is_enabled())
{
btif_transfer_context(btif_dm_execute_service_request,
BTIF_DM_ENABLE_SERVICE,
(char*)p_id, sizeof(tBTA_SERVICE_ID), NULL);
}
return BT_STATUS_SUCCESS;
}
/*******************************************************************************
**
** Function btif_disable_service
**
** Description Disables the service 'service_ID' to the service_mask.
** Upon BT disable, BTIF core shall invoke the BTA APIs to
** disable the profiles
**
** Returns bt_status_t
**
*******************************************************************************/
bt_status_t btif_disable_service(tBTA_SERVICE_ID service_id)
{
tBTA_SERVICE_ID *p_id = &service_id;
/* If BT is enabled, we need to switch to BTIF context and trigger the
* disable for that profile so that the appropriate uuid_property_changed will
* be triggerred. Otherwise, we just need to clear the service_id in the mask
*/
btif_enabled_services &= (tBTA_SERVICE_MASK)(~(1<<service_id));
BTIF_TRACE_ERROR2("%s: Current Services:0x%x", __FUNCTION__, btif_enabled_services);
if (btif_is_enabled())
{
btif_transfer_context(btif_dm_execute_service_request,
BTIF_DM_DISABLE_SERVICE,
(char*)p_id, sizeof(tBTA_SERVICE_ID), NULL);
}
return BT_STATUS_SUCCESS;
}