static int set_adapter_property(const bt_property_t *property)
{
char buf[sizeof(struct hal_cmd_set_adapter_prop) + property->len];
struct hal_cmd_set_adapter_prop *cmd = (void *) buf;
DBG("prop: %s", btproperty2str(property));
if (!interface_ready())
return BT_STATUS_NOT_READY;
adapter_prop_from_hal(property, &cmd->type, &cmd->len, cmd->val);
return hal_ipc_cmd(HAL_SERVICE_ID_BLUETOOTH, HAL_OP_SET_ADAPTER_PROP,
sizeof(*cmd) + cmd->len, cmd, 0, NULL, NULL);
}
static bt_status_t set_player_app_value_rsp(btrc_status_t rsp_status)
{
struct hal_cmd_avrcp_set_player_attrs_value cmd;
DBG("");
if (!interface_ready())
return BT_STATUS_NOT_READY;
cmd.status = rsp_status;
return hal_ipc_cmd(HAL_SERVICE_ID_AVRCP,
HAL_OP_AVRCP_SET_PLAYER_ATTRS_VALUE,
sizeof(cmd), &cmd, 0, NULL, NULL);
}
static int get_adapter_property(bt_property_type_t type)
{
struct hal_cmd_get_adapter_prop cmd;
DBG("prop: %s (%d)", bt_property_type_t2str(type), type);
if (!interface_ready())
return BT_STATUS_NOT_READY;
/* type match IPC type */
cmd.type = type;
return hal_ipc_cmd(HAL_SERVICE_ID_BLUETOOTH, HAL_OP_GET_ADAPTER_PROP,
sizeof(cmd), &cmd, 0, NULL, NULL);
}
static bt_status_t read_remote_rssi(int client_if, const bt_bdaddr_t *bd_addr)
{
struct hal_cmd_gatt_client_read_remote_rssi cmd;
if (!interface_ready())
return BT_STATUS_NOT_READY;
cmd.client_if = client_if;
memcpy(cmd.bdaddr, bd_addr, sizeof(*bd_addr));
return hal_ipc_cmd(HAL_SERVICE_ID_GATT,
HAL_OP_GATT_CLIENT_READ_REMOTE_RSSI,
sizeof(cmd), &cmd, NULL, NULL, NULL);
}
static int get_remote_services(bt_bdaddr_t *remote_addr)
{
struct hal_cmd_get_remote_services cmd;
DBG("bdaddr: %s", bdaddr2str(remote_addr));
if (!interface_ready())
return BT_STATUS_NOT_READY;
memcpy(cmd.bdaddr, remote_addr, sizeof(cmd.bdaddr));
return hal_ipc_cmd(HAL_SERVICE_ID_BLUETOOTH,
HAL_OP_GET_REMOTE_SERVICES, sizeof(cmd), &cmd, 0,
NULL, NULL);
}
static int init(bt_callbacks_t *callbacks)
{
struct hal_cmd_register_module cmd;
int status;
DBG("");
if (interface_ready())
return BT_STATUS_DONE;
bt_hal_cbacks = callbacks;
hal_ipc_register(HAL_SERVICE_ID_BLUETOOTH, ev_handlers,
sizeof(ev_handlers)/sizeof(ev_handlers[0]));
if (!hal_ipc_init()) {
bt_hal_cbacks = NULL;
return BT_STATUS_FAIL;
}
cmd.service_id = HAL_SERVICE_ID_BLUETOOTH;
status = hal_ipc_cmd(HAL_SERVICE_ID_CORE, HAL_OP_REGISTER_MODULE,
sizeof(cmd), &cmd, NULL, NULL, NULL);
if (status != BT_STATUS_SUCCESS) {
error("Failed to register 'bluetooth' service");
goto fail;
}
cmd.service_id = HAL_SERVICE_ID_SOCK;
status = hal_ipc_cmd(HAL_SERVICE_ID_CORE, HAL_OP_REGISTER_MODULE,
sizeof(cmd), &cmd, NULL, NULL, NULL);
if (status != BT_STATUS_SUCCESS) {
error("Failed to register 'socket' service");
goto fail;
}
return status;
fail:
hal_ipc_cleanup();
bt_hal_cbacks = NULL;
hal_ipc_unregister(HAL_SERVICE_ID_BLUETOOTH);
return status;
}
static bt_status_t server_connect(int server_if, const bt_bdaddr_t *bd_addr,
bool is_direct)
{
struct hal_cmd_gatt_server_connect cmd;
if (!interface_ready())
return BT_STATUS_NOT_READY;
cmd.server_if = server_if;
cmd.is_direct = is_direct;
memcpy(cmd.bdaddr, bd_addr, sizeof(*bd_addr));
return hal_ipc_cmd(HAL_SERVICE_ID_GATT, HAL_OP_GATT_SERVER_CONNECT,
sizeof(cmd), &cmd, 0, NULL, NULL);
}
static bt_status_t at_response(bthf_at_response_t response, int error)
{
struct hal_cmd_handsfree_at_response cmd;
DBG("");
if (!interface_ready())
return BT_STATUS_NOT_READY;
cmd.response = response;
cmd.error = error;
return hal_ipc_cmd(HAL_SERVICE_ID_HANDSFREE,
HAL_OP_HANDSFREE_AT_RESPONSE,
sizeof(cmd), &cmd, 0, NULL, NULL);
}
static bt_status_t volume_control(bthf_volume_type_t type, int volume)
{
struct hal_cmd_handsfree_volume_control cmd;
DBG("");
if (!interface_ready())
return BT_STATUS_NOT_READY;
cmd.type = type;
cmd.volume = volume;
return hal_ipc_cmd(HAL_SERVICE_ID_HANDSFREE,
HAL_OP_HANDSFREE_VOLUME_CONTROL, sizeof(cmd),
&cmd, 0, NULL, NULL);
}
static void cleanup()
{
struct hal_cmd_unregister_module cmd;
DBG("");
if (!interface_ready())
return;
cbs = NULL;
cmd.service_id = HAL_SERVICE_ID_A2DP;
hal_ipc_cmd(HAL_SERVICE_ID_CORE, HAL_OP_UNREGISTER_MODULE,
sizeof(cmd), &cmd, 0, NULL, NULL);
}
static bt_status_t add_service(int server_if, btgatt_srvc_id_t *srvc_id,
int num_handles)
{
struct hal_cmd_gatt_server_add_service cmd;
if (!interface_ready())
return BT_STATUS_NOT_READY;
cmd.server_if = server_if;
cmd.num_handles = num_handles;
srvc_id_to_hal(&cmd.srvc_id, srvc_id);
return hal_ipc_cmd(HAL_SERVICE_ID_GATT, HAL_OP_GATT_SERVER_ADD_SERVICE,
sizeof(cmd), &cmd, 0, NULL, NULL);
}
static bt_status_t start_service(int server_if, int service_handle,
int transport)
{
struct hal_cmd_gatt_server_start_service cmd;
if (!interface_ready())
return BT_STATUS_NOT_READY;
cmd.server_if = server_if;
cmd.service_handle = service_handle;
cmd.transport = transport;
return hal_ipc_cmd(HAL_SERVICE_ID_GATT,
HAL_OP_GATT_SERVER_START_SERVICE,
sizeof(cmd), &cmd, 0, NULL, NULL);
}
static bt_status_t add_included_service(int server_if, int service_handle,
int included_handle)
{
struct hal_cmd_gatt_server_add_inc_service cmd;
if (!interface_ready())
return BT_STATUS_NOT_READY;
cmd.server_if = server_if;
cmd.service_handle = service_handle;
cmd.included_handle = included_handle;
return hal_ipc_cmd(HAL_SERVICE_ID_GATT,
HAL_OP_GATT_SERVER_ADD_INC_SERVICE,
sizeof(cmd), &cmd, 0, NULL, NULL);
}
static bt_status_t disconnect(int client_if, const bt_bdaddr_t *bd_addr,
int conn_id)
{
struct hal_cmd_gatt_client_disconnect cmd;
if (!interface_ready())
return BT_STATUS_NOT_READY;
cmd.client_if = client_if;
cmd.conn_id = conn_id;
memcpy(cmd.bdaddr, bd_addr, sizeof(*bd_addr));
return hal_ipc_cmd(HAL_SERVICE_ID_GATT, HAL_OP_GATT_CLIENT_DISCONNECT,
sizeof(cmd), &cmd, 0, NULL, NULL);
}
static bt_status_t stop_voice_recognition_real(bt_bdaddr_t *bd_addr)
{
struct hal_cmd_handsfree_stop_vr cmd;
DBG("");
if (!interface_ready())
return BT_STATUS_NOT_READY;
memset(&cmd, 0, sizeof(cmd));
if (bd_addr)
memcpy(cmd.bdaddr, bd_addr, sizeof(cmd.bdaddr));
return hal_ipc_cmd(HAL_SERVICE_ID_HANDSFREE, HAL_OP_HANDSFREE_STOP_VR,
sizeof(cmd), &cmd, NULL, NULL, NULL);
}
static bt_status_t handsfree_connect(bt_bdaddr_t *bd_addr)
{
struct hal_cmd_handsfree_connect cmd;
DBG("");
if (!interface_ready())
return BT_STATUS_NOT_READY;
if (!bd_addr)
return BT_STATUS_PARM_INVALID;
memcpy(cmd.bdaddr, bd_addr, sizeof(cmd.bdaddr));
return hal_ipc_cmd(HAL_SERVICE_ID_HANDSFREE, HAL_OP_HANDSFREE_CONNECT,
sizeof(cmd), &cmd, NULL, NULL, NULL);
}
/* will be called from notification thread context */
void bt_notify_a2dp(uint8_t opcode, void *buf, uint16_t len)
{
if (!interface_ready())
return;
switch (opcode) {
case HAL_EV_A2DP_CONN_STATE:
handle_conn_state(buf);
break;
case HAL_EV_A2DP_AUDIO_STATE:
handle_audio_state(buf);
break;
default:
DBG("Unhandled callback opcode=0x%x", opcode);
break;
}
}
static bt_status_t pan_connect(const bt_bdaddr_t *bd_addr, int local_role,
int remote_role)
{
struct hal_cmd_pan_connect cmd;
DBG("");
if (!interface_ready())
return BT_STATUS_NOT_READY;
memcpy(cmd.bdaddr, bd_addr, sizeof(cmd.bdaddr));
cmd.local_role = local_role;
cmd.remote_role = remote_role;
return hal_ipc_cmd(HAL_SERVICE_ID_PAN, HAL_OP_PAN_CONNECT,
sizeof(cmd), &cmd, NULL, NULL, NULL);
}
static int dut_mode_send(uint16_t opcode, uint8_t *buf, uint8_t len)
{
uint8_t cmd_buf[sizeof(struct hal_cmd_dut_mode_send) + len];
struct hal_cmd_dut_mode_send *cmd = (void *) cmd_buf;
DBG("opcode %u len %u", opcode, len);
if (!interface_ready())
return BT_STATUS_NOT_READY;
cmd->opcode = opcode;
cmd->len = len;
memcpy(cmd->data, buf, cmd->len);
return hal_ipc_cmd(HAL_SERVICE_ID_BLUETOOTH, HAL_OP_DUT_MODE_SEND,
sizeof(cmd_buf), cmd, 0, NULL, NULL);
}
static bt_status_t disconnect(bt_bdaddr_t *bd_addr)
{
struct hal_cmd_hidhost_disconnect cmd;
DBG("");
if (!interface_ready())
return BT_STATUS_NOT_READY;
if (!bd_addr)
return BT_STATUS_PARM_INVALID;
memcpy(cmd.bdaddr, bd_addr, sizeof(cmd.bdaddr));
return hal_ipc_cmd(HAL_SERVICE_ID_HIDHOST, HAL_OP_HIDHOST_DISCONNECT,
sizeof(cmd), &cmd, NULL, NULL, NULL);
}
static bt_status_t get_play_status_rsp(btrc_play_status_t status,
uint32_t song_len, uint32_t song_pos)
{
struct hal_cmd_avrcp_get_play_status cmd;
DBG("");
if (!interface_ready())
return BT_STATUS_NOT_READY;
cmd.status = status;
cmd.duration = song_len;
cmd.position = song_pos;
return hal_ipc_cmd(HAL_SERVICE_ID_AVRCP, HAL_OP_AVRCP_GET_PLAY_STATUS,
sizeof(cmd), &cmd, 0, NULL, NULL);
}
static int pin_reply(const bt_bdaddr_t *bd_addr, uint8_t accept,
uint8_t pin_len, bt_pin_code_t *pin_code)
{
struct hal_cmd_pin_reply cmd;
DBG("bdaddr: %s", bdaddr2str(bd_addr));
if (!interface_ready())
return BT_STATUS_NOT_READY;
memcpy(cmd.bdaddr, bd_addr, sizeof(cmd.bdaddr));
cmd.accept = accept;
cmd.pin_len = pin_len;
memcpy(cmd.pin_code, pin_code, sizeof(cmd.pin_code));
return hal_ipc_cmd(HAL_SERVICE_ID_BLUETOOTH, HAL_OP_PIN_REPLY,
sizeof(cmd), &cmd, 0, NULL, NULL);
}
static bt_status_t add_descriptor(int server_if, int service_handle,
bt_uuid_t *uuid, int permissions)
{
struct hal_cmd_gatt_server_add_descriptor cmd;
if (!interface_ready())
return BT_STATUS_NOT_READY;
cmd.server_if = server_if;
cmd.service_handle = service_handle;
cmd.permissions = permissions;
memcpy(cmd.uuid, uuid, sizeof(*uuid));
return hal_ipc_cmd(HAL_SERVICE_ID_GATT,
HAL_OP_GATT_SERVER_ADD_DESCRIPTOR,
sizeof(cmd), &cmd, 0, NULL, NULL);
}
static int pan_get_local_role(void)
{
struct hal_rsp_pan_get_role rsp;
size_t len = sizeof(rsp);
bt_status_t status;
DBG("");
if (!interface_ready())
return BTPAN_ROLE_NONE;
status = hal_ipc_cmd(HAL_SERVICE_ID_PAN, HAL_OP_PAN_GET_ROLE, 0, NULL,
&len, &rsp, NULL);
if (status != BT_STATUS_SUCCESS)
return BTPAN_ROLE_NONE;
return rsp.local_role;
}
static bt_status_t virtual_unplug(bt_bdaddr_t *bd_addr)
{
struct hal_cmd_hidhost_virtual_unplug cmd;
DBG("");
if (!interface_ready())
return BT_STATUS_NOT_READY;
if (!bd_addr)
return BT_STATUS_PARM_INVALID;
memcpy(cmd.bdaddr, bd_addr, sizeof(cmd.bdaddr));
return hal_ipc_cmd(HAL_SERVICE_ID_HIDHOST,
HAL_OP_HIDHOST_VIRTUAL_UNPLUG,
sizeof(cmd), &cmd, NULL, NULL, NULL);
}
static int ssp_reply(const bt_bdaddr_t *bd_addr, bt_ssp_variant_t variant,
uint8_t accept, uint32_t passkey)
{
struct hal_cmd_ssp_reply cmd;
DBG("bdaddr: %s", bdaddr2str(bd_addr));
if (!interface_ready())
return BT_STATUS_NOT_READY;
memcpy(cmd.bdaddr, bd_addr, sizeof(cmd.bdaddr));
/* type match IPC type */
cmd.ssp_variant = variant;
cmd.accept = accept;
cmd.passkey = passkey;
return hal_ipc_cmd(HAL_SERVICE_ID_BLUETOOTH, HAL_OP_SSP_REPLY,
sizeof(cmd), &cmd, 0, NULL, NULL);
}
static bt_status_t read_characteristic(int conn_id, btgatt_srvc_id_t *srvc_id,
btgatt_gatt_id_t *char_id,
int auth_req)
{
struct hal_cmd_gatt_client_read_characteristic cmd;
if (!interface_ready())
return BT_STATUS_NOT_READY;
cmd.conn_id = conn_id;
cmd.auth_req = auth_req;
srvc_id_to_hal(&cmd.srvc_id, srvc_id);
gatt_id_to_hal(&cmd.gatt_id, char_id);
return hal_ipc_cmd(HAL_SERVICE_ID_GATT,
HAL_OP_GATT_CLIENT_READ_CHARACTERISTIC,
sizeof(cmd), &cmd, 0, NULL, NULL);
}
static bt_status_t configure_wbs(bt_bdaddr_t *bd_addr, bthf_wbs_config_t config)
{
struct hal_cmd_handsfree_configure_wbs cmd;
DBG("%u", config);
if (!interface_ready())
return BT_STATUS_NOT_READY;
if (!bd_addr)
return BT_STATUS_PARM_INVALID;
memcpy(cmd.bdaddr, bd_addr, sizeof(cmd.bdaddr));
cmd.config = config;
return hal_ipc_cmd(HAL_SERVICE_ID_HANDSFREE,
HAL_OP_HANDSFREE_CONFIGURE_WBS,
sizeof(cmd), &cmd, NULL, NULL, NULL);
}
static bt_status_t clcc_response_real(int index, bthf_call_direction_t dir,
bthf_call_state_t state,
bthf_call_mode_t mode,
bthf_call_mpty_type_t mpty,
const char *number,
bthf_call_addrtype_t type,
bt_bdaddr_t *bd_addr)
{
char buf[IPC_MTU];
struct hal_cmd_handsfree_clcc_response *cmd = (void *) buf;
size_t len;
DBG("");
if (!interface_ready())
return BT_STATUS_NOT_READY;
memset(cmd, 0, sizeof(*cmd));
if (bd_addr)
memcpy(cmd->bdaddr, bd_addr, sizeof(cmd->bdaddr));
cmd->index = index;
cmd->dir = dir;
cmd->state = state;
cmd->mode = mode;
cmd->mpty = mpty;
cmd->type = type;
if (number) {
cmd->number_len = strlen(number) + 1;
memcpy(cmd->number, number, cmd->number_len);
} else {
cmd->number_len = 0;
}
len = sizeof(*cmd) + cmd->number_len;
return hal_ipc_cmd(HAL_SERVICE_ID_HANDSFREE,
HAL_OP_HANDSFREE_CLCC_RESPONSE,
len, cmd, NULL, NULL, NULL);
}
static bt_status_t send_data(bt_bdaddr_t *bd_addr, char *data)
{
uint8_t buf[IPC_MTU];
struct hal_cmd_hidhost_send_data *cmd = (void *) buf;
DBG("");
if (!interface_ready())
return BT_STATUS_NOT_READY;
if (!bd_addr || !data)
return BT_STATUS_PARM_INVALID;
memcpy(cmd->bdaddr, bd_addr, sizeof(cmd->bdaddr));
cmd->len = strlen(data);
memcpy(cmd->data, data, cmd->len);
return hal_ipc_cmd(HAL_SERVICE_ID_HIDHOST, HAL_OP_HIDHOST_SEND_DATA,
sizeof(*cmd) + cmd->len, buf, NULL, NULL, NULL);
}
