static void bt_hid_notify_get_report(struct hid_device *dev, uint8_t *buf,
int len)
{
struct hal_ev_hidhost_get_report *ev;
int ev_len;
char address[18];
ba2str(&dev->dst, address);
DBG("device %s", address);
ev_len = sizeof(*ev);
if (!((buf[0] == (HID_MSG_DATA | HID_DATA_TYPE_INPUT)) ||
(buf[0] == (HID_MSG_DATA | HID_DATA_TYPE_OUTPUT)) ||
(buf[0] == (HID_MSG_DATA | HID_DATA_TYPE_FEATURE)))) {
ev = g_malloc0(ev_len);
ev->status = buf[0];
bdaddr2android(&dev->dst, ev->bdaddr);
goto send;
}
/* Report porotocol mode reply contains id after hdr, in boot
* protocol mode id doesn't exist */
ev_len += (dev->boot_dev) ? (len - 1) : (len - 2);
ev = g_malloc0(ev_len);
ev->status = HAL_HIDHOST_STATUS_OK;
bdaddr2android(&dev->dst, ev->bdaddr);
/* Report porotocol mode reply contains id after hdr, in boot
* protocol mode id doesn't exist */
if (dev->boot_dev) {
ev->len = len - 1;
memcpy(ev->data, buf + 1, ev->len);
} else {
ev->len = len - 2;
memcpy(ev->data, buf + 2, ev->len);
}
send:
ipc_send_notif(HAL_SERVICE_ID_HIDHOST, HAL_EV_HIDHOST_GET_REPORT,
ev_len, ev);
g_free(ev);
}
static void avrcp_disconnect_action(void)
{
struct test_data *data = tester_get_data();
const uint8_t *addr = hciemu_get_client_bdaddr(data->hciemu);
struct step *step = g_new0(struct step, 1);
bt_bdaddr_t bdaddr;
bdaddr2android((const bdaddr_t *) addr, &bdaddr);
step->action_status = data->if_a2dp->disconnect(&bdaddr);
schedule_action_verification(step);
}
static void hidhost_set_report_action(void)
{
struct test_data *data = tester_get_data();
const uint8_t *hid_addr = hciemu_get_client_bdaddr(data->hciemu);
struct step *step = g_new0(struct step, 1);
char *buf = "fe0201";
bt_bdaddr_t bdaddr;
bdaddr2android((const bdaddr_t *) hid_addr, &bdaddr);
step->action_status = data->if_hid->send_data(&bdaddr, buf);
schedule_action_verification(step);
}
static void hidhost_virtual_unplug_action(void)
{
struct test_data *data = tester_get_data();
const uint8_t *hid_addr = hciemu_get_client_bdaddr(data->hciemu);
struct step *step = g_new0(struct step, 1);
bt_bdaddr_t bdaddr;
bdaddr2android((const bdaddr_t *) hid_addr, &bdaddr);
step->action_status = data->if_hid->virtual_unplug(&bdaddr);
schedule_action_verification(step);
}
static void hidhost_set_protocol_action(void)
{
struct test_data *data = tester_get_data();
const uint8_t *hid_addr = hciemu_get_client_bdaddr(data->hciemu);
struct step *step = g_new0(struct step, 1);
bt_bdaddr_t bdaddr;
bdaddr2android((const bdaddr_t *) hid_addr, &bdaddr);
step->action_status = data->if_hid->set_protocol(&bdaddr,
BTHH_REPORT_MODE);
schedule_action_verification(step);
}
static int avrcp_device_add_session(struct avrcp_device *dev, int fd,
uint16_t imtu, uint16_t omtu)
{
struct hal_ev_avrcp_remote_features ev;
char address[18];
dev->session = avrcp_new(fd, imtu, omtu, dev->version);
if (!dev->session)
return -EINVAL;
avrcp_set_destroy_cb(dev->session, disconnect_cb, dev);
avrcp_set_passthrough_handlers(dev->session, passthrough_handlers,
dev);
avrcp_register_player(dev->session, &control_ind, &control_cfm, dev);
dev->queue = g_queue_new();
ba2str(&dev->dst, address);
/* FIXME: get the real name of the device */
avrcp_init_uinput(dev->session, "bluetooth", address);
bdaddr2android(&dev->dst, ev.bdaddr);
ev.features = HAL_AVRCP_FEATURE_NONE;
DBG("version 0x%02x", dev->version);
if (dev->version < 0x0103)
goto done;
ev.features |= HAL_AVRCP_FEATURE_METADATA;
if (dev->version < 0x0104)
goto done;
ev.features |= HAL_AVRCP_FEATURE_ABSOLUTE_VOLUME;
avrcp_get_capabilities(dev->session, CAP_EVENTS_SUPPORTED);
done:
ipc_send_notif(hal_ipc, HAL_SERVICE_ID_AVRCP,
HAL_EV_AVRCP_REMOTE_FEATURES,
sizeof(ev), &ev);
return 0;
}
static void send_channel_state_notify(struct health_channel *channel,
uint8_t state, int fd)
{
struct hal_ev_health_channel_state ev;
DBG("");
bdaddr2android(&channel->dev->dst, ev.bdaddr);
ev.app_id = channel->dev->app_id;
ev.mdep_index = channel->mdep_id - 1;
ev.channel_id = channel->id;
ev.channel_state = state;
ipc_send_notif_with_fd(hal_ipc, HAL_SERVICE_ID_HEALTH,
HAL_EV_HEALTH_CHANNEL_STATE,
sizeof(ev), &ev, fd);
}
static void bt_audio_notify_state(struct a2dp_setup *setup, uint8_t state)
{
struct hal_ev_a2dp_audio_state ev;
char address[18];
if (setup->state == state)
return;
setup->state = state;
ba2str(&setup->dev->dst, address);
DBG("device %s state %u", address, state);
bdaddr2android(&setup->dev->dst, ev.bdaddr);
ev.state = state;
ipc_send_notif(hal_ipc, HAL_SERVICE_ID_A2DP, HAL_EV_A2DP_AUDIO_STATE,
sizeof(ev), &ev);
}
static void bt_hid_notify_state(struct hid_device *dev, uint8_t state)
{
struct hal_ev_hidhost_conn_state ev;
char address[18];
if (dev->state == state)
return;
dev->state = state;
ba2str(&dev->dst, address);
DBG("device %s state %u", address, state);
bdaddr2android(&dev->dst, ev.bdaddr);
ev.state = state;
ipc_send_notif(hal_ipc, HAL_SERVICE_ID_HIDHOST,
HAL_EV_HIDHOST_CONN_STATE, sizeof(ev), &ev);
}
static void bt_hid_set_info(struct hid_device *dev)
{
struct hal_ev_hidhost_info ev;
DBG("");
bdaddr2android(&dev->dst, ev.bdaddr);
ev.attr = 0; /* TODO: Check what is this field */
ev.subclass = dev->subclass;
ev.app_id = 0; /* TODO: Check what is this field */
ev.vendor = dev->vendor;
ev.product = dev->product;
ev.version = dev->version;
ev.country = dev->country;
ev.descr_len = dev->rd_size;
memset(ev.descr, 0, sizeof(ev.descr));
memcpy(ev.descr, dev->rd_data, ev.descr_len);
ipc_send_notif(hal_ipc, HAL_SERVICE_ID_HIDHOST, HAL_EV_HIDHOST_INFO,
sizeof(ev), &ev);
}
static void bt_hid_notify_virtual_unplug(struct hid_device *dev,
uint8_t *buf, int len)
{
struct hal_ev_hidhost_virtual_unplug ev;
char address[18];
ba2str(&dev->dst, address);
DBG("device %s", address);
bdaddr2android(&dev->dst, ev.bdaddr);
ev.status = HAL_HIDHOST_GENERAL_ERROR;
/* Wait either channels to HUP */
if (dev->intr_io && dev->ctrl_io) {
g_io_channel_shutdown(dev->intr_io, TRUE, NULL);
g_io_channel_shutdown(dev->ctrl_io, TRUE, NULL);
bt_hid_notify_state(dev, HAL_HIDHOST_STATE_DISCONNECTING);
ev.status = HAL_HIDHOST_STATUS_OK;
}
ipc_send_notif(hal_ipc, HAL_SERVICE_ID_HIDHOST,
HAL_EV_HIDHOST_VIRTUAL_UNPLUG, sizeof(ev), &ev);
}
static void bt_pan_notify_conn_state(struct pan_device *dev, uint8_t state)
{
struct hal_ev_pan_conn_state ev;
char addr[18];
if (dev->conn_state == state)
return;
dev->conn_state = state;
ba2str(&dev->dst, addr);
DBG("device %s state %u", addr, state);
bdaddr2android(&dev->dst, ev.bdaddr);
ev.state = state;
ev.local_role = local_role;
ev.remote_role = dev->role;
ev.status = HAL_STATUS_SUCCESS;
ipc_send_notif(hal_ipc, HAL_SERVICE_ID_PAN, HAL_EV_PAN_CONN_STATE,
sizeof(ev), &ev);
if (dev->conn_state == HAL_PAN_STATE_DISCONNECTED)
pan_device_remove(dev);
}
