static void wakeup_writer(struct mgmt *mgmt)
{
if (!queue_isempty(mgmt->pending_list)) {
/* only queued reply commands trigger wakeup */
if (queue_isempty(mgmt->reply_queue))
return;
}
if (mgmt->writer_active)
return;
io_set_write_handler(mgmt->io, can_write_data, mgmt,
write_watch_destroy);
}
static void wakeup_writer(struct hfp_gw *hfp)
{
if (hfp->writer_active)
return;
if (!ringbuf_len(hfp->write_buf))
return;
if (!io_set_write_handler(hfp->io, can_write_data,
hfp, write_watch_destroy))
return;
hfp->writer_active = true;
}
bool bt_hci_flush(struct bt_hci *hci)
{
if (!hci)
return false;
if (hci->writer_active) {
io_set_write_handler(hci->io, NULL, NULL, NULL);
hci->writer_active = false;
}
queue_remove_all(hci->cmd_queue, NULL, NULL, cmd_free);
queue_remove_all(hci->rsp_queue, NULL, NULL, cmd_free);
return true;
}
static void wakeup_writer(struct bt_hci *hci)
{
if (hci->writer_active)
return;
if (hci->num_cmds < 1)
return;
if (queue_isempty(hci->cmd_queue))
return;
if (!io_set_write_handler(hci->io, io_write_callback, hci, NULL))
return;
hci->writer_active = true;
}
static void wakeup_writer(struct bt_att *att)
{
if (att->writer_active)
return;
/* Set the write handler only if there is anything that can be sent
* at all.
*/
if (queue_isempty(att->write_queue)) {
if ((att->pending_req || queue_isempty(att->req_queue)) &&
(att->pending_ind || queue_isempty(att->ind_queue)))
return;
}
if (!io_set_write_handler(att->io, can_write_data, att,
write_watch_destroy))
return;
att->writer_active = true;
}
void bt_att_unref(struct bt_att *att)
{
if (!att)
return;
if (__sync_sub_and_fetch(&att->ref_count, 1))
return;
bt_att_unregister_all(att);
bt_att_cancel_all(att);
io_set_write_handler(att->io, NULL, NULL, NULL);
io_set_read_handler(att->io, NULL, NULL, NULL);
queue_destroy(att->req_queue, NULL);
queue_destroy(att->ind_queue, NULL);
queue_destroy(att->write_queue, NULL);
queue_destroy(att->notify_list, NULL);
att->req_queue = NULL;
att->ind_queue = NULL;
att->write_queue = NULL;
att->notify_list = NULL;
io_destroy(att->io);
att->io = NULL;
if (att->close_on_unref)
close(att->fd);
if (att->timeout_destroy)
att->timeout_destroy(att->timeout_data);
if (att->debug_destroy)
att->debug_destroy(att->debug_data);
free(att->buf);
att->buf = NULL;
free(att);
}
void hfp_hf_unref(struct hfp_hf *hfp)
{
if (!hfp)
return;
if (__sync_sub_and_fetch(&hfp->ref_count, 1))
return;
io_set_write_handler(hfp->io, NULL, NULL, NULL);
io_set_read_handler(hfp->io, NULL, NULL, NULL);
io_set_disconnect_handler(hfp->io, NULL, NULL, NULL);
io_destroy(hfp->io);
hfp->io = NULL;
if (hfp->close_on_unref)
close(hfp->fd);
hfp_hf_set_debug(hfp, NULL, NULL, NULL);
ringbuf_free(hfp->read_buf);
hfp->read_buf = NULL;
ringbuf_free(hfp->write_buf);
hfp->write_buf = NULL;
queue_destroy(hfp->event_handlers, destroy_event_handler);
hfp->event_handlers = NULL;
queue_destroy(hfp->cmd_queue, free);
hfp->cmd_queue = NULL;
if (!hfp->in_disconnect) {
free(hfp);
return;
}
hfp->destroyed = true;
}
void mgmt_unref(struct mgmt *mgmt)
{
if (!mgmt)
return;
if (__sync_sub_and_fetch(&mgmt->ref_count, 1))
return;
mgmt_unregister_all(mgmt);
mgmt_cancel_all(mgmt);
queue_destroy(mgmt->reply_queue, NULL);
queue_destroy(mgmt->request_queue, NULL);
io_set_write_handler(mgmt->io, NULL, NULL, NULL);
io_set_read_handler(mgmt->io, NULL, NULL, NULL);
io_destroy(mgmt->io);
mgmt->io = NULL;
if (mgmt->close_on_unref)
close(mgmt->fd);
if (mgmt->debug_destroy)
mgmt->debug_destroy(mgmt->debug_data);
free(mgmt->buf);
mgmt->buf = NULL;
if (!mgmt->in_notify) {
queue_destroy(mgmt->notify_list, NULL);
queue_destroy(mgmt->pending_list, NULL);
free(mgmt);
return;
}
mgmt->destroyed = true;
}
