tBTA_SYS_CB bta_sys_cb;
#endif
-fixed_queue_t *btu_bta_alarm_queue;
static hash_map_t *bta_alarm_hash_map;
static const size_t BTA_ALARM_HASH_MAP_SIZE = 17;
static pthread_mutex_t bta_alarm_lock;
UINT8 appl_trace_level = BT_TRACE_LEVEL_WARNING; //APPL_INITIAL_TRACE_LEVEL;
UINT8 btif_trace_level = BT_TRACE_LEVEL_WARNING;
-// Communication queue between btu_task and bta.
-extern fixed_queue_t *btu_bta_msg_queue;
void btu_bta_alarm_ready(fixed_queue_t *queue);
static const tBTA_SYS_REG bta_sys_hw_reg = {
bta_alarm_hash_map = hash_map_new(BTA_ALARM_HASH_MAP_SIZE,
hash_function_pointer, NULL, (data_free_fn)osi_alarm_free, NULL);
- btu_bta_alarm_queue = fixed_queue_new(SIZE_MAX);
-
- fixed_queue_register_dequeue(btu_bta_alarm_queue,
- btu_bta_alarm_ready);
appl_trace_level = APPL_INITIAL_TRACE_LEVEL;
void bta_sys_free(void)
{
- fixed_queue_free(btu_bta_alarm_queue, NULL);
hash_map_free(bta_alarm_hash_map);
pthread_mutex_destroy(&bta_alarm_lock);
}
// there is a procedure in progress that can schedule a task via this
// message queue. This causes |btu_bta_msg_queue| to get cleaned up before
// it gets used here; hence we check for NULL before using it.
- if (btu_bta_msg_queue) {
- fixed_queue_enqueue(btu_bta_msg_queue, p_msg);
- //ke_event_set(KE_EVENT_BTU_TASK_THREAD);
- btu_task_post(SIG_BTU_WORK, TASK_POST_BLOCKING);
+ if (btu_task_post(SIG_BTU_BTA_MSG, p_msg, TASK_POST_BLOCKING) != TASK_POST_SUCCESS) {
+ GKI_freebuf(p_msg);
}
}
assert(data != NULL);
TIMER_LIST_ENT *p_tle = (TIMER_LIST_ENT *)data;
- fixed_queue_enqueue(btu_bta_alarm_queue, p_tle);
-
- btu_task_post(SIG_BTU_WORK, TASK_POST_BLOCKING);
+ btu_task_post(SIG_BTU_BTA_ALARM, p_tle, TASK_POST_BLOCKING);
}
void bta_sys_start_timer(TIMER_LIST_ENT *p_tle, UINT16 type, INT32 timeout_ms)
for (;;) {
if (pdTRUE == xQueueReceive(xHciH4Queue, &e, (portTickType)portMAX_DELAY)) {
- if (e.sig == 0xff) {
+ if (e.sig == SIG_HCI_HAL_RECV_PACKET) {
fixed_queue_process(hci_hal_env.rx_q);
}
}
}
}
-void hci_hal_h4_task_post(task_post_t timeout)
+task_post_status_t hci_hal_h4_task_post(task_post_t timeout)
{
BtTaskEvt_t evt;
- evt.sig = 0xff;
+ evt.sig = SIG_HCI_HAL_RECV_PACKET;
evt.par = 0;
if (xQueueSend(xHciH4Queue, &evt, timeout) != pdTRUE) {
LOG_ERROR("xHciH4Queue failed\n");
+ return TASK_POST_SUCCESS;
}
+
+ return TASK_POST_FAIL;
}
static void hci_hal_h4_hdl_rx_packet(BT_HDR *packet)
fixed_queue_t *command_queue;
fixed_queue_t *packet_queue;
- // The hand-off point for data going to a higher layer, set by the higher layer
- fixed_queue_t *upwards_data_queue;
-
command_waiting_response_t cmd_waiting_q;
/*
}
-void hci_host_task_post(task_post_t timeout)
+task_post_status_t hci_host_task_post(task_post_t timeout)
{
BtTaskEvt_t evt;
if (hci_host_startup_flag == false) {
- return;
+ return TASK_POST_FAIL;
}
- evt.sig = 0xff;
+ evt.sig = SIG_HCI_HOST_SEND_AVAILABLE;
evt.par = 0;
if (xQueueSend(xHciHostQueue, &evt, timeout) != pdTRUE) {
LOG_ERROR("xHciHostQueue failed\n");
+ return TASK_POST_FAIL;
}
+
+ return TASK_POST_SUCCESS;
}
static int hci_layer_init_env(void)
for (;;) {
if (pdTRUE == xQueueReceive(xHciHostQueue, &e, (portTickType)portMAX_DELAY)) {
- if (e.sig == 0xff) {
+ if (e.sig == SIG_HCI_HOST_SEND_AVAILABLE) {
if (esp_vhci_host_check_send_available()) {
/*Now Target only allowed one packet per TX*/
BT_HDR *pkt = packet_fragmenter->fragment_current_packet();
}
}
-static void set_data_queue(fixed_queue_t *queue)
-{
- hci_host_env.upwards_data_queue = queue;
-}
-
static void transmit_command(
BT_HDR *command,
command_complete_cb complete_callback,
} else {
fixed_queue_enqueue(hci_host_env.packet_queue, data);
}
- //ke_event_set(KE_EVENT_HCI_HOST_THREAD);
+
hci_host_task_post(TASK_POST_BLOCKING);
}
!fixed_queue_is_empty(hci_host_env.command_queue)) {
hci_host_task_post(TASK_POST_BLOCKING);
}
- //ke_event_set(KE_EVENT_HCI_HOST_THREAD);
if (wait_entry) {
// If it has a callback, it's responsible for freeing the packet
static void dispatch_reassembled(BT_HDR *packet)
{
// Events should already have been dispatched before this point
-
- if (hci_host_env.upwards_data_queue) {
- fixed_queue_enqueue(hci_host_env.upwards_data_queue, packet);
- btu_task_post(SIG_BTU_WORK, TASK_POST_BLOCKING);
- //Tell Up-layer received packet.
- } else {
- LOG_DEBUG("%s had no queue to place upwards data packet in. Dropping it on the floor.", __func__);
+ //Tell Up-layer received packet.
+ if (btu_task_post(SIG_BTU_HCI_MSG, packet, TASK_POST_BLOCKING) != TASK_POST_SUCCESS) {
buffer_allocator->free(packet);
}
}
static void init_layer_interface()
{
if (!interface_created) {
- interface.set_data_queue = set_data_queue;
interface.transmit_command = transmit_command;
interface.transmit_command_futured = transmit_command_futured;
interface.transmit_downward = transmit_downward;
// Do the postload sequence (call after the rest of the BT stack initializes).
void (*do_postload)(void);
- // Set the queue to receive ACL data in
- void (*set_data_queue)(fixed_queue_t *queue);
-
// Send a command through the HCI layer
void (*transmit_command)(
BT_HDR *command,
#include "bt_trace.h"
#include "osi.h"
#include "alarm.h"
-#include "fixed_queue.h"
#include "hash_map.h"
#include "hash_functions.h"
#include "controller.h"
#include "hci_layer.h"
#include "bta_api.h"
-//#include "bluedroid_test.h"
-/*
-#define LOG_TAG "bt_main"
-
-#include <cutils/properties.h>
-#include <fcntl.h>
-#include <hardware/bluetooth.h>
-#include <pthread.h>
-#include <signal.h>
-#include <stdlib.h>
-#include <time.h>
-
-#include "osi/include/alarm.h"
-#include "bta_api.h"
-#include "bt_hci_bdroid.h"
-#include "bte.h"
-#include "btif_common.h"
-#include "btu.h"
-#include "btsnoop.h"
-#include "bt_utils.h"
-#include "btcore/include/counter.h"
-#include "btcore/include/module.h"
-#include "osi/include/fixed_queue.h"
-#include "osi/include/future.h"
-#include "gki.h"
-#include "osi/include/hash_functions.h"
-#include "osi/include/hash_map.h"
-#include "hci_layer.h"
-#include "osi/include/osi.h"
-#include "osi/include/log.h"
-#include "stack_config.h"
-#include "osi/include/thread.h"
-*/
/*******************************************************************************
** Constants & Macros
*******************************************************************************/
-/* Run-time configuration file for BLE*/
-/*
-#ifndef BTE_BLE_STACK_CONF_FILE
-#define BTE_BLE_STACK_CONF_FILE "/etc/bluetooth/ble_stack.conf"
-#endif
-*/
/******************************************************************************
** Variables
******************************************************************************/
/*******************************************************************************
** Externs
*******************************************************************************/
-//extern void bte_load_ble_conf(const char *p_path);
-fixed_queue_t *btu_hci_msg_queue;
bluedroid_init_done_cb_t bluedroid_init_done_cb;
return -2;
}
- btu_hci_msg_queue = fixed_queue_new(SIZE_MAX);
- if (btu_hci_msg_queue == NULL) {
- LOG_ERROR("%s unable to allocate hci message queue.\n", __func__);
- return -3;
- }
-
bluedroid_init_done_cb = cb;
- //Caution: No event dispatcher defined now in hci layer
- //data_dispatcher_register_default(hci->event_dispatcher, btu_hci_msg_queue);
- hci->set_data_queue(btu_hci_msg_queue);
-
//Enbale HCI
bte_main_enable();
******************************************************************************/
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
typedef bt_status_t (* BtTaskCb_t)(void *arg);
-enum {
- SIG_PRF_START_UP = 0xfc,
- SIG_PRF_WORK = 0xfd,
- SIG_BTU_START_UP = 0xfe,
- SIG_BTU_WORK = 0xff,
-};
+typedef enum {
+ SIG_HCI_HAL_RECV_PACKET = 0,
+ SIG_HCI_HAL_NUM,
+} SIG_HCI_HAL_t;
+
+
+typedef enum {
+ SIG_HCI_HOST_SEND_AVAILABLE = 0,
+ SIG_HCI_HOST_NUM,
+} SIG_HCI_HOST_t;
+
+typedef enum {
+ SIG_BTU_START_UP = 0,
+ SIG_BTU_HCI_MSG,
+ SIG_BTU_BTA_MSG,
+ SIG_BTU_BTA_ALARM,
+ SIG_BTU_GENERAL_ALARM,
+ SIG_BTU_ONESHOT_ALARM,
+ SIG_BTU_L2CAP_ALARM,
+ SIG_BTU_NUM,
+} SIG_BTU_t;
#define HCI_HOST_TASK_STACK_SIZE (2048 + BT_TASK_EXTRA_STACK_SIZE)
#define HCI_HOST_TASK_PRIO (configMAX_PRIORITIES - 3)
#define TASK_POST_BLOCKING (portMAX_DELAY)
typedef uint32_t task_post_t; /* Timeout of task post return, unit TICK */
-void btu_task_post(uint32_t sig, task_post_t timeout);
-void hci_host_task_post(task_post_t timeout);
-void hci_hal_h4_task_post(task_post_t timeout);
+typedef enum {
+ TASK_POST_SUCCESS = 0,
+ TASK_POST_FAIL,
+} task_post_status_t;
+task_post_status_t btu_task_post(uint32_t sig, void *param, task_post_t timeout);
+task_post_status_t hci_host_task_post(task_post_t timeout);
+task_post_status_t hci_hal_h4_task_post(task_post_t timeout);
#endif /* __THREAD_H__ */
// TODO(zachoverflow): remove this horrible hack
#include "btu.h"
-extern fixed_queue_t *btu_hci_msg_queue;
extern void btm_process_cancel_complete(UINT8 status, UINT8 mode);
extern void btm_ble_test_command_complete(UINT8 *p);
event->event = BTU_POST_TO_TASK_NO_GOOD_HORRIBLE_HACK;
- fixed_queue_enqueue(btu_hci_msg_queue, event);
- // ke_event_set(KE_EVENT_BTU_TASK_THREAD);
- btu_task_post(SIG_BTU_WORK, TASK_POST_BLOCKING);
+ btu_task_post(SIG_BTU_HCI_MSG, event, TASK_POST_BLOCKING);
}
event->event = BTU_POST_TO_TASK_NO_GOOD_HORRIBLE_HACK;
- fixed_queue_enqueue(btu_hci_msg_queue, event);
- //ke_event_set(KE_EVENT_BTU_TASK_THREAD);
- btu_task_post(SIG_BTU_WORK, TASK_POST_BLOCKING);
+ btu_task_post(SIG_BTU_HCI_MSG, event, TASK_POST_BLOCKING);
}
/*******************************************************************************
#include "bt_trace.h"
#include "controller.h"
#include "alarm.h"
-#include "fixed_queue.h"
#include "hash_map.h"
#include "hash_functions.h"
#include "thread.h"
#endif
#endif
-// extern fixed_queue_t *btif_msg_queue;
-
-// Communication queue from bta thread to bt_workqueue.
-fixed_queue_t *btu_bta_msg_queue;
-
-// Communication queue from hci thread to bt_workqueue.
-extern fixed_queue_t *btu_hci_msg_queue;
-
-// General timer queue.
-fixed_queue_t *btu_general_alarm_queue;
hash_map_t *btu_general_alarm_hash_map;
pthread_mutex_t btu_general_alarm_lock;
static const size_t BTU_GENERAL_ALARM_HASH_MAP_SIZE = 34;
-// Oneshot timer queue.
-fixed_queue_t *btu_oneshot_alarm_queue;
hash_map_t *btu_oneshot_alarm_hash_map;
pthread_mutex_t btu_oneshot_alarm_lock;
static const size_t BTU_ONESHOT_ALARM_HASH_MAP_SIZE = 34;
-// l2cap timer queue.
-fixed_queue_t *btu_l2cap_alarm_queue;
hash_map_t *btu_l2cap_alarm_hash_map;
pthread_mutex_t btu_l2cap_alarm_lock;
static const size_t BTU_L2CAP_ALARM_HASH_MAP_SIZE = 34;
memset (&btu_cb, 0, sizeof (tBTU_CB));
btu_cb.trace_level = HCI_INITIAL_TRACE_LEVEL;
- btu_bta_msg_queue = fixed_queue_new(SIZE_MAX);
- if (btu_bta_msg_queue == NULL) {
- goto error_exit;
- }
-
btu_general_alarm_hash_map = hash_map_new(BTU_GENERAL_ALARM_HASH_MAP_SIZE,
hash_function_pointer, NULL, (data_free_fn)osi_alarm_free, NULL);
if (btu_general_alarm_hash_map == NULL) {
pthread_mutex_init(&btu_general_alarm_lock, NULL);
- btu_general_alarm_queue = fixed_queue_new(SIZE_MAX);
- if (btu_general_alarm_queue == NULL) {
- goto error_exit;
- }
-
btu_oneshot_alarm_hash_map = hash_map_new(BTU_ONESHOT_ALARM_HASH_MAP_SIZE,
hash_function_pointer, NULL, (data_free_fn)osi_alarm_free, NULL);
if (btu_oneshot_alarm_hash_map == NULL) {
pthread_mutex_init(&btu_oneshot_alarm_lock, NULL);
- btu_oneshot_alarm_queue = fixed_queue_new(SIZE_MAX);
- if (btu_oneshot_alarm_queue == NULL) {
- goto error_exit;
- }
-
btu_l2cap_alarm_hash_map = hash_map_new(BTU_L2CAP_ALARM_HASH_MAP_SIZE,
hash_function_pointer, NULL, (data_free_fn)osi_alarm_free, NULL);
if (btu_l2cap_alarm_hash_map == NULL) {
pthread_mutex_init(&btu_l2cap_alarm_lock, NULL);
- btu_l2cap_alarm_queue = fixed_queue_new(SIZE_MAX);
- if (btu_l2cap_alarm_queue == NULL) {
- goto error_exit;
- }
-
xBtuQueue = xQueueCreate(BTU_QUEUE_NUM, sizeof(BtTaskEvt_t));
xTaskCreatePinnedToCore(btu_task_thread_handler, BTU_TASK_NAME, BTU_TASK_STACK_SIZE, NULL, BTU_TASK_PRIO, &xBtuTaskHandle, 0);
- btu_task_post(SIG_BTU_START_UP, TASK_POST_BLOCKING);
- /*
- // Continue startup on bt workqueue thread.
- thread_post(bt_workqueue_thread, btu_task_start_up, NULL);
- */
+
+ btu_task_post(SIG_BTU_START_UP, NULL, TASK_POST_BLOCKING);
+
return;
error_exit:;
{
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;
}
return 0;
#endif
}
-/*******************************************************************************
-**
-** Function btu_uipc_rx_cback
-**
-** Description
-**
-**
-** Returns void
-**
-*******************************************************************************/
-/*
-void btu_uipc_rx_cback(BT_HDR *p_msg) {
- assert(p_msg != NULL);
- BT_TRACE(TRACE_LAYER_BTM, TRACE_TYPE_DEBUG, "btu_uipc_rx_cback event 0x%x,"
- " len %d, offset %d", p_msg->event, p_msg->len, p_msg->offset);
- fixed_queue_enqueue(btu_hci_msg_queue, p_msg);
-}
-*/
#include "btm_api.h"
#include "btm_int.h"
#include "btu.h"
-#include "fixed_queue.h"
#include "gki.h"
#include "hash_map.h"
#include "hcimsgs.h"
tBTU_CB btu_cb;
#endif
-// Communication queue between btu_task and bta.
-extern fixed_queue_t *btu_bta_msg_queue;
-
-// alarm queue between btu_task and bta
-extern fixed_queue_t *btu_bta_alarm_queue;
-
-// Communication queue between btu_task and hci.
-extern fixed_queue_t *btu_hci_msg_queue;
-
-// General timer queue.
-extern fixed_queue_t *btu_general_alarm_queue;
extern hash_map_t *btu_general_alarm_hash_map;
extern pthread_mutex_t btu_general_alarm_lock;
// Oneshot timer queue.
-extern fixed_queue_t *btu_oneshot_alarm_queue;
extern hash_map_t *btu_oneshot_alarm_hash_map;
extern pthread_mutex_t btu_oneshot_alarm_lock;
// l2cap timer queue.
-extern fixed_queue_t *btu_l2cap_alarm_queue;
extern hash_map_t *btu_l2cap_alarm_hash_map;
extern pthread_mutex_t btu_l2cap_alarm_lock;
-extern fixed_queue_t *event_queue;
-//extern fixed_queue_t *btif_msg_queue;
-
-//extern thread_t *bt_workqueue_thread;
extern xTaskHandle xBtuTaskHandle;
extern xQueueHandle xBtuQueue;
extern bluedroid_init_done_cb_t bluedroid_init_done_cb;
static void btu_bta_alarm_process(TIMER_LIST_ENT *p_tle);
#endif
-void btu_hci_msg_ready(fixed_queue_t *queue)
-{
- BT_HDR *p_msg;
-
- while (!fixed_queue_is_empty(queue)) {
- p_msg = (BT_HDR *)fixed_queue_dequeue(queue);
- btu_hci_msg_process(p_msg);
- }
-}
-
-void btu_general_alarm_ready(fixed_queue_t *queue)
-{
- TIMER_LIST_ENT *p_tle;
-
- while (!fixed_queue_is_empty(queue)) {
- p_tle = (TIMER_LIST_ENT *)fixed_queue_dequeue(queue);
- btu_general_alarm_process(p_tle);
- }
-}
-
-void btu_oneshot_alarm_ready(fixed_queue_t *queue)
-{
- TIMER_LIST_ENT *p_tle;
-
- while (!fixed_queue_is_empty(queue)) {
- 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
- LOG_ERROR("Received unexpected oneshot timer event:0x%x\n",
- p_tle->event);
- break;
- }
- }
-}
-
-void btu_l2cap_alarm_ready(fixed_queue_t *queue)
-{
- TIMER_LIST_ENT *p_tle;
-
- while (!fixed_queue_is_empty(queue)) {
- p_tle = (TIMER_LIST_ENT *)fixed_queue_dequeue(queue);
- btu_l2cap_alarm_process(p_tle);
- }
-}
-
-#if (defined(BTA_INCLUDED) && BTA_INCLUDED == TRUE)
-void btu_bta_msg_ready(fixed_queue_t *queue)
-{
- BT_HDR *p_msg;
-
- while (!fixed_queue_is_empty(queue)) {
- p_msg = (BT_HDR *)fixed_queue_dequeue(queue);
- bta_sys_event(p_msg);
- }
-}
-
-void btu_bta_alarm_ready(fixed_queue_t *queue)
-{
- TIMER_LIST_ENT *p_tle;
-
- while (!fixed_queue_is_empty(queue)) {
- p_tle = (TIMER_LIST_ENT *)fixed_queue_dequeue(queue);
- btu_bta_alarm_process(p_tle);
- }
-}
-#endif
-
static void btu_hci_msg_process(BT_HDR *p_msg)
{
/* Determine the input message type. */
for (;;) {
if (pdTRUE == xQueueReceive(xBtuQueue, &e, (portTickType)portMAX_DELAY)) {
- if (e.sig == SIG_BTU_WORK) {
- fixed_queue_process(btu_hci_msg_queue);
-#if (defined(BTA_INCLUDED) && BTA_INCLUDED == TRUE)
- fixed_queue_process(btu_bta_msg_queue);
- fixed_queue_process(btu_bta_alarm_queue);
-#endif
- fixed_queue_process(btu_general_alarm_queue);
- fixed_queue_process(btu_oneshot_alarm_queue);
- fixed_queue_process(btu_l2cap_alarm_queue);
- } else if (e.sig == SIG_BTU_START_UP) {
+ switch (e.sig) {
+ case SIG_BTU_START_UP:
btu_task_start_up();
+ break;
+ case SIG_BTU_HCI_MSG:
+ btu_hci_msg_process((BT_HDR *)e.par);
+ break;
+#if (defined(BTA_INCLUDED) && BTA_INCLUDED == TRUE)
+ case SIG_BTU_BTA_MSG:
+ bta_sys_event((BT_HDR *)e.par);
+ break;
+ case SIG_BTU_BTA_ALARM:
+ btu_bta_alarm_process((TIMER_LIST_ENT *)e.par);
+ break;
+#endif
+ case SIG_BTU_GENERAL_ALARM:
+ btu_general_alarm_process((TIMER_LIST_ENT *)e.par);
+ break;
+ case SIG_BTU_ONESHOT_ALARM: {
+ TIMER_LIST_ENT *p_tle = (TIMER_LIST_ENT *)e.par;
+ 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
+ LOG_ERROR("Received unexpected oneshot timer event:0x%x\n", p_tle->event);
+ break;
+ }
+ break;
+ }
+ case SIG_BTU_L2CAP_ALARM:
+ btu_l2cap_alarm_process((TIMER_LIST_ENT *)e.par);
+ break;
+ default:
+ break;
}
}
}
}
-void btu_task_post(uint32_t sig, task_post_t timeout)
+task_post_status_t btu_task_post(uint32_t sig, void *param, task_post_t timeout)
{
BtTaskEvt_t evt;
evt.sig = sig;
- evt.par = 0;
+ evt.par = param;
if (xQueueSend(xBtuQueue, &evt, timeout) != pdTRUE) {
LOG_ERROR("xBtuQueue failed\n");
+ return TASK_POST_FAIL;
}
+
+ return TASK_POST_SUCCESS;
}
void btu_task_start_up(void)
{
-
-#if (defined(BTA_INCLUDED) && BTA_INCLUDED == TRUE)
- fixed_queue_register_dequeue(btu_bta_msg_queue, btu_bta_msg_ready);
-#endif
-
- fixed_queue_register_dequeue(btu_hci_msg_queue, btu_hci_msg_ready);
- fixed_queue_register_dequeue(btu_general_alarm_queue, btu_general_alarm_ready);
- fixed_queue_register_dequeue(btu_oneshot_alarm_queue, btu_oneshot_alarm_ready);
- fixed_queue_register_dequeue(btu_l2cap_alarm_queue, btu_l2cap_alarm_ready);
-
/* Initialize the mandatory core stack control blocks
(BTU, BTM, L2CAP, and SDP)
*/
void btu_task_shut_down(void)
{
- fixed_queue_unregister_dequeue(btu_general_alarm_queue);
- fixed_queue_unregister_dequeue(btu_oneshot_alarm_queue);
- fixed_queue_unregister_dequeue(btu_l2cap_alarm_queue);
-
#if (defined(BTA_INCLUDED) && BTA_INCLUDED == TRUE)
- fixed_queue_unregister_dequeue(btu_bta_msg_queue);
bta_sys_free();
#endif
assert(data != NULL);
TIMER_LIST_ENT *p_tle = (TIMER_LIST_ENT *)data;
- fixed_queue_enqueue(btu_general_alarm_queue, p_tle);
- //ke_event_set(KE_EVENT_BTU_TASK_THREAD);
- btu_task_post(SIG_BTU_WORK, TASK_POST_BLOCKING);
+ btu_task_post(SIG_BTU_GENERAL_ALARM, p_tle, TASK_POST_BLOCKING);
}
void btu_start_timer(TIMER_LIST_ENT *p_tle, UINT16 type, UINT32 timeout_sec)
assert(data != NULL);
TIMER_LIST_ENT *p_tle = (TIMER_LIST_ENT *)data;
- fixed_queue_enqueue(btu_l2cap_alarm_queue, p_tle);
- //ke_event_set(KE_EVENT_BTU_TASK_THREAD);
- btu_task_post(SIG_BTU_WORK, TASK_POST_BLOCKING);
+ btu_task_post(SIG_BTU_L2CAP_ALARM, p_tle, TASK_POST_BLOCKING);
}
void btu_start_quick_timer(TIMER_LIST_ENT *p_tle, UINT16 type, UINT32 timeout_ticks)
btu_stop_timer_oneshot(p_tle);
- fixed_queue_enqueue(btu_oneshot_alarm_queue, p_tle);
- //ke_event_set(KE_EVENT_BTU_TASK_THREAD);
- btu_task_post(SIG_BTU_WORK, TASK_POST_BLOCKING);
+ btu_task_post(SIG_BTU_ONESHOT_ALARM, p_tle, TASK_POST_BLOCKING);
}
/*
projects / esp-idf / commitdiff