/*******************************************************************************
**
** Function btm_free
**
** Description This function is called at btu core free the fixed queue
**
** Returns void
**
*******************************************************************************/
void btm_free(void)
{
fixed_queue_free(btm_cb.page_queue, osi_free_func);
fixed_queue_free(btm_cb.sec_pending_q, osi_free_func);
#if BTM_DYNAMIC_MEMORY
FREE_AND_RESET(btm_cb_ptr);
#endif
btm_lock_free();
btm_sem_free();
}
/*******************************************************************************
**
** Function l2c_ucd_delete_sec_pending_q
**
** Description discard all of UCD packets in security pending queue
**
** Returns None
**
*******************************************************************************/
void l2c_ucd_delete_sec_pending_q(tL2C_LCB *p_lcb)
{
/* clean up any security pending UCD */
while (p_lcb->ucd_out_sec_pending_q.p_first) {
osi_free(fixed_queue_try_dequeue(p_lcb->ucd_out_sec_pending_q));
}
fixed_queue_free(p_lcb->ucd_out_sec_pending_q, NULL);
p_lcb->ucd_out_sec_pending_q = NULL;
while (! fixed_queue_is_empty(p_lcb->ucd_in_sec_pending_q)) {
osi_free(fixed_queue_try_dequeue(p_lcb->ucd_in_sec_pending_q));
}
fixed_queue_free(p_lcb->ucd_in_sec_pending_q);
p_lcb->ucd_in_sec_pending_q = NULL;
}
/*******************************************************************************
**
** Function avct_lcb_dealloc
**
** Description Deallocate a link control block.
**
**
** Returns void.
**
*******************************************************************************/
void avct_lcb_dealloc(tAVCT_LCB *p_lcb, tAVCT_LCB_EVT *p_data)
{
UNUSED(p_data);
AVCT_TRACE_DEBUG("%s allocated: %d", __func__, p_lcb->allocated);
// Check if the LCB is still referenced
tAVCT_CCB *p_ccb = &avct_cb.ccb[0];
for (size_t i = 0; i < AVCT_NUM_CONN; i++, p_ccb++)
{
if (p_ccb->allocated && p_ccb->p_lcb == p_lcb)
{
AVCT_TRACE_DEBUG("%s LCB in use; lcb index: %d", __func__, i);
return;
}
}
// If not, de-allocate now...
AVCT_TRACE_DEBUG("%s Freeing LCB", __func__);
osi_free(p_lcb->p_rx_msg);
fixed_queue_free(p_lcb->tx_q, NULL);
memset(p_lcb, 0, sizeof(tAVCT_LCB));
}
static void hci_layer_deinit_env(void)
{
command_waiting_response_t *cmd_wait_q;
if (hci_host_env.command_queue) {
fixed_queue_free(hci_host_env.command_queue, osi_free_func);
}
if (hci_host_env.packet_queue) {
fixed_queue_free(hci_host_env.packet_queue, osi_free_func);
}
cmd_wait_q = &hci_host_env.cmd_waiting_q;
list_free(cmd_wait_q->commands_pending_response);
osi_mutex_free(&cmd_wait_q->commands_pending_response_lock);
osi_alarm_free(cmd_wait_q->command_response_timer);
cmd_wait_q->command_response_timer = NULL;
}
static void hci_layer_deinit_env(void)
{
command_waiting_response_t *cmd_wait_q;
if (hci_host_env.command_queue) {
fixed_queue_free(hci_host_env.command_queue, allocator_calloc.free);
}
if (hci_host_env.packet_queue) {
fixed_queue_free(hci_host_env.packet_queue, buffer_allocator->free);
}
cmd_wait_q = &hci_host_env.cmd_waiting_q;
list_free(cmd_wait_q->commands_pending_response);
pthread_mutex_destroy(&cmd_wait_q->commands_pending_response_lock);
osi_alarm_free(cmd_wait_q->command_response_timer);
cmd_wait_q->command_response_timer = NULL;
}
static future_t *shut_down() {
LOG_INFO(LOG_TAG, "%s", __func__);
hci_inject->close();
if (thread) {
if (firmware_is_configured) {
non_repeating_timer_restart(epilog_timer);
thread_post(thread, event_epilog, NULL);
} else {
thread_stop(thread);
}
thread_join(thread);
}
fixed_queue_free(command_queue, buffer_allocator->free);
fixed_queue_free(packet_queue, buffer_allocator->free);
list_free(commands_pending_response);
pthread_mutex_destroy(&commands_pending_response_lock);
packet_fragmenter->cleanup();
non_repeating_timer_free(epilog_timer);
non_repeating_timer_free(command_response_timer);
non_repeating_timer_free(startup_timer);
epilog_timer = NULL;
command_response_timer = NULL;
low_power_manager->cleanup();
hal->close();
// Turn off the chip
int power_state = BT_VND_PWR_OFF;
vendor->send_command(VENDOR_CHIP_POWER_CONTROL, &power_state);
vendor->close();
thread_free(thread);
thread = NULL;
firmware_is_configured = false;
return NULL;
}
/*******************************************************************************
**
** Function rfc_alloc_multiplexer_channel
**
** Description This function returns existing or new control block for
** the BD_ADDR.
**
*******************************************************************************/
tRFC_MCB *rfc_alloc_multiplexer_channel (BD_ADDR bd_addr, BOOLEAN is_initiator)
{
int i, j;
tRFC_MCB *p_mcb = NULL;
RFCOMM_TRACE_DEBUG("rfc_alloc_multiplexer_channel: bd_addr:%02x:%02x:%02x:%02x:%02x:%02x",
bd_addr[0], bd_addr[1], bd_addr[2], bd_addr[3], bd_addr[4], bd_addr[5]);
RFCOMM_TRACE_DEBUG("rfc_alloc_multiplexer_channel:is_initiator:%d", is_initiator);
for (i = 0; i < MAX_BD_CONNECTIONS; i++) {
RFCOMM_TRACE_DEBUG("rfc_alloc_multiplexer_channel rfc_cb.port.rfc_mcb[%d].state:%d",
i, rfc_cb.port.rfc_mcb[i].state);
RFCOMM_TRACE_DEBUG("(rfc_cb.port.rfc_mcb[i].bd_addr:%02x:%02x:%02x:%02x:%02x:%02x",
rfc_cb.port.rfc_mcb[i].bd_addr[0], rfc_cb.port.rfc_mcb[i].bd_addr[1],
rfc_cb.port.rfc_mcb[i].bd_addr[2], rfc_cb.port.rfc_mcb[i].bd_addr[3],
rfc_cb.port.rfc_mcb[i].bd_addr[4], rfc_cb.port.rfc_mcb[i].bd_addr[5]);
if ((rfc_cb.port.rfc_mcb[i].state != RFC_MX_STATE_IDLE)
&& (!memcmp (rfc_cb.port.rfc_mcb[i].bd_addr, bd_addr, BD_ADDR_LEN))) {
/* Multiplexer channel found do not change anything */
/* If there was an inactivity timer running stop it now */
if (rfc_cb.port.rfc_mcb[i].state == RFC_MX_STATE_CONNECTED) {
rfc_timer_stop (&rfc_cb.port.rfc_mcb[i]);
}
RFCOMM_TRACE_DEBUG("rfc_alloc_multiplexer_channel:is_initiator:%d, found, state:%d, p_mcb:%p",
is_initiator, rfc_cb.port.rfc_mcb[i].state, &rfc_cb.port.rfc_mcb[i]);
return (&rfc_cb.port.rfc_mcb[i]);
}
}
/* connection with bd_addr does not exist */
for (i = 0, j = rfc_cb.rfc.last_mux + 1; i < MAX_BD_CONNECTIONS; i++, j++) {
if (j >= MAX_BD_CONNECTIONS) {
j = 0;
}
p_mcb = &rfc_cb.port.rfc_mcb[j];
if (rfc_cb.port.rfc_mcb[j].state == RFC_MX_STATE_IDLE) {
/* New multiplexer control block */
fixed_queue_free(p_mcb->cmd_q, NULL);
memset (p_mcb, 0, sizeof (tRFC_MCB));
memcpy (p_mcb->bd_addr, bd_addr, BD_ADDR_LEN);
RFCOMM_TRACE_DEBUG("rfc_alloc_multiplexer_channel:is_initiator:%d, create new p_mcb:%p, index:%d",
is_initiator, &rfc_cb.port.rfc_mcb[j], j);
p_mcb->cmd_q = fixed_queue_new(SIZE_MAX);
p_mcb->is_initiator = is_initiator;
rfc_timer_start (p_mcb, RFC_MCB_INIT_INACT_TIMER);
rfc_cb.rfc.last_mux = (UINT8) j;
return (p_mcb);
}
}
return (NULL);
}
void thread_free(thread_t *thread) {
if (!thread)
return;
thread_stop(thread);
pthread_join(thread->pthread, NULL);
fixed_queue_free(thread->work_queue, free);
reactor_free(thread->reactor);
free(thread);
}
/*******************************************************************************
**
** Function rfc_release_multiplexer_channel
**
** Description This function returns existing or new control block for
** the BD_ADDR.
**
*******************************************************************************/
void rfc_release_multiplexer_channel (tRFC_MCB *p_mcb)
{
rfc_timer_stop (p_mcb);
fixed_queue_free(p_mcb->cmd_q, osi_free_fun);
memset (p_mcb, 0, sizeof (tRFC_MCB));
p_mcb->state = RFC_MX_STATE_IDLE;
}
void thread_free(thread_t *thread) {
if (!thread)
return;
thread_stop(thread);
thread_join(thread);
fixed_queue_free(thread->work_queue, osi_free);
reactor_free(thread->reactor);
osi_free(thread);
}
static void btc_a2dp_sink_thread_cleanup(UNUSED_ATTR void *context)
{
/* make sure no channels are restarted while shutting down */
btc_a2dp_sink_state = BTC_A2DP_SINK_STATE_SHUTTING_DOWN;
btc_a2dp_control_set_datachnl_stat(FALSE);
/* Clear task flag */
btc_a2dp_sink_state = BTC_A2DP_SINK_STATE_OFF;
btc_a2dp_control_cleanup();
fixed_queue_free(btc_aa_snk_cb.RxSbcQ, osi_free_func);
}
/*******************************************************************************
**
** Function avdt_scb_dealloc
**
** Description Deallocate a stream control block.
**
**
** Returns void.
**
*******************************************************************************/
void avdt_scb_dealloc(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
{
UNUSED(p_data);
AVDT_TRACE_DEBUG("avdt_scb_dealloc hdl=%d\n", avdt_scb_to_hdl(p_scb));
btu_stop_timer(&p_scb->timer_entry);
#if AVDT_MULTIPLEXING == TRUE
/* free fragments we're holding, if any; it shouldn't happen */
fixed_queue_free(p_scb->frag_q, osi_free_func);
#endif
memset(p_scb, 0, sizeof(tAVDT_SCB));
}
void BTU_ShutDown(void)
{
btu_task_shut_down();
fixed_queue_free(btu_bta_msg_queue, NULL);
hash_map_free(btu_general_alarm_hash_map);
pthread_mutex_destroy(&btu_general_alarm_lock);
fixed_queue_free(btu_general_alarm_queue, NULL);
hash_map_free(btu_oneshot_alarm_hash_map);
pthread_mutex_destroy(&btu_oneshot_alarm_lock);
fixed_queue_free(btu_oneshot_alarm_queue, NULL);
hash_map_free(btu_l2cap_alarm_hash_map);
pthread_mutex_destroy(&btu_l2cap_alarm_lock);
fixed_queue_free(btu_l2cap_alarm_queue, NULL);
//thread_free(bt_workqueue_thread);
vTaskDelete(xBtuTaskHandle);
vQueueDelete(xBtuQueue);
btu_bta_msg_queue = NULL;
btu_general_alarm_hash_map = NULL;
btu_general_alarm_queue = NULL;
btu_oneshot_alarm_hash_map = NULL;
btu_oneshot_alarm_queue = NULL;
btu_l2cap_alarm_hash_map = NULL;
btu_l2cap_alarm_queue = NULL;
// bt_workqueue_thread = NULL;
xBtuTaskHandle = NULL;
xBtuQueue = 0;
}
thread_t *thread_new_sized(const char *name, size_t work_queue_capacity) {
assert(name != NULL);
assert(work_queue_capacity != 0);
thread_t *ret = osi_calloc(sizeof(thread_t));
if (!ret)
goto error;
ret->reactor = reactor_new();
if (!ret->reactor)
goto error;
ret->work_queue = fixed_queue_new(work_queue_capacity);
if (!ret->work_queue)
goto error;
// Start is on the stack, but we use a semaphore, so it's safe
struct start_arg start;
start.start_sem = semaphore_new(0);
if (!start.start_sem)
goto error;
strncpy(ret->name, name, THREAD_NAME_MAX);
start.thread = ret;
start.error = 0;
pthread_create(&ret->pthread, NULL, run_thread, &start);
semaphore_wait(start.start_sem);
semaphore_free(start.start_sem);
if (start.error)
goto error;
return ret;
error:;
if (ret) {
fixed_queue_free(ret->work_queue, osi_free);
reactor_free(ret->reactor);
}
osi_free(ret);
return NULL;
}
thread_t *thread_new(const char *name) {
assert(name != NULL);
// Start is on the stack, but we use a semaphore, so it's safe
thread_t *ret = calloc(1, sizeof(thread_t));
if (!ret)
goto error;
ret->reactor = reactor_new();
if (!ret->reactor)
goto error;
ret->work_queue = fixed_queue_new(WORK_QUEUE_CAPACITY);
if (!ret->work_queue)
goto error;
struct start_arg start;
start.start_sem = semaphore_new(0);
if (!start.start_sem)
goto error;
strncpy(ret->name, name, THREAD_NAME_MAX);
start.thread = ret;
start.error = 0;
pthread_create(&ret->pthread, NULL, run_thread, &start);
semaphore_wait(start.start_sem);
semaphore_free(start.start_sem);
if (start.error)
goto error;
return ret;
error:;
if (ret) {
fixed_queue_free(ret->work_queue, free);
reactor_free(ret->reactor);
}
free(ret);
return NULL;
}
void eager_reader_free(eager_reader_t *reader) {
if (!reader)
return;
eager_reader_unregister(reader);
// Only unregister from the input if we actually did register
if (reader->inbound_read_object)
reactor_unregister(reader->inbound_read_object);
if (reader->bytes_available_fd != INVALID_FD)
close(reader->bytes_available_fd);
// Free the current buffer, because it's not in the queue
// and won't be freed below
if (reader->current_buffer)
reader->allocator->free(reader->current_buffer);
fixed_queue_free(reader->buffers, reader->allocator->free);
thread_free(reader->inbound_read_thread);
osi_free(reader);
}
/******************************************************************************
**
** Function bte_main_shutdown
**
** Description BTE MAIN API - Shutdown code for BTE chip/stack
**
** Returns None
**
******************************************************************************/
void bte_main_shutdown(void)
{
//data_dispatcher_register_default(hci_layer_get_interface()->event_dispatcher, NULL);
hci->set_data_queue(NULL);
fixed_queue_unregister_dequeue(btu_hci_msg_queue);
fixed_queue_free(btu_hci_msg_queue, NULL);
btu_hci_msg_queue = NULL;
/*
module_clean_up(get_module(STACK_CONFIG_MODULE));
module_clean_up(get_module(COUNTER_MODULE));
module_clean_up(get_module(GKI_MODULE));
*/
#if (BLE_INCLUDED == TRUE)
BTA_VendorCleanup();
#endif
bte_main_disable();
gki_clean_up();
}
/*******************************************************************************
**
** Function port_release_port
**
** Description Release port infor control block.
**
** Returns Pointer to the PORT or NULL if not found
**
*******************************************************************************/
void port_release_port (tPORT *p_port)
{
BT_HDR *p_buf;
UINT32 mask;
tPORT_CALLBACK *p_port_cb;
tPORT_STATE user_port_pars;
osi_mutex_global_lock();
RFCOMM_TRACE_DEBUG("port_release_port, p_port:%p", p_port);
while ((p_buf = (BT_HDR *)fixed_queue_try_dequeue(p_port->rx.queue)) != NULL) {
osi_free (p_buf);
}
p_port->rx.queue_size = 0;
while ((p_buf = (BT_HDR *)fixed_queue_try_dequeue(p_port->tx.queue)) != NULL) {
osi_free (p_buf);
}
p_port->tx.queue_size = 0;
osi_mutex_global_unlock();
p_port->state = PORT_STATE_CLOSED;
if (p_port->rfc.state == RFC_STATE_CLOSED) {
RFCOMM_TRACE_DEBUG ("rfc_port_closed DONE");
if (p_port->rfc.p_mcb) {
p_port->rfc.p_mcb->port_inx[p_port->dlci] = 0;
/* If there are no more ports opened on this MCB release it */
rfc_check_mcb_active (p_port->rfc.p_mcb);
}
rfc_port_timer_stop (p_port);
fixed_queue_free(p_port->tx.queue, NULL);
p_port->tx.queue = NULL;
fixed_queue_free(p_port->rx.queue, NULL);
p_port->rx.queue = NULL;
RFCOMM_TRACE_DEBUG ("port_release_port:p_port->keep_port_handle:%d", p_port->keep_port_handle);
if ( p_port->keep_port_handle ) {
RFCOMM_TRACE_DEBUG ("port_release_port:Initialize handle:%d", p_port->inx);
/* save event mask and callback */
mask = p_port->ev_mask;
p_port_cb = p_port->p_callback;
user_port_pars = p_port->user_port_pars;
port_set_defaults(p_port);
/* restore */
p_port->ev_mask = mask;
p_port->p_callback = p_port_cb;
p_port->user_port_pars = user_port_pars;
p_port->mtu = p_port->keep_mtu;
p_port->state = PORT_STATE_OPENING;
p_port->rfc.p_mcb = NULL;
if (p_port->is_server) {
p_port->dlci &= 0xfe;
}
p_port->local_ctrl.modem_signal = p_port->default_signal_state;
memcpy (p_port->bd_addr, BT_BD_ANY, BD_ADDR_LEN);
} else {
RFCOMM_TRACE_DEBUG ("port_release_port:Clean-up handle:%d", p_port->inx);
memset (p_port, 0, sizeof (tPORT));
}
}
}
