void btu_oneshot_alarm_ready(fixed_queue_t *queue, UNUSED_ATTR void *context) {
TIMER_LIST_ENT *p_tle = (TIMER_LIST_ENT *)fixed_queue_dequeue(queue);
btu_general_alarm_process(p_tle);
switch (p_tle->event) {
#if (defined(BLE_INCLUDED) && BLE_INCLUDED == TRUE)
case BTU_TTYPE_BLE_RANDOM_ADDR:
btm_ble_timeout(p_tle);
break;
#endif
case BTU_TTYPE_USER_FUNC:
{
tUSER_TIMEOUT_FUNC *p_uf = (tUSER_TIMEOUT_FUNC *)p_tle->param;
(*p_uf)(p_tle);
}
break;
default:
// FAIL
BTM_TRACE_WARNING("Received unexpected oneshot timer event:0x%x\n",
p_tle->event);
break;
}
}
static void event_packet_ready(fixed_queue_t *queue)
{
BT_HDR *packet = (BT_HDR *)fixed_queue_dequeue(queue);
// The queue may be the command queue or the packet queue, we don't care
packet_fragmenter->fragment_and_dispatch(packet);
}
static void work_queue_read_cb(void *context) {
assert(context != NULL);
fixed_queue_t *queue = (fixed_queue_t *)context;
work_item_t *item = fixed_queue_dequeue(queue);
item->func(item->context);
osi_free(item);
}
static void event_packet_ready(fixed_queue_t *queue, UNUSED_ATTR void *context) {
// The queue may be the command queue or the packet queue, we don't care
BT_HDR *packet = (BT_HDR *)fixed_queue_dequeue(queue);
low_power_manager->wake_assert();
packet_fragmenter->fragment_and_dispatch(packet);
low_power_manager->transmit_done();
}
static void if_tx_thread(void *args)
{
ifnet *i = args;
cbuf *buf;
ssize_t len;
t_current_set_name("IF Xmit");
#if IF_PRIO
thread_set_priority(i->tx_thread, THREAD_MAX_RT_PRIORITY - 2);
#endif
//if(i->fd < 0) return -1;
//printf("if %x tx thread inited", i);
for(;;) {
sem_acquire(i->tx_queue_sem);
//printf("if %x tx thread gogo\n", i);
for(;;) {
// pull a packet out of the queue
mutex_lock(&i->tx_queue_lock);
buf = fixed_queue_dequeue(&i->tx_queue);
mutex_unlock(&i->tx_queue_lock);
if(!buf)
break;
#if LOSE_TX_PACKETS
if(rand() % 100 < LOSE_TX_PERCENTAGE) {
cbuf_free_chain(buf);
continue;
}
#endif
// put the cbuf chain into a flat buffer
len = cbuf_get_len(buf);
cbuf_memcpy_from_chain(i->tx_buf, buf, 0, len);
cbuf_free_chain(buf);
#if 0||NET_CHATTY
dprintf("if_tx_thread: sending packet size %ld\n", (long)len);
#endif
//sys_write(i->fd, i->tx_buf, 0, len);
i->dev->dops.write(i->dev, i->tx_buf, len);
}
}
}
// SEE HEADER FOR THREAD SAFETY NOTE
size_t eager_reader_read(eager_reader_t *reader, uint8_t *buffer, size_t max_size, bool block) {
assert(reader != NULL);
assert(buffer != NULL);
// If the caller wants nonblocking behavior, poll to see if we have
// any bytes available before reading.
if (!block && !has_byte(reader))
return 0;
// Find out how many bytes we have available in our various buffers.
eventfd_t bytes_available;
if (eventfd_read(reader->bytes_available_fd, &bytes_available) == -1) {
LOG_ERROR(LOG_TAG, "%s unable to read semaphore for output data.", __func__);
return 0;
}
if (max_size > bytes_available)
max_size = bytes_available;
size_t bytes_consumed = 0;
while (bytes_consumed < max_size) {
if (!reader->current_buffer)
reader->current_buffer = fixed_queue_dequeue(reader->buffers);
size_t bytes_to_copy = reader->current_buffer->length - reader->current_buffer->offset;
if (bytes_to_copy > (max_size - bytes_consumed))
bytes_to_copy = max_size - bytes_consumed;
memcpy(&buffer[bytes_consumed], &reader->current_buffer->data[reader->current_buffer->offset], bytes_to_copy);
bytes_consumed += bytes_to_copy;
reader->current_buffer->offset += bytes_to_copy;
if (reader->current_buffer->offset >= reader->current_buffer->length) {
reader->allocator->free(reader->current_buffer);
reader->current_buffer = NULL;
}
}
bytes_available -= bytes_consumed;
if (eventfd_write(reader->bytes_available_fd, bytes_available) == -1) {
LOG_ERROR(LOG_TAG, "%s unable to write back bytes available for output data.", __func__);
}
return bytes_consumed;
}
static void event_command_ready(fixed_queue_t *queue, UNUSED_ATTR void *context) {
if (command_credits > 0) {
waiting_command_t *wait_entry = fixed_queue_dequeue(queue);
command_credits--;
// Move it to the list of commands awaiting response
pthread_mutex_lock(&commands_pending_response_lock);
list_append(commands_pending_response, wait_entry);
pthread_mutex_unlock(&commands_pending_response_lock);
// Send it off
low_power_manager->wake_assert();
packet_fragmenter->fragment_and_dispatch(wait_entry->command);
low_power_manager->transmit_done();
non_repeating_timer_restart_if(command_response_timer, !list_is_empty(commands_pending_response));
}
}
// Command/packet transmitting functions
static void event_command_ready(fixed_queue_t *queue)
{
waiting_command_t *wait_entry = NULL;
command_waiting_response_t *cmd_wait_q = &hci_host_env.cmd_waiting_q;
wait_entry = fixed_queue_dequeue(queue);
hci_host_env.command_credits--;
// Move it to the list of commands awaiting response
pthread_mutex_lock(&cmd_wait_q->commands_pending_response_lock);
list_append(cmd_wait_q->commands_pending_response, wait_entry);
pthread_mutex_unlock(&cmd_wait_q->commands_pending_response_lock);
// Send it off
packet_fragmenter->fragment_and_dispatch(wait_entry->command);
wait_entry->sent_time = osi_alarm_now();
restart_comamnd_waiting_response_timer(cmd_wait_q, true);
}
static int if_tx_thread(void *args)
{
ifnet *i = args;
cbuf *buf;
ssize_t len;
if(i->fd < 0)
return -1;
for(;;) {
sem_acquire(i->tx_queue_sem, 1);
for(;;) {
// pull a packet out of the queue
mutex_lock(&i->tx_queue_lock);
buf = fixed_queue_dequeue(&i->tx_queue);
mutex_unlock(&i->tx_queue_lock);
if(!buf)
break;
#if LOSE_TX_PACKETS
if(rand() % 100 < LOSE_TX_PERCENTAGE) {
cbuf_free_chain(buf);
continue;
}
#endif
// put the cbuf chain into a flat buffer
len = cbuf_get_len(buf);
cbuf_memcpy_from_chain(i->tx_buf, buf, 0, len);
cbuf_free_chain(buf);
#if NET_CHATTY
dprintf("if_tx_thread: sending packet size %Ld\n", (long long)len);
#endif
sys_write(i->fd, i->tx_buf, 0, len);
}
}
}
// Command/packet transmitting functions
static void event_command_ready(fixed_queue_t *queue)
{
waiting_command_t *wait_entry = NULL;
command_waiting_response_t *cmd_wait_q = &hci_host_env.cmd_waiting_q;
wait_entry = fixed_queue_dequeue(queue);
if(wait_entry->opcode == HCI_HOST_NUM_PACKETS_DONE){
packet_fragmenter->fragment_and_dispatch(wait_entry->command);
osi_free(wait_entry->command);
osi_free(wait_entry);
return;
}
hci_host_env.command_credits--;
// Move it to the list of commands awaiting response
osi_mutex_lock(&cmd_wait_q->commands_pending_response_lock, OSI_MUTEX_MAX_TIMEOUT);
list_append(cmd_wait_q->commands_pending_response, wait_entry);
osi_mutex_unlock(&cmd_wait_q->commands_pending_response_lock);
// Send it off
packet_fragmenter->fragment_and_dispatch(wait_entry->command);
restart_command_waiting_response_timer(cmd_wait_q);
}
void btu_bta_alarm_ready(fixed_queue_t *queue, UNUSED_ATTR void *context) {
TIMER_LIST_ENT *p_tle = (TIMER_LIST_ENT *)fixed_queue_dequeue(queue);
btu_bta_alarm_process(p_tle);
}
void btu_bta_msg_ready(fixed_queue_t *queue, UNUSED_ATTR void *context) {
BT_HDR *p_msg = (BT_HDR *)fixed_queue_dequeue(queue);
bta_sys_event(p_msg);
}
void btu_hci_msg_ready(fixed_queue_t *queue, UNUSED_ATTR void *context) {
BT_HDR *p_msg = (BT_HDR *)fixed_queue_dequeue(queue);
btu_hci_msg_process(p_msg);
}
