stack/btu/btu_task.c - platform/system/bt - Gitiles

 /******************************************************************************
  *
  *  Copyright (C) 1999-2012 Broadcom Corporation
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
  *  You may obtain a copy of the License at:
  *
  *  http://www.apache.org/licenses/LICENSE-2.0
  *
  *  Unless required by applicable law or agreed to in writing, software
  *  distributed under the License is distributed on an "AS IS" BASIS,
  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  *
  ******************************************************************************/

 #define LOG_TAG "bt_btu_task"

 #include <assert.h>
 #include <pthread.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>

 #include "osi/include/alarm.h"
 #include "bt_target.h"
 #include "bt_trace.h"
 #include "bt_types.h"
 #include "bt_utils.h"
 #include "btif_common.h"
 #include "btm_api.h"
 #include "btm_int.h"
 #include "btu.h"
 #include "osi/include/fixed_queue.h"
 #include "osi/include/future.h"
 #include "gki.h"
 #include "osi/include/hash_map.h"
 #include "hcimsgs.h"
 #include "l2c_int.h"
 #include "btcore/include/module.h"
 #include "osi/include/osi.h"
 #include "osi/include/log.h"
 #include "sdpint.h"
 #include "osi/include/thread.h"

 #include "port_api.h"
 #include "port_ext.h"

 #include "gap_int.h"

 #if (defined(BNEP_INCLUDED) && BNEP_INCLUDED == TRUE)
 #include "bnep_int.h"
 #endif

 #if (defined(PAN_INCLUDED) && PAN_INCLUDED == TRUE)
 #include "pan_int.h"
 #endif

 #if (defined(HID_HOST_INCLUDED) && HID_HOST_INCLUDED == TRUE )
 #include "hidh_int.h"
 #endif

 #if (defined(AVDT_INCLUDED) && AVDT_INCLUDED == TRUE)
 #include "avdt_int.h"
 #else
 extern void avdt_rcv_sync_info (BT_HDR *p_buf); /* this is for hci_test */
 #endif

 #if (defined(MCA_INCLUDED) && MCA_INCLUDED == TRUE)
 #include "mca_api.h"
 #include "mca_defs.h"
 #include "mca_int.h"
 #endif

 #include "bta_sys.h"

 #if (BLE_INCLUDED == TRUE)
 #include "gatt_int.h"
 #if (SMP_INCLUDED == TRUE)
 #include "smp_int.h"
 #endif
 #include "btm_ble_int.h"
 #endif

 extern void BTE_InitStack(void);

 /* Define BTU storage area
 */
 #if BTU_DYNAMIC_MEMORY == FALSE
 tBTU_CB  btu_cb;
 #endif

 // Communication queue between btu_task and bta.
 extern fixed_queue_t *btu_bta_msg_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;

 /* Define a function prototype to allow a generic timeout handler */
 typedef void (tUSER_TIMEOUT_FUNC) (TIMER_LIST_ENT *p_tle);

 static void btu_l2cap_alarm_process(TIMER_LIST_ENT *p_tle);
 static void btu_general_alarm_process(TIMER_LIST_ENT *p_tle);
 static void btu_bta_alarm_process(TIMER_LIST_ENT *p_tle);
 static void btu_hci_msg_process(BT_HDR *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);
 }

 void btu_general_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);
 }

 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;
     }
 }

 void btu_l2cap_alarm_ready(fixed_queue_t *queue, UNUSED_ATTR void *context) {
     TIMER_LIST_ENT *p_tle = (TIMER_LIST_ENT *)fixed_queue_dequeue(queue);
     btu_l2cap_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_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);
 }

 static void btu_hci_msg_process(BT_HDR *p_msg) {
     /* Determine the input message type. */
     switch (p_msg->event & BT_EVT_MASK)
     {
         case BTU_POST_TO_TASK_NO_GOOD_HORRIBLE_HACK: // TODO(zachoverflow): remove this
             ((post_to_task_hack_t *)(&p_msg->data[0]))->callback(p_msg);
             break;
         case BT_EVT_TO_BTU_HCI_ACL:
             /* All Acl Data goes to L2CAP */
             l2c_rcv_acl_data (p_msg);
             break;

         case BT_EVT_TO_BTU_L2C_SEG_XMIT:
             /* L2CAP segment transmit complete */
             l2c_link_segments_xmitted (p_msg);
             break;

         case BT_EVT_TO_BTU_HCI_SCO:
 #if BTM_SCO_INCLUDED == TRUE
             btm_route_sco_data (p_msg);
             break;
 #endif

         case BT_EVT_TO_BTU_HCI_EVT:
             btu_hcif_process_event ((UINT8)(p_msg->event & BT_SUB_EVT_MASK), p_msg);
             GKI_freebuf(p_msg);

 #if (defined(HCILP_INCLUDED) && HCILP_INCLUDED == TRUE)
             /* If host receives events which it doesn't response to, */
             /* host should start idle timer to enter sleep mode.     */
             btu_check_bt_sleep ();
 #endif
             break;

         case BT_EVT_TO_BTU_HCI_CMD:
             btu_hcif_send_cmd ((UINT8)(p_msg->event & BT_SUB_EVT_MASK), p_msg);
             break;

         default:;
             int i = 0;
             uint16_t mask = (UINT16) (p_msg->event & BT_EVT_MASK);
             BOOLEAN handled = FALSE;

             for (; !handled && i < BTU_MAX_REG_EVENT; i++)
             {
                 if (btu_cb.event_reg[i].event_cb == NULL)
                     continue;

                 if (mask == btu_cb.event_reg[i].event_range)
                 {
                     if (btu_cb.event_reg[i].event_cb)
                     {
                         btu_cb.event_reg[i].event_cb(p_msg);
                         handled = TRUE;
                     }
                 }
             }

             if (handled == FALSE)
                 GKI_freebuf (p_msg);

             break;
     }

 }

 static void btu_bta_alarm_process(TIMER_LIST_ENT *p_tle) {
     /* call timer callback */
     if (p_tle->p_cback) {
         (*p_tle->p_cback)(p_tle);
     } else if (p_tle->event) {
         BT_HDR *p_msg;
         if ((p_msg = (BT_HDR *) GKI_getbuf(sizeof(BT_HDR))) != NULL) {
             p_msg->event = p_tle->event;
             p_msg->layer_specific = 0;
             bta_sys_sendmsg(p_msg);
         }
     }
 }

 void btu_task_start_up(UNUSED_ATTR void *context) {
   BT_TRACE(TRACE_LAYER_BTU, TRACE_TYPE_API,
       "btu_task pending for preload complete event");

   LOG_INFO(LOG_TAG, "Bluetooth chip preload is complete");

   BT_TRACE(TRACE_LAYER_BTU, TRACE_TYPE_API,
       "btu_task received preload complete event");

   /* Initialize the mandatory core stack control blocks
      (BTU, BTM, L2CAP, and SDP)
    */
   btu_init_core();

   /* Initialize any optional stack components */
   BTE_InitStack();

   bta_sys_init();

   /* Initialise platform trace levels at this point as BTE_InitStack() and bta_sys_init()
    * reset the control blocks and preset the trace level with XXX_INITIAL_TRACE_LEVEL
    */
 #if ( BT_USE_TRACES==TRUE )
   module_init(get_module(BTE_LOGMSG_MODULE));
 #endif

   // Inform the bt jni thread initialization is ok.
   btif_transfer_context(btif_init_ok, 0, NULL, 0, NULL);

   fixed_queue_register_dequeue(btu_bta_msg_queue,
       thread_get_reactor(bt_workqueue_thread),
       btu_bta_msg_ready,
       NULL);

   fixed_queue_register_dequeue(btu_hci_msg_queue,
       thread_get_reactor(bt_workqueue_thread),
       btu_hci_msg_ready,
       NULL);

   fixed_queue_register_dequeue(btu_general_alarm_queue,
       thread_get_reactor(bt_workqueue_thread),
       btu_general_alarm_ready,
       NULL);

   fixed_queue_register_dequeue(btu_oneshot_alarm_queue,
       thread_get_reactor(bt_workqueue_thread),
       btu_oneshot_alarm_ready,
       NULL);

   fixed_queue_register_dequeue(btu_l2cap_alarm_queue,
       thread_get_reactor(bt_workqueue_thread),
       btu_l2cap_alarm_ready,
       NULL);
 }

 void btu_task_shut_down(UNUSED_ATTR void *context) {
   fixed_queue_unregister_dequeue(btu_bta_msg_queue);
   fixed_queue_unregister_dequeue(btu_hci_msg_queue);
   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 ( BT_USE_TRACES==TRUE )
   module_clean_up(get_module(BTE_LOGMSG_MODULE));
 #endif

   bta_sys_free();
   btu_free_core();
 }

 /*******************************************************************************
 **
 ** Function         btu_start_timer
 **
 ** Description      Start a timer for the specified amount of time.
 **                  NOTE: The timeout resolution is in SECONDS! (Even
 **                          though the timer structure field is ticks)
 **
 ** Returns          void
 **
 *******************************************************************************/
 static void btu_general_alarm_process(TIMER_LIST_ENT *p_tle) {
     assert(p_tle != NULL);

     switch (p_tle->event) {
         case BTU_TTYPE_BTM_DEV_CTL:
             btm_dev_timeout(p_tle);
             break;

         case BTU_TTYPE_L2CAP_LINK:
         case BTU_TTYPE_L2CAP_CHNL:
         case BTU_TTYPE_L2CAP_HOLD:
         case BTU_TTYPE_L2CAP_INFO:
         case BTU_TTYPE_L2CAP_FCR_ACK:
             l2c_process_timeout (p_tle);
             break;

         case BTU_TTYPE_SDP:
             sdp_conn_timeout ((tCONN_CB *)p_tle->param);
             break;

         case BTU_TTYPE_BTM_RMT_NAME:
             btm_inq_rmt_name_failed();
             break;

         case BTU_TTYPE_RFCOMM_MFC:
         case BTU_TTYPE_RFCOMM_PORT:
             rfcomm_process_timeout (p_tle);
             break;

 #if ((defined(BNEP_INCLUDED) && BNEP_INCLUDED == TRUE))
         case BTU_TTYPE_BNEP:
             bnep_process_timeout(p_tle);
             break;
 #endif


 #if (defined(AVDT_INCLUDED) && AVDT_INCLUDED == TRUE)
         case BTU_TTYPE_AVDT_CCB_RET:
         case BTU_TTYPE_AVDT_CCB_RSP:
         case BTU_TTYPE_AVDT_CCB_IDLE:
         case BTU_TTYPE_AVDT_SCB_TC:
             avdt_process_timeout(p_tle);
             break;
 #endif

 #if (defined(HID_HOST_INCLUDED) && HID_HOST_INCLUDED == TRUE)
         case BTU_TTYPE_HID_HOST_REPAGE_TO :
             hidh_proc_repage_timeout(p_tle);
             break;
 #endif

 #if (defined(BLE_INCLUDED) && BLE_INCLUDED == TRUE)
         case BTU_TTYPE_BLE_INQUIRY:
         case BTU_TTYPE_BLE_GAP_LIM_DISC:
         case BTU_TTYPE_BLE_RANDOM_ADDR:
         case BTU_TTYPE_BLE_GAP_FAST_ADV:
         case BTU_TTYPE_BLE_OBSERVE:
             btm_ble_timeout(p_tle);
             break;

         case BTU_TTYPE_ATT_WAIT_FOR_RSP:
             gatt_rsp_timeout(p_tle);
             break;

         case BTU_TTYPE_ATT_WAIT_FOR_IND_ACK:
             gatt_ind_ack_timeout(p_tle);
             break;
 #if (defined(SMP_INCLUDED) && SMP_INCLUDED == TRUE)
         case BTU_TTYPE_SMP_PAIRING_CMD:
             smp_rsp_timeout(p_tle);
             break;
 #endif

 #endif

 #if (MCA_INCLUDED == TRUE)
         case BTU_TTYPE_MCA_CCB_RSP:
             mca_process_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:;
                 int i = 0;
                 BOOLEAN handled = FALSE;

                 for (; !handled && i < BTU_MAX_REG_TIMER; i++)
                 {
                     if (btu_cb.timer_reg[i].timer_cb == NULL)
                         continue;
                     if (btu_cb.timer_reg[i].p_tle == p_tle)
                     {
                         btu_cb.timer_reg[i].timer_cb(p_tle);
                         handled = TRUE;
                     }
                 }
                 break;
     }
 }

 void btu_general_alarm_cb(void *data) {
   assert(data != NULL);
   TIMER_LIST_ENT *p_tle = (TIMER_LIST_ENT *)data;

   fixed_queue_enqueue(btu_general_alarm_queue, p_tle);
 }

 void btu_start_timer(TIMER_LIST_ENT *p_tle, UINT16 type, UINT32 timeout_sec) {
   assert(p_tle != NULL);

   // Get the alarm for the timer list entry.
   pthread_mutex_lock(&btu_general_alarm_lock);
   if (!hash_map_has_key(btu_general_alarm_hash_map, p_tle)) {
     hash_map_set(btu_general_alarm_hash_map, p_tle, alarm_new());
   }
   pthread_mutex_unlock(&btu_general_alarm_lock);

   alarm_t *alarm = hash_map_get(btu_general_alarm_hash_map, p_tle);
   if (alarm == NULL) {
     LOG_ERROR(LOG_TAG, "%s Unable to create alarm", __func__);
     return;
   }
   alarm_cancel(alarm);

   p_tle->event = type;
   // NOTE: This value is in seconds but stored in a ticks field.
   p_tle->ticks = timeout_sec;
   p_tle->in_use = TRUE;
   alarm_set(alarm, (period_ms_t)(timeout_sec * 1000), btu_general_alarm_cb, (void *)p_tle);
 }

 /*******************************************************************************
 **
 ** Function         btu_stop_timer
 **
 ** Description      Stop a timer.
 **
 ** Returns          void
 **
 *******************************************************************************/
 void btu_stop_timer(TIMER_LIST_ENT *p_tle) {
   assert(p_tle != NULL);

   if (p_tle->in_use == FALSE)
     return;
   p_tle->in_use = FALSE;

   // Get the alarm for the timer list entry.
   alarm_t *alarm = hash_map_get(btu_general_alarm_hash_map, p_tle);
   if (alarm == NULL) {
     LOG_WARN(LOG_TAG, "%s Unable to find expected alarm in hashmap", __func__);
     return;
   }
   alarm_cancel(alarm);
 }

 #if defined(QUICK_TIMER_TICKS_PER_SEC) && (QUICK_TIMER_TICKS_PER_SEC > 0)
 /*******************************************************************************
 **
 ** Function         btu_start_quick_timer
 **
 ** Description      Start a timer for the specified amount of time in ticks.
 **
 ** Returns          void
 **
 *******************************************************************************/
 static void btu_l2cap_alarm_process(TIMER_LIST_ENT *p_tle) {
   assert(p_tle != NULL);

   switch (p_tle->event) {
     case BTU_TTYPE_L2CAP_CHNL:      /* monitor or retransmission timer */
     case BTU_TTYPE_L2CAP_FCR_ACK:   /* ack timer */
       l2c_process_timeout (p_tle);
       break;

     default:
       break;
   }
 }

 static void btu_l2cap_alarm_cb(void *data) {
   assert(data != NULL);
   TIMER_LIST_ENT *p_tle = (TIMER_LIST_ENT *)data;

   fixed_queue_enqueue(btu_l2cap_alarm_queue, p_tle);
 }

 void btu_start_quick_timer(TIMER_LIST_ENT *p_tle, UINT16 type, UINT32 timeout_ticks) {
   assert(p_tle != NULL);

   // Get the alarm for the timer list entry.
   pthread_mutex_lock(&btu_l2cap_alarm_lock);
   if (!hash_map_has_key(btu_l2cap_alarm_hash_map, p_tle)) {
     hash_map_set(btu_l2cap_alarm_hash_map, p_tle, alarm_new());
   }
   pthread_mutex_unlock(&btu_l2cap_alarm_lock);

   alarm_t *alarm = hash_map_get(btu_l2cap_alarm_hash_map, p_tle);
   if (alarm == NULL) {
     LOG_ERROR(LOG_TAG, "%s Unable to create alarm", __func__);
     return;
   }
   alarm_cancel(alarm);

   p_tle->event = type;
   p_tle->ticks = timeout_ticks;
   p_tle->in_use = TRUE;
   // The quick timer ticks are 100ms long.
   alarm_set(alarm, (period_ms_t)(timeout_ticks * 100), btu_l2cap_alarm_cb, (void *)p_tle);
 }

 /*******************************************************************************
 **
 ** Function         btu_stop_quick_timer
 **
 ** Description      Stop a timer.
 **
 ** Returns          void
 **
 *******************************************************************************/
 void btu_stop_quick_timer(TIMER_LIST_ENT *p_tle) {
   assert(p_tle != NULL);

   if (p_tle->in_use == FALSE)
     return;
   p_tle->in_use = FALSE;

   // Get the alarm for the timer list entry.
   alarm_t *alarm = hash_map_get(btu_l2cap_alarm_hash_map, p_tle);
   if (alarm == NULL) {
     LOG_WARN(LOG_TAG, "%s Unable to find expected alarm in hashmap", __func__);
     return;
   }
   alarm_cancel(alarm);
 }
 #endif /* defined(QUICK_TIMER_TICKS_PER_SEC) && (QUICK_TIMER_TICKS_PER_SEC > 0) */

 void btu_oneshot_alarm_cb(void *data) {
   assert(data != NULL);
   TIMER_LIST_ENT *p_tle = (TIMER_LIST_ENT *)data;

   btu_stop_timer_oneshot(p_tle);

   fixed_queue_enqueue(btu_oneshot_alarm_queue, p_tle);
 }

 /*
  * Starts a oneshot timer with a timeout in seconds.
  */
 void btu_start_timer_oneshot(TIMER_LIST_ENT *p_tle, UINT16 type, UINT32 timeout_sec) {
   assert(p_tle != NULL);

   // Get the alarm for the timer list entry.
   pthread_mutex_lock(&btu_oneshot_alarm_lock);
   if (!hash_map_has_key(btu_oneshot_alarm_hash_map, p_tle)) {
     hash_map_set(btu_oneshot_alarm_hash_map, p_tle, alarm_new());
   }
   pthread_mutex_unlock(&btu_oneshot_alarm_lock);

   alarm_t *alarm = hash_map_get(btu_oneshot_alarm_hash_map, p_tle);
   if (alarm == NULL) {
     LOG_ERROR(LOG_TAG, "%s Unable to create alarm", __func__);
     return;
   }
   alarm_cancel(alarm);

   p_tle->event = type;
   p_tle->in_use = TRUE;
   // NOTE: This value is in seconds but stored in a ticks field.
   p_tle->ticks = timeout_sec;
   alarm_set(alarm, (period_ms_t)(timeout_sec * 1000), btu_oneshot_alarm_cb, (void *)p_tle);
 }

 void btu_stop_timer_oneshot(TIMER_LIST_ENT *p_tle) {
   assert(p_tle != NULL);

   if (p_tle->in_use == FALSE)
     return;
   p_tle->in_use = FALSE;

   // Get the alarm for the timer list entry.
   alarm_t *alarm = hash_map_get(btu_oneshot_alarm_hash_map, p_tle);
   if (alarm == NULL) {
     LOG_WARN(LOG_TAG, "%s Unable to find expected alarm in hashmap", __func__);
     return;
   }
   alarm_cancel(alarm);
 }

 #if (defined(HCILP_INCLUDED) && HCILP_INCLUDED == TRUE)
 /*******************************************************************************
 **
 ** Function         btu_check_bt_sleep
 **
 ** Description      This function is called to check if controller can go to sleep.
 **
 ** Returns          void
 **
 *******************************************************************************/
 void btu_check_bt_sleep (void)
 {
     // TODO(zachoverflow) take pending commands into account?
     if (l2cb.controller_xmit_window == l2cb.num_lm_acl_bufs)
     {
         bte_main_lpm_allow_bt_device_sleep();
     }
 }
 #endif
	/******************************************************************************
	*
	* Copyright (C) 1999-2012 Broadcom Corporation
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at:
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*
	******************************************************************************/

	#define LOG_TAG "bt_btu_task"

	#include <assert.h>
	#include <pthread.h>
	#include <stdlib.h>
	#include <stdio.h>
	#include <string.h>

	#include "osi/include/alarm.h"
	#include "bt_target.h"
	#include "bt_trace.h"
	#include "bt_types.h"
	#include "bt_utils.h"
	#include "btif_common.h"
	#include "btm_api.h"
	#include "btm_int.h"
	#include "btu.h"
	#include "osi/include/fixed_queue.h"
	#include "osi/include/future.h"
	#include "gki.h"
	#include "osi/include/hash_map.h"
	#include "hcimsgs.h"
	#include "l2c_int.h"
	#include "btcore/include/module.h"
	#include "osi/include/osi.h"
	#include "osi/include/log.h"
	#include "sdpint.h"
	#include "osi/include/thread.h"

	#include "port_api.h"
	#include "port_ext.h"

	#include "gap_int.h"

	#if (defined(BNEP_INCLUDED) && BNEP_INCLUDED == TRUE)
	#include "bnep_int.h"
	#endif

	#if (defined(PAN_INCLUDED) && PAN_INCLUDED == TRUE)
	#include "pan_int.h"
	#endif

	#if (defined(HID_HOST_INCLUDED) && HID_HOST_INCLUDED == TRUE )
	#include "hidh_int.h"
	#endif

	#if (defined(AVDT_INCLUDED) && AVDT_INCLUDED == TRUE)
	#include "avdt_int.h"
	#else
	extern void avdt_rcv_sync_info (BT_HDR p_buf); / this is for hci_test */
	#endif

	#if (defined(MCA_INCLUDED) && MCA_INCLUDED == TRUE)
	#include "mca_api.h"
	#include "mca_defs.h"
	#include "mca_int.h"
	#endif

	#include "bta_sys.h"

	#if (BLE_INCLUDED == TRUE)
	#include "gatt_int.h"
	#if (SMP_INCLUDED == TRUE)
	#include "smp_int.h"
	#endif
	#include "btm_ble_int.h"
	#endif

	extern void BTE_InitStack(void);

	/* Define BTU storage area
	*/
	#if BTU_DYNAMIC_MEMORY == FALSE
	tBTU_CB btu_cb;
	#endif

	// Communication queue between btu_task and bta.
	extern fixed_queue_t *btu_bta_msg_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;

	/* Define a function prototype to allow a generic timeout handler */
	typedef void (tUSER_TIMEOUT_FUNC) (TIMER_LIST_ENT *p_tle);

	static void btu_l2cap_alarm_process(TIMER_LIST_ENT *p_tle);
	static void btu_general_alarm_process(TIMER_LIST_ENT *p_tle);
	static void btu_bta_alarm_process(TIMER_LIST_ENT *p_tle);
	static void btu_hci_msg_process(BT_HDR *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);
	}

	void btu_general_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);
	}

	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;
	}
	}

	void btu_l2cap_alarm_ready(fixed_queue_t queue, UNUSED_ATTR void context) {
	TIMER_LIST_ENT p_tle = (TIMER_LIST_ENT )fixed_queue_dequeue(queue);
	btu_l2cap_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_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);
	}

	static void btu_hci_msg_process(BT_HDR *p_msg) {
	/* Determine the input message type. */
	switch (p_msg->event & BT_EVT_MASK)
	{
	case BTU_POST_TO_TASK_NO_GOOD_HORRIBLE_HACK: // TODO(zachoverflow): remove this
	((post_to_task_hack_t *)(&p_msg->data[0]))->callback(p_msg);
	break;
	case BT_EVT_TO_BTU_HCI_ACL:
	/* All Acl Data goes to L2CAP */
	l2c_rcv_acl_data (p_msg);
	break;

	case BT_EVT_TO_BTU_L2C_SEG_XMIT:
	/* L2CAP segment transmit complete */
	l2c_link_segments_xmitted (p_msg);
	break;

	case BT_EVT_TO_BTU_HCI_SCO:
	#if BTM_SCO_INCLUDED == TRUE
	btm_route_sco_data (p_msg);
	break;
	#endif

	case BT_EVT_TO_BTU_HCI_EVT:
	btu_hcif_process_event ((UINT8)(p_msg->event & BT_SUB_EVT_MASK), p_msg);
	GKI_freebuf(p_msg);

	#if (defined(HCILP_INCLUDED) && HCILP_INCLUDED == TRUE)
	/* If host receives events which it doesn't response to, */
	/* host should start idle timer to enter sleep mode. */
	btu_check_bt_sleep ();
	#endif
	break;

	case BT_EVT_TO_BTU_HCI_CMD:
	btu_hcif_send_cmd ((UINT8)(p_msg->event & BT_SUB_EVT_MASK), p_msg);
	break;

	default:;
	int i = 0;
	uint16_t mask = (UINT16) (p_msg->event & BT_EVT_MASK);
	BOOLEAN handled = FALSE;

	for (; !handled && i < BTU_MAX_REG_EVENT; i++)
	{
	if (btu_cb.event_reg[i].event_cb == NULL)
	continue;

	if (mask == btu_cb.event_reg[i].event_range)
	{
	if (btu_cb.event_reg[i].event_cb)
	{
	btu_cb.event_reg[i].event_cb(p_msg);
	handled = TRUE;
	}
	}
	}

	if (handled == FALSE)
	GKI_freebuf (p_msg);

	break;
	}

	}

	static void btu_bta_alarm_process(TIMER_LIST_ENT *p_tle) {
	/* call timer callback */
	if (p_tle->p_cback) {
	(*p_tle->p_cback)(p_tle);
	} else if (p_tle->event) {
	BT_HDR *p_msg;
	if ((p_msg = (BT_HDR *) GKI_getbuf(sizeof(BT_HDR))) != NULL) {
	p_msg->event = p_tle->event;
	p_msg->layer_specific = 0;
	bta_sys_sendmsg(p_msg);
	}
	}
	}

	void btu_task_start_up(UNUSED_ATTR void *context) {
	BT_TRACE(TRACE_LAYER_BTU, TRACE_TYPE_API,
	"btu_task pending for preload complete event");

	LOG_INFO(LOG_TAG, "Bluetooth chip preload is complete");

	BT_TRACE(TRACE_LAYER_BTU, TRACE_TYPE_API,
	"btu_task received preload complete event");

	/* Initialize the mandatory core stack control blocks
	(BTU, BTM, L2CAP, and SDP)
	*/
	btu_init_core();

	/* Initialize any optional stack components */
	BTE_InitStack();

	bta_sys_init();

	/* Initialise platform trace levels at this point as BTE_InitStack() and bta_sys_init()
	* reset the control blocks and preset the trace level with XXX_INITIAL_TRACE_LEVEL
	*/
	#if ( BT_USE_TRACES==TRUE )
	module_init(get_module(BTE_LOGMSG_MODULE));
	#endif

	// Inform the bt jni thread initialization is ok.
	btif_transfer_context(btif_init_ok, 0, NULL, 0, NULL);

	fixed_queue_register_dequeue(btu_bta_msg_queue,
	thread_get_reactor(bt_workqueue_thread),
	btu_bta_msg_ready,
	NULL);

	fixed_queue_register_dequeue(btu_hci_msg_queue,
	thread_get_reactor(bt_workqueue_thread),
	btu_hci_msg_ready,
	NULL);

	fixed_queue_register_dequeue(btu_general_alarm_queue,
	thread_get_reactor(bt_workqueue_thread),
	btu_general_alarm_ready,
	NULL);

	fixed_queue_register_dequeue(btu_oneshot_alarm_queue,
	thread_get_reactor(bt_workqueue_thread),
	btu_oneshot_alarm_ready,
	NULL);

	fixed_queue_register_dequeue(btu_l2cap_alarm_queue,
	thread_get_reactor(bt_workqueue_thread),
	btu_l2cap_alarm_ready,
	NULL);
	}

	void btu_task_shut_down(UNUSED_ATTR void *context) {
	fixed_queue_unregister_dequeue(btu_bta_msg_queue);
	fixed_queue_unregister_dequeue(btu_hci_msg_queue);
	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 ( BT_USE_TRACES==TRUE )
	module_clean_up(get_module(BTE_LOGMSG_MODULE));
	#endif

	bta_sys_free();
	btu_free_core();
	}

	/*******************************************************************************
	**
	** Function btu_start_timer
	**
	** Description Start a timer for the specified amount of time.
	** NOTE: The timeout resolution is in SECONDS! (Even
	** though the timer structure field is ticks)
	**
	** Returns void
	**
	*******************************************************************************/
	static void btu_general_alarm_process(TIMER_LIST_ENT *p_tle) {
	assert(p_tle != NULL);

	switch (p_tle->event) {
	case BTU_TTYPE_BTM_DEV_CTL:
	btm_dev_timeout(p_tle);
	break;

	case BTU_TTYPE_L2CAP_LINK:
	case BTU_TTYPE_L2CAP_CHNL:
	case BTU_TTYPE_L2CAP_HOLD:
	case BTU_TTYPE_L2CAP_INFO:
	case BTU_TTYPE_L2CAP_FCR_ACK:
	l2c_process_timeout (p_tle);
	break;

	case BTU_TTYPE_SDP:
	sdp_conn_timeout ((tCONN_CB *)p_tle->param);
	break;

	case BTU_TTYPE_BTM_RMT_NAME:
	btm_inq_rmt_name_failed();
	break;

	case BTU_TTYPE_RFCOMM_MFC:
	case BTU_TTYPE_RFCOMM_PORT:
	rfcomm_process_timeout (p_tle);
	break;

	#if ((defined(BNEP_INCLUDED) && BNEP_INCLUDED == TRUE))
	case BTU_TTYPE_BNEP:
	bnep_process_timeout(p_tle);
	break;
	#endif


	#if (defined(AVDT_INCLUDED) && AVDT_INCLUDED == TRUE)
	case BTU_TTYPE_AVDT_CCB_RET:
	case BTU_TTYPE_AVDT_CCB_RSP:
	case BTU_TTYPE_AVDT_CCB_IDLE:
	case BTU_TTYPE_AVDT_SCB_TC:
	avdt_process_timeout(p_tle);
	break;
	#endif

	#if (defined(HID_HOST_INCLUDED) && HID_HOST_INCLUDED == TRUE)
	case BTU_TTYPE_HID_HOST_REPAGE_TO :
	hidh_proc_repage_timeout(p_tle);
	break;
	#endif

	#if (defined(BLE_INCLUDED) && BLE_INCLUDED == TRUE)
	case BTU_TTYPE_BLE_INQUIRY:
	case BTU_TTYPE_BLE_GAP_LIM_DISC:
	case BTU_TTYPE_BLE_RANDOM_ADDR:
	case BTU_TTYPE_BLE_GAP_FAST_ADV:
	case BTU_TTYPE_BLE_OBSERVE:
	btm_ble_timeout(p_tle);
	break;

	case BTU_TTYPE_ATT_WAIT_FOR_RSP:
	gatt_rsp_timeout(p_tle);
	break;

	case BTU_TTYPE_ATT_WAIT_FOR_IND_ACK:
	gatt_ind_ack_timeout(p_tle);
	break;
	#if (defined(SMP_INCLUDED) && SMP_INCLUDED == TRUE)
	case BTU_TTYPE_SMP_PAIRING_CMD:
	smp_rsp_timeout(p_tle);
	break;
	#endif

	#endif

	#if (MCA_INCLUDED == TRUE)
	case BTU_TTYPE_MCA_CCB_RSP:
	mca_process_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:;
	int i = 0;
	BOOLEAN handled = FALSE;

	for (; !handled && i < BTU_MAX_REG_TIMER; i++)
	{
	if (btu_cb.timer_reg[i].timer_cb == NULL)
	continue;
	if (btu_cb.timer_reg[i].p_tle == p_tle)
	{
	btu_cb.timer_reg[i].timer_cb(p_tle);
	handled = TRUE;
	}
	}
	break;
	}
	}

	void btu_general_alarm_cb(void *data) {
	assert(data != NULL);
	TIMER_LIST_ENT p_tle = (TIMER_LIST_ENT )data;

	fixed_queue_enqueue(btu_general_alarm_queue, p_tle);
	}

	void btu_start_timer(TIMER_LIST_ENT *p_tle, UINT16 type, UINT32 timeout_sec) {
	assert(p_tle != NULL);

	// Get the alarm for the timer list entry.
	pthread_mutex_lock(&btu_general_alarm_lock);
	if (!hash_map_has_key(btu_general_alarm_hash_map, p_tle)) {
	hash_map_set(btu_general_alarm_hash_map, p_tle, alarm_new());
	}
	pthread_mutex_unlock(&btu_general_alarm_lock);

	alarm_t *alarm = hash_map_get(btu_general_alarm_hash_map, p_tle);
	if (alarm == NULL) {
	LOG_ERROR(LOG_TAG, "%s Unable to create alarm", __func__);
	return;
	}
	alarm_cancel(alarm);

	p_tle->event = type;
	// NOTE: This value is in seconds but stored in a ticks field.
	p_tle->ticks = timeout_sec;
	p_tle->in_use = TRUE;
	alarm_set(alarm, (period_ms_t)(timeout_sec * 1000), btu_general_alarm_cb, (void *)p_tle);
	}

	/*******************************************************************************
	**
	** Function btu_stop_timer
	**
	** Description Stop a timer.
	**
	** Returns void
	**
	*******************************************************************************/
	void btu_stop_timer(TIMER_LIST_ENT *p_tle) {
	assert(p_tle != NULL);

	if (p_tle->in_use == FALSE)
	return;
	p_tle->in_use = FALSE;

	// Get the alarm for the timer list entry.
	alarm_t *alarm = hash_map_get(btu_general_alarm_hash_map, p_tle);
	if (alarm == NULL) {
	LOG_WARN(LOG_TAG, "%s Unable to find expected alarm in hashmap", __func__);
	return;
	}
	alarm_cancel(alarm);
	}

	#if defined(QUICK_TIMER_TICKS_PER_SEC) && (QUICK_TIMER_TICKS_PER_SEC > 0)
	/*******************************************************************************
	**
	** Function btu_start_quick_timer
	**
	** Description Start a timer for the specified amount of time in ticks.
	**
	** Returns void
	**
	*******************************************************************************/
	static void btu_l2cap_alarm_process(TIMER_LIST_ENT *p_tle) {
	assert(p_tle != NULL);

	switch (p_tle->event) {
	case BTU_TTYPE_L2CAP_CHNL: /* monitor or retransmission timer */
	case BTU_TTYPE_L2CAP_FCR_ACK: /* ack timer */
	l2c_process_timeout (p_tle);
	break;

	default:
	break;
	}
	}

	static void btu_l2cap_alarm_cb(void *data) {
	assert(data != NULL);
	TIMER_LIST_ENT p_tle = (TIMER_LIST_ENT )data;

	fixed_queue_enqueue(btu_l2cap_alarm_queue, p_tle);
	}

	void btu_start_quick_timer(TIMER_LIST_ENT *p_tle, UINT16 type, UINT32 timeout_ticks) {
	assert(p_tle != NULL);

	// Get the alarm for the timer list entry.
	pthread_mutex_lock(&btu_l2cap_alarm_lock);
	if (!hash_map_has_key(btu_l2cap_alarm_hash_map, p_tle)) {
	hash_map_set(btu_l2cap_alarm_hash_map, p_tle, alarm_new());
	}
	pthread_mutex_unlock(&btu_l2cap_alarm_lock);

	alarm_t *alarm = hash_map_get(btu_l2cap_alarm_hash_map, p_tle);
	if (alarm == NULL) {
	LOG_ERROR(LOG_TAG, "%s Unable to create alarm", __func__);
	return;
	}
	alarm_cancel(alarm);

	p_tle->event = type;
	p_tle->ticks = timeout_ticks;
	p_tle->in_use = TRUE;
	// The quick timer ticks are 100ms long.
	alarm_set(alarm, (period_ms_t)(timeout_ticks * 100), btu_l2cap_alarm_cb, (void *)p_tle);
	}

	/*******************************************************************************
	**
	** Function btu_stop_quick_timer
	**
	** Description Stop a timer.
	**
	** Returns void
	**
	*******************************************************************************/
	void btu_stop_quick_timer(TIMER_LIST_ENT *p_tle) {
	assert(p_tle != NULL);

	if (p_tle->in_use == FALSE)
	return;
	p_tle->in_use = FALSE;

	// Get the alarm for the timer list entry.
	alarm_t *alarm = hash_map_get(btu_l2cap_alarm_hash_map, p_tle);
	if (alarm == NULL) {
	LOG_WARN(LOG_TAG, "%s Unable to find expected alarm in hashmap", __func__);
	return;
	}
	alarm_cancel(alarm);
	}
	#endif /* defined(QUICK_TIMER_TICKS_PER_SEC) && (QUICK_TIMER_TICKS_PER_SEC > 0) */

	void btu_oneshot_alarm_cb(void *data) {
	assert(data != NULL);
	TIMER_LIST_ENT p_tle = (TIMER_LIST_ENT )data;

	btu_stop_timer_oneshot(p_tle);

	fixed_queue_enqueue(btu_oneshot_alarm_queue, p_tle);
	}

	/*
	* Starts a oneshot timer with a timeout in seconds.
	*/
	void btu_start_timer_oneshot(TIMER_LIST_ENT *p_tle, UINT16 type, UINT32 timeout_sec) {
	assert(p_tle != NULL);

	// Get the alarm for the timer list entry.
	pthread_mutex_lock(&btu_oneshot_alarm_lock);
	if (!hash_map_has_key(btu_oneshot_alarm_hash_map, p_tle)) {
	hash_map_set(btu_oneshot_alarm_hash_map, p_tle, alarm_new());
	}
	pthread_mutex_unlock(&btu_oneshot_alarm_lock);

	alarm_t *alarm = hash_map_get(btu_oneshot_alarm_hash_map, p_tle);
	if (alarm == NULL) {
	LOG_ERROR(LOG_TAG, "%s Unable to create alarm", __func__);
	return;
	}
	alarm_cancel(alarm);

	p_tle->event = type;
	p_tle->in_use = TRUE;
	// NOTE: This value is in seconds but stored in a ticks field.
	p_tle->ticks = timeout_sec;
	alarm_set(alarm, (period_ms_t)(timeout_sec * 1000), btu_oneshot_alarm_cb, (void *)p_tle);
	}

	void btu_stop_timer_oneshot(TIMER_LIST_ENT *p_tle) {
	assert(p_tle != NULL);

	if (p_tle->in_use == FALSE)
	return;
	p_tle->in_use = FALSE;

	// Get the alarm for the timer list entry.
	alarm_t *alarm = hash_map_get(btu_oneshot_alarm_hash_map, p_tle);
	if (alarm == NULL) {
	LOG_WARN(LOG_TAG, "%s Unable to find expected alarm in hashmap", __func__);
	return;
	}
	alarm_cancel(alarm);
	}

	#if (defined(HCILP_INCLUDED) && HCILP_INCLUDED == TRUE)
	/*******************************************************************************
	**
	** Function btu_check_bt_sleep
	**
	** Description This function is called to check if controller can go to sleep.
	**
	** Returns void
	**
	*******************************************************************************/
	void btu_check_bt_sleep (void)
	{
	// TODO(zachoverflow) take pending commands into account?
	if (l2cb.controller_xmit_window == l2cb.num_lm_acl_bufs)
	{
	bte_main_lpm_allow_bt_device_sleep();
	}
	}
	#endif