static int remove_bond(const bt_bdaddr_t *bd_addr)
{
struct hal_cmd_remove_bond cmd;
DBG("bdaddr: %s", bdaddr2str(bd_addr));
if (!interface_ready())
return BT_STATUS_NOT_READY;
memcpy(cmd.bdaddr, bd_addr, sizeof(cmd.bdaddr));
return hal_ipc_cmd(HAL_SERVICE_ID_BLUETOOTH, HAL_OP_REMOVE_BOND,
sizeof(cmd), &cmd, 0, NULL, NULL);
}
static int dut_mode_configure(uint8_t enable)
{
struct hal_cmd_dut_mode_conf cmd;
DBG("enable %u", enable);
if (!interface_ready())
return BT_STATUS_NOT_READY;
cmd.enable = enable;
return hal_ipc_cmd(HAL_SERVICE_ID_BLUETOOTH, HAL_OP_DUT_MODE_CONF,
sizeof(cmd), &cmd, 0, NULL, NULL);
}
static bt_status_t set_volume(uint8_t volume)
{
struct hal_cmd_avrcp_set_volume cmd;
DBG("");
if (!interface_ready())
return BT_STATUS_NOT_READY;
cmd.value = volume;
return hal_ipc_cmd(HAL_SERVICE_ID_AVRCP, HAL_OP_AVRCP_SET_VOLUME,
sizeof(cmd), &cmd, 0, NULL, NULL);
}
static bt_status_t pan_enable(int local_role)
{
struct hal_cmd_pan_enable cmd;
DBG("");
if (!interface_ready())
return BT_STATUS_NOT_READY;
cmd.local_role = local_role;
return hal_ipc_cmd(HAL_SERVICE_ID_PAN, HAL_OP_PAN_ENABLE,
sizeof(cmd), &cmd, NULL, NULL, NULL);
}
static bt_status_t pan_disconnect(const bt_bdaddr_t *bd_addr)
{
struct hal_cmd_pan_disconnect cmd;
DBG("");
if (!interface_ready())
return BT_STATUS_NOT_READY;
memcpy(cmd.bdaddr, bd_addr, sizeof(cmd.bdaddr));
return hal_ipc_cmd(HAL_SERVICE_ID_PAN, HAL_OP_PAN_DISCONNECT,
sizeof(cmd), &cmd, NULL, NULL, NULL);
}
static bt_status_t a2dp_connect(bt_bdaddr_t *bd_addr)
{
struct hal_cmd_a2dp_connect cmd;
DBG("");
if (!interface_ready())
return BT_STATUS_NOT_READY;
memcpy(cmd.bdaddr, bd_addr, sizeof(cmd.bdaddr));
return hal_ipc_cmd(HAL_SERVICE_ID_A2DP, HAL_OP_A2DP_CONNECT,
sizeof(cmd), &cmd, NULL, 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 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, 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 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 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 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 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 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 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 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 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 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 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);
}
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 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 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 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 play_pos_changed_rsp(btrc_notification_type_t type,
uint32_t *song_pos)
{
char buf[IPC_MTU];
struct hal_cmd_avrcp_register_notification *cmd = (void *) buf;
size_t len;
cmd->event = BTRC_EVT_PLAY_POS_CHANGED;
cmd->type = type;
cmd->len = sizeof(*song_pos);
memcpy(cmd->data, song_pos, cmd->len);
len = sizeof(*cmd) + cmd->len;
return hal_ipc_cmd(HAL_SERVICE_ID_AVRCP,
HAL_OP_AVRCP_REGISTER_NOTIFICATION,
len, cmd, 0, NULL, NULL);
}
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 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);
}
