alex/esp-idf
alex/esp-idf
1
0
Fork 0
mirror of https://github.com/espressif/esp-idf.git synced 2024-10-05 20:47:46 -04:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

components/bt: Optimization and bugfix of previous commits

Browse Source
This commit is contained in:
baohongde 2019-06-21 11:55:45 +08:00
parent 8024fcb296
commit 149e07911d
29 changed files with 451 additions and 331 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
components/bt/bluedroid/bta/dm/bta_dm_act.c
View File

@ -1298,7 +1298,9 @@ void bta_dm_loc_oob(tBTA_DM_MSG *p_data)
*******************************************************************************/
void bta_dm_oob_reply(tBTA_DM_MSG *p_data)
{
#if (BLE_INCLUDED)
BTM_BleOobDataReply(p_data->oob_reply.bd_addr, BTM_SUCCESS, p_data->oob_reply.len, p_data->oob_reply.value);
#endif
}
/*******************************************************************************

2
components/bt/bluedroid/bta/dm/bta_dm_cfg.c
View File

@ -441,4 +441,4 @@ tBTA_DM_EIR_CONF bta_dm_eir_cfg = {
NULL
#endif /* #if (BTC_GAP_BT_INCLUDED == TRUE) */
};
tBTA_DM_EIR_CONF *const p_bta_dm_eir_cfg = (tBTA_DM_EIR_CONF *) &bta_dm_eir_cfg;
tBTA_DM_EIR_CONF *p_bta_dm_eir_cfg = (tBTA_DM_EIR_CONF *) &bta_dm_eir_cfg;

2
components/bt/bluedroid/bta/dm/bta_dm_main.c
View File

@ -160,7 +160,9 @@ const tBTA_DM_ACTION bta_dm_action[BTA_DM_MAX_EVT] = {
bta_dm_update_white_list, /* BTA_DM_API_UPDATE_WHITE_LIST_EVT */
bta_dm_ble_read_adv_tx_power, /* BTA_DM_API_BLE_READ_ADV_TX_POWER_EVT */
bta_dm_ble_read_rssi, /* BTA_DM_API_BLE_READ_RSSI_EVT */
#if BLE_INCLUDED == TRUE
bta_dm_ble_update_duplicate_exceptional_list,/* BTA_DM_API_UPDATE_DUPLICATE_EXCEPTIONAL_LIST_EVT */
#endif
};

2
components/bt/bluedroid/bta/dm/include/bta_dm_int.h
View File

@ -157,7 +157,9 @@ enum {
BTA_DM_API_UPDATE_WHITE_LIST_EVT,
BTA_DM_API_BLE_READ_ADV_TX_POWER_EVT,
BTA_DM_API_BLE_READ_RSSI_EVT,
#if BLE_INCLUDED == TRUE
BTA_DM_API_UPDATE_DUPLICATE_EXCEPTIONAL_LIST_EVT,
#endif
BTA_DM_MAX_EVT
};

2
components/bt/bluedroid/bta/gatt/bta_gattc_co.c
View File

@ -269,8 +269,8 @@ tBTA_GATT_STATUS bta_gattc_co_cache_load(tBTA_GATTC_NV_ATTR *attr, UINT8 index)
// Read the size of memory space required for blob
nvs_get_blob(cache_env->cache_addr[index].cache_fp, cache_key, NULL, &length);
// Read previously saved blob if available
#if (!CONFIG_BT_STACK_NO_LOG)
esp_err_t err_code = nvs_get_blob(cache_env->cache_addr[index].cache_fp, cache_key, attr, &length);
#if (!CONFIG_BT_STACK_NO_LOG)
num_attr = length / sizeof(tBTA_GATTC_NV_ATTR);
#endif
status = (err_code == ESP_OK && length != 0) ? BTA_GATT_OK : BTA_GATT_ERROR;

2
components/bt/bluedroid/bta/include/bta/bta_sys.h
View File

@ -215,7 +215,7 @@ extern "C" {
extern void bta_sys_init(void);
extern void bta_sys_free(void);
extern void bta_sys_event(BT_HDR *p_msg);
extern void bta_sys_event(void * param);
extern void bta_sys_set_trace_level(UINT8 level);
extern void bta_sys_register(UINT8 id, const tBTA_SYS_REG *p_reg);
extern void bta_sys_deregister(UINT8 id);

4
components/bt/bluedroid/bta/sys/bta_sys_main.c
View File

@ -482,8 +482,10 @@ void bta_sys_hw_evt_stack_enabled(tBTA_SYS_HW_MSG *p_sys_hw_msg)
** Returns void
**
*******************************************************************************/
void bta_sys_event(BT_HDR *p_msg)
void bta_sys_event(void * param)
{
BT_HDR *p_msg = (BT_HDR *)param;
UINT8 id;
BOOLEAN freebuf = TRUE;

116
components/bt/bluedroid/btc/core/btc_task.c
View File

@ -176,95 +176,121 @@ bt_status_t btc_transfer_context(btc_msg_t *msg, void *arg, int arg_len, btc_arg
}
#if BTC_DYNAMIC_MENDRY
static void btc_deinit_mem(void) {
if (btc_dm_cb_ptr) {
osi_free(btc_dm_cb_ptr);
btc_dm_cb_ptr = NULL;
}
if (btc_profile_cb_tab) {
osi_free(btc_profile_cb_tab);
btc_profile_cb_tab = NULL;
}
#if (BLE_INCLUDED == TRUE)
if (gl_bta_adv_data_ptr) {
osi_free(gl_bta_adv_data_ptr);
gl_bta_adv_data_ptr = NULL;
}
if (gl_bta_scan_rsp_data_ptr) {
osi_free(gl_bta_scan_rsp_data_ptr);
gl_bta_scan_rsp_data_ptr = NULL;
}
#endif ///BLE_INCLUDED == TRUE
#if GATTS_INCLUDED == TRUE && GATT_DYNAMIC_MEMORY == TRUE
if (btc_creat_tab_env_ptr) {
osi_free(btc_creat_tab_env_ptr);
btc_creat_tab_env_ptr = NULL;
}
if (blufi_env_ptr) {
osi_free(blufi_env_ptr);
blufi_env_ptr = NULL;
}
#endif
#if BTC_HF_CLIENT_INCLUDED == TRUE && HFP_DYNAMIC_MEMORY == TRUE
if (hf_client_local_param_ptr) {
osi_free(hf_client_local_param_ptr);
hf_client_local_param_ptr = NULL;
}
#endif
#if BTC_AV_INCLUDED == TRUE && AVRC_DYNAMIC_MEMORY == TRUE
if (btc_rc_cb_ptr) {
osi_free(btc_rc_cb_ptr);
btc_rc_cb_ptr = NULL;
}
if (bta_av_co_cb_ptr) {
osi_free(bta_av_co_cb_ptr);
bta_av_co_cb_ptr = NULL;
}
#endif
}
static bt_status_t btc_init_mem(void) {
if ((btc_dm_cb_ptr = (btc_dm_cb_t *)osi_malloc(sizeof(btc_dm_cb_t))) == NULL) {
return BT_STATUS_NOMEM;
goto error_exit;
}
memset((void *)btc_dm_cb_ptr, 0, sizeof(btc_dm_cb_t));
if ((btc_profile_cb_tab = (void **)osi_malloc(sizeof(void *) * BTC_PID_NUM)) == NULL) {
return BT_STATUS_NOMEM;
goto error_exit;
}
memset((void *)btc_profile_cb_tab, 0, sizeof(void *) * BTC_PID_NUM);
#if (BLE_INCLUDED == TRUE)
if ((gl_bta_adv_data_ptr = (tBTA_BLE_ADV_DATA *)osi_malloc(sizeof(tBTA_BLE_ADV_DATA))) == NULL) {
return BT_STATUS_NOMEM;
goto error_exit;
}
memset((void *)gl_bta_adv_data_ptr, 0, sizeof(tBTA_BLE_ADV_DATA));
if ((gl_bta_scan_rsp_data_ptr = (tBTA_BLE_ADV_DATA *)osi_malloc(sizeof(tBTA_BLE_ADV_DATA))) == NULL) {
return BT_STATUS_NOMEM;
goto error_exit;
}
memset((void *)gl_bta_scan_rsp_data_ptr, 0, sizeof(tBTA_BLE_ADV_DATA));
#endif ///BLE_INCLUDED == TRUE
#if GATTS_INCLUDED == TRUE && GATT_DYNAMIC_MEMORY == TRUE
if ((btc_creat_tab_env_ptr = (esp_btc_creat_tab_t *)osi_malloc(sizeof(esp_btc_creat_tab_t))) == NULL) {
return BT_STATUS_NOMEM;
goto error_exit;
}
memset((void *)btc_creat_tab_env_ptr, 0, sizeof(esp_btc_creat_tab_t));
if ((blufi_env_ptr = (tBLUFI_ENV *)osi_malloc(sizeof(tBLUFI_ENV))) == NULL) {
return BT_STATUS_NOMEM;
goto error_exit;
}
memset((void *)blufi_env_ptr, 0, sizeof(tBLUFI_ENV));
#endif
#if BTC_HF_CLIENT_INCLUDED == TRUE && HFP_DYNAMIC_MEMORY == TRUE
if ((hf_client_local_param_ptr = (hf_client_local_param_t *)osi_malloc(sizeof(hf_client_local_param_t))) == NULL) {
return BT_STATUS_NOMEM;
goto error_exit;
}
memset((void *)hf_client_local_param_ptr, 0, sizeof(hf_client_local_param_t));
#endif
#if BTC_AV_INCLUDED == TRUE && AVRC_DYNAMIC_MEMORY == TRUE
if ((btc_rc_vb_ptr = (btc_rc_cb_t *)osi_malloc(sizeof(btc_rc_cb_t))) == NULL) {
return BT_STATUS_NOMEM;
if ((btc_rc_cb_ptr = (btc_rc_cb_t *)osi_malloc(sizeof(btc_rc_cb_t))) == NULL) {
goto error_exit;
}
memset((void *)btc_rc_vb_ptr, 0, sizeof(btc_rc_cb_t));
memset((void *)btc_rc_cb_ptr, 0, sizeof(btc_rc_cb_t));
if ((bta_av_co_cb_ptr = (tBTA_AV_CO_CB *)osi_malloc(sizeof(tBTA_AV_CO_CB))) == NULL) {
return BT_STATUS_NOMEM;
goto error_exit;
}
memset((void *)bta_av_co_cb_ptr, 0, sizeof(tBTA_AV_CO_CB));
#endif
return BT_STATUS_SUCCESS;
error_exit:;
btc_deinit_mem();
return BT_STATUS_NOMEM;
}
static void btc_deinit_mem(void) {
osi_free(btc_dm_cb_ptr);
btc_dm_cb_ptr = NULL;
osi_free(btc_profile_cb_tab);
btc_profile_cb_tab = NULL;
osi_free(gl_bta_adv_data_ptr);
gl_bta_adv_data_ptr = NULL;
osi_free(gl_bta_scan_rsp_data_ptr);
gl_bta_scan_rsp_data_ptr = NULL;
#if GATTS_INCLUDED == TRUE && GATT_DYNAMIC_MEMORY == TRUE
osi_free(btc_creat_tab_env_ptr);
btc_creat_tab_env_ptr = NULL;
osi_free(blufi_env_ptr);
blufi_env_ptr = NULL;
#endif
#if BTC_HF_CLIENT_INCLUDED == TRUE && HFP_DYNAMIC_MEMORY == TRUE
osi_free(hf_client_local_param_ptr);
hf_client_local_param_ptr = NULL;
#endif
#if BTC_AV_INCLUDED == TRUE && AVRC_DYNAMIC_MEMORY == TRUE
osi_free(btc_rc_vb_ptr);
btc_rc_vb_ptr = NULL;
osi_free(bta_av_co_cb_ptr);
bta_av_co_cb_ptr = NULL;
#endif
}
#endif
#endif ///BTC_DYNAMIC_MENDRY
int btc_init(void)
{

2
components/bt/bluedroid/btc/profile/std/avrc/btc_avrc.c
View File

@ -1002,8 +1002,6 @@ static void btc_avrc_ct_init(void)
/// initialize CT-TG shared resources
if (s_rc_tg_init != BTC_RC_TG_INIT_MAGIC) {
memset (&btc_rc_cb, 0, sizeof(btc_rc_cb_t));
btc_rc_cb.rc_vol_label = MAX_LABEL;
btc_rc_cb.rc_volume = MAX_VOLUME;
}
}

2
components/bt/bluedroid/btc/profile/std/include/btc_avrc.h
View File

@ -98,7 +98,7 @@ typedef enum {
#define CHECK_ESP_RC_CONNECTED do { \
BTC_TRACE_DEBUG("## %s ##", __FUNCTION__); \
if (btc_rc_vb.rc_connected == FALSE) { \
if (btc_rc_cb.rc_connected == FALSE) { \
BTC_TRACE_WARNING("Function %s() called when RC is not connected", __FUNCTION__); \
return ESP_ERR_INVALID_STATE; \
} \

17
components/bt/bluedroid/common/include/common/bt_user_config.h
View File

@ -15,9 +15,6 @@
#ifndef __BT_USER_CONFIG_H__
#define __BT_USER_CONFIG_H__
/* All the configuration from SDK defined here */
#include "sdkconfig.h"
@ -86,6 +83,7 @@
#define UC_BT_SSP_ENABLED CONFIG_BT_SSP_ENABLED
#else
#define UC_BT_SSP_ENABLED FALSE
#endif
//BLE
#ifdef CONFIG_BT_BLE_ENABLED
@ -96,16 +94,16 @@
//GATTS
#ifdef CONFIG_BT_GATTS_ENABLE
#define UC_BT_GATTS_ENABLED CONFIG_BT_GATTS_ENABLE
#define UC_BT_GATTS_ENABLE CONFIG_BT_GATTS_ENABLE
#else
#define UC_BT_GATTS_ENABLED FALSE
#define UC_BT_GATTS_ENABLE FALSE
#endif
//GATTC
#ifdef CONFIG_BT_GATTC_ENABLE
#define UC_BT_GATTC_ENABLED CONFIG_BT_GATTC_ENABLE
#define UC_BT_GATTC_ENABLE CONFIG_BT_GATTC_ENABLE
#else
#define UC_BT_GATTC_ENABLED FALSE
#define UC_BT_GATTC_ENABLE FALSE
#endif
//GATTC CACHE
@ -117,9 +115,9 @@
//SMP
#ifdef CONFIG_BT_SMP_ENABLE
#define UC_BT_SMP_ENABLED CONFIG_BT_SMP_ENABLE
#define UC_BT_SMP_ENABLE CONFIG_BT_SMP_ENABLE
#else
#define UC_BT_SMP_ENABLED FALSE
#define UC_BT_SMP_ENABLE FALSE
#endif
//SMP_SLAVE_CON_PARAMS_UPD_ENABLE
@ -371,7 +369,6 @@
#define UC_BT_LOG_BLUFI_TRACE_LEVEL UC_TRACE_LEVEL_WARNING
#endif
#endif /* __BT_USER_CONFIG_H__ */

4
components/bt/bluedroid/device/controller.c
View File

@ -111,8 +111,8 @@ static void start_up(void)
#endif ///C2H_FLOW_CONTROL_INCLUDED == TRUE
#if (BLE_ADV_REPORT_FLOW_CONTROL == TRUE)
// Enable adv flow control
response = AWAIT_COMMAND(packet_factory->make_set_adv_report_flow_control(HCI_HOST_FLOW_CTRL_ADV_REPORT_ON, (uint16_t)BLE_ADV_REPORT_FLOW_CONTROL_NUM, (uint16_t)BLE_ADV_REPORT_DISCARD_THRSHOLD));
packet_parser->parse_generic_command_complete(response);
response = AWAIT_COMMAND(controller_param.packet_factory->make_set_adv_report_flow_control(HCI_HOST_FLOW_CTRL_ADV_REPORT_ON, (uint16_t)BLE_ADV_REPORT_FLOW_CONTROL_NUM, (uint16_t)BLE_ADV_REPORT_DISCARD_THRSHOLD));
controller_param.packet_parser->parse_generic_command_complete(response);
#endif
// Tell the controller about our buffer sizes and buffer counts next
// TODO(zachoverflow): factor this out. eww l2cap contamination. And why just a hardcoded 10?

440
components/bt/bluedroid/main/bte_init.c
View File

@ -143,168 +143,6 @@
** F U N C T I O N S *
******************************************************************************/
/*****************************************************************************
**
** Function BTE_InitStack
**
** Description Initialize control block memory for each component.
**
** Note: The core stack components must be called
** before creating the BTU Task. The rest of the
** components can be initialized at a later time if desired
** as long as the component's init function is called
** before accessing any of its functions.
**
** Returns void
**
******************************************************************************/
void BTE_InitStack(void)
{
#if (defined(RFCOMM_INCLUDED) && RFCOMM_INCLUDED == TRUE)
//Initialize the optional stack components
RFCOMM_Init();
#endif
//BNEP and its profiles
#if (defined(BNEP_INCLUDED) && BNEP_INCLUDED == TRUE)
BNEP_Init();
#if (defined(PAN_INCLUDED) && PAN_INCLUDED == TRUE)
PAN_Init();
#endif // PAN
#endif // BNEP Included
//AVDT and its profiles
#if (defined(A2D_INCLUDED) && A2D_INCLUDED == TRUE)
A2D_Init();
#endif // AADP
#if (defined(AVRC_INCLUDED) && AVRC_INCLUDED == TRUE)
AVRC_Init();
#endif
#if (defined(AVDT_INCLUDED) && AVDT_INCLUDED == TRUE && AVDT_DYNAMIC_MEMORY == TRUE)
if ((avdt_cb_ptr = (tAVDT_CB *)osi_malloc(sizeof(tAVDT_CB))) == NULL) {
return;
}
memset((void *)avdt_cb_ptr, 0, sizeof(tAVDT_CB));
#endif
#if (defined(AVCT_INCLUDED) && AVCT_INCLUDED == TRUE && AVCT_DYNAMIC_MEMORY == TRUE)
if ((avct_cb_ptr = (tAVCT_CB *)osi_malloc(sizeof(tAVCT_CB))) == NULL) {
return;
}
memset((void *)avct_cb_ptr, 0, sizeof(tAVCT_CB));
#endif
#if (defined(GAP_INCLUDED) && GAP_INCLUDED == TRUE)
GAP_Init();
#endif
#if (defined(HID_HOST_INCLUDED) && HID_HOST_INCLUDED == TRUE)
HID_HostInit();
#endif
#if (defined(MCA_INCLUDED) && MCA_INCLUDED == TRUE)
MCA_Init();
#endif
//BTA Modules
#if (BTA_INCLUDED == TRUE && BTA_DYNAMIC_MEMORY == TRUE)
if ((bta_sys_cb_ptr = (tBTA_SYS_CB *)osi_malloc(sizeof(tBTA_SYS_CB))) == NULL) {
return;
}
if ((bta_dm_cb_ptr = (tBTA_DM_CB *)osi_malloc(sizeof(tBTA_DM_CB))) == NULL) {
return;
}
if ((bta_dm_search_cb_ptr = (tBTA_DM_SEARCH_CB *)osi_malloc(sizeof(tBTA_DM_SEARCH_CB))) == NULL) {
return;
}
if ((bta_dm_di_cb_ptr = (tBTA_DM_DI_CB *)osi_malloc(sizeof(tBTA_DM_DI_CB))) == NULL) {
return;
}
if ((bta_dm_conn_srvcs_ptr = (tBTA_DM_CONNECTED_SRVCS *)osi_malloc(sizeof(tBTA_DM_CONNECTED_SRVCS))) == NULL) {
return;
}
memset((void *)bta_sys_cb_ptr, 0, sizeof(tBTA_SYS_CB));
memset((void *)bta_dm_cb_ptr, 0, sizeof(tBTA_DM_CB));
memset((void *)bta_dm_search_cb_ptr, 0, sizeof(tBTA_DM_SEARCH_CB));
memset((void *)bta_dm_di_cb_ptr, 0, sizeof(tBTA_DM_DI_CB));
memset((void *)bta_dm_conn_srvcs_ptr, 0, sizeof(tBTA_DM_CONNECTED_SRVCS));
//memset((void *)bta_prm_cb_ptr, 0, sizeof(tBTA_PRM_CB));
#if (defined BTA_HF_INCLUDED && BTA_HF_INCLUDED == TRUE)
if ((bta_hf_client_cb_ptr = (tBTA_HF_CLIENT_CB *)osi_malloc(sizeof(tBTA_HF_CLIENT_CB))) == NULL) {
return;
}
memset((void *)bta_hf_client_cb_ptr, 0, sizeof(tBTA_HF_CLIENT_CB));
#endif
#if (defined BTA_JV_INCLUDED && BTA_JV_INCLUDED == TRUE)
if ((bta_jv_cb_ptr = (tBTA_JV_CB *)osi_malloc(sizeof(tBTA_JV_CB))) == NULL) {
return;
}
memset((void *)bta_jv_cb_ptr, 0, sizeof(tBTA_JV_CB));
#endif //JV
#if BTA_HS_INCLUDED == TRUE
memset((void *)bta_hs_cb_ptr, 0, sizeof(tBTA_HS_CB));
#endif
#if BTA_SDP_INCLUDED == TRUE
if ((bta_sdp_cb_ptr = (tBTA_SDP_CB *)osi_malloc(sizeof(tBTA_SDP_CB))) == NULL) {
return;
}
memset((void *)bta_sdp_cb_ptr, 0, sizeof(tBTA_SDP_CB));
#endif
#if SDP_INCLUDED == TRUE
if ((g_disc_raw_data_buf = (UINT8 *)osi_malloc(MAX_DISC_RAW_DATA_BUF)) == NULL) {
return;
}
memset((void *)g_disc_raw_data_buf, 0, MAX_DISC_RAW_DATA_BUF);
#endif
#if BTA_AR_INCLUDED==TRUE
if ((bta_ar_cb_ptr = (tBTA_AR_CB *)osi_malloc(sizeof(tBTA_AR_CB))) == NULL) {
return;
}
memset((void *)bta_ar_cb_ptr, 0, sizeof(tBTA_AR_CB));
#endif
#if BTA_AV_INCLUDED==TRUE
if ((bta_av_cb_ptr = (tBTA_AV_CB *)osi_malloc(sizeof(tBTA_AV_CB))) == NULL) {
return;
}
memset((void *)bta_av_cb_ptr, 0, sizeof(tBTA_AV_CB));
if ((bta_av_sbc_ups_cb_ptr = (tBTA_AV_SBC_UPS_CB *)osi_malloc(sizeof(tBTA_AV_SBC_UPS_CB))) == NULL) {
return;
}
memset((void *)bta_av_sbc_ups_cb_ptr, 0, sizeof(tBTA_AV_SBC_UPS_CB));
#endif
#if BTA_HH_INCLUDED==TRUE
if ((bta_hh_cb_ptr = (tBTA_HH_CB *)osi_malloc(sizeof(tBTA_HH_CB))) == NULL) {
return;
}
memset((void *)bta_hh_cb_ptr, 0, sizeof(tBTA_HH_CB));
#endif
#if BTA_HL_INCLUDED==TRUE
memset((void *)bta_hl_cb_ptr, 0, sizeof(tBTA_HL_CB));
#endif
#if GATTC_INCLUDED==TRUE
if ((bta_gattc_cb_ptr = (tBTA_GATTC_CB *)osi_malloc(sizeof(tBTA_GATTC_CB))) == NULL) {
return;
}
memset((void *)bta_gattc_cb_ptr, 0, sizeof(tBTA_GATTC_CB));
#endif
#if GATTS_INCLUDED == TRUE
if ((bta_gatts_cb_ptr = (tBTA_GATTS_CB *)osi_malloc(sizeof(tBTA_GATTS_CB))) == NULL) {
return;
}
memset((void *)bta_gatts_cb_ptr, 0, sizeof(tBTA_GATTS_CB));
#endif
#if BTA_PAN_INCLUDED==TRUE
memset((void *)bta_pan_cb_ptr, 0, sizeof(tBTA_PAN_CB));
#endif
#endif // BTA_INCLUDED == TRUE
}
/*****************************************************************************
**
** Function BTE_DeinitStack
@ -322,53 +160,83 @@ void BTE_DeinitStack(void)
//BTA Modules
#if (BTA_INCLUDED == TRUE && BTA_DYNAMIC_MEMORY == TRUE)
#if GATTS_INCLUDED == TRUE
osi_free(bta_gatts_cb_ptr);
bta_gatts_cb_ptr = NULL;
if (bta_gatts_cb_ptr){
osi_free(bta_gatts_cb_ptr);
bta_gatts_cb_ptr = NULL;
}
#endif
#if GATTC_INCLUDED==TRUE
osi_free(bta_gattc_cb_ptr);
bta_gattc_cb_ptr = NULL;
if (bta_gattc_cb_ptr){
osi_free(bta_gattc_cb_ptr);
bta_gattc_cb_ptr = NULL;
}
#endif
#if BTA_HH_INCLUDED==TRUE
osi_free(bta_hh_cb_ptr);
bta_hh_cb_ptr = NULL;
if (bta_hh_cb_ptr){
osi_free(bta_hh_cb_ptr);
bta_hh_cb_ptr = NULL;
}
#endif
#if BTA_AV_INCLUDED==TRUE
osi_free(bta_av_cb_ptr);
bta_av_cb_ptr = NULL;
osi_free(bta_av_sbc_ups_cb_ptr);
bta_av_sbc_ups_cb_ptr = NULL;
if (bta_av_cb_ptr){
osi_free(bta_av_cb_ptr);
bta_av_cb_ptr = NULL;
}
if (bta_av_sbc_ups_cb_ptr){
osi_free(bta_av_sbc_ups_cb_ptr);
bta_av_sbc_ups_cb_ptr = NULL;
}
#endif
#if BTA_AR_INCLUDED==TRUE
osi_free(bta_ar_cb_ptr);
bta_ar_cb_ptr = NULL;
if (bta_ar_cb_ptr){
osi_free(bta_ar_cb_ptr);
bta_ar_cb_ptr = NULL;
}
#endif
#if SDP_INCLUDED == TRUE
osi_free(g_disc_raw_data_buf);
g_disc_raw_data_buf = NULL;
if (g_disc_raw_data_buf){
osi_free(g_disc_raw_data_buf);
g_disc_raw_data_buf = NULL;
}
#endif
#if BTA_SDP_INCLUDED == TRUE
osi_free(bta_sdp_cb_ptr);
bta_sdp_cb_ptr = NULL;
if (bta_sdp_cb_ptr){
osi_free(bta_sdp_cb_ptr);
bta_sdp_cb_ptr = NULL;
}
#endif
#if (defined BTA_JV_INCLUDED && BTA_JV_INCLUDED == TRUE)
osi_free(bta_jv_cb_ptr);
bta_jv_cb_ptr = NULL;
if (bta_jv_cb_ptr){
osi_free(bta_jv_cb_ptr);
bta_jv_cb_ptr = NULL;
}
#endif //JV
#if (defined BTA_HF_INCLUDED && BTA_HF_INCLUDED == TRUE)
osi_free(bta_hf_client_cb_ptr);
bta_hf_client_cb_ptr = NULL;
if (bta_hf_client_cb_ptr){
osi_free(bta_hf_client_cb_ptr);
bta_hf_client_cb_ptr = NULL;
}
#endif
osi_free(bta_dm_conn_srvcs_ptr);
bta_dm_conn_srvcs_ptr = NULL;
osi_free(bta_dm_di_cb_ptr);
bta_dm_di_cb_ptr = NULL;
osi_free(bta_dm_search_cb_ptr);
bta_dm_search_cb_ptr = NULL;
osi_free(bta_dm_cb_ptr);
bta_dm_cb_ptr = NULL;
osi_free(bta_sys_cb_ptr);
bta_sys_cb_ptr = NULL;
if (bta_dm_conn_srvcs_ptr){
osi_free(bta_dm_conn_srvcs_ptr);
bta_dm_conn_srvcs_ptr = NULL;
}
if (bta_dm_di_cb_ptr){
osi_free(bta_dm_di_cb_ptr);
bta_dm_di_cb_ptr = NULL;
}
if (bta_dm_search_cb_ptr){
osi_free(bta_dm_search_cb_ptr);
bta_dm_search_cb_ptr = NULL;
}
if (bta_dm_cb_ptr){
osi_free(bta_dm_cb_ptr);
bta_dm_cb_ptr = NULL;
}
if (bta_sys_cb_ptr){
osi_free(bta_sys_cb_ptr);
bta_sys_cb_ptr = NULL;
}
#endif // BTA_INCLUDED == TRUE
#if (defined(GAP_INCLUDED) && GAP_INCLUDED == TRUE)
@ -376,13 +244,17 @@ void BTE_DeinitStack(void)
#endif
#if (defined(AVCT_INCLUDED) && AVCT_INCLUDED == TRUE && AVCT_DYNAMIC_MEMORY == TRUE)
osi_free(avct_cb_ptr);
avct_cb_ptr = NULL;
if (avct_cb_ptr){
osi_free(avct_cb_ptr);
avct_cb_ptr = NULL;
}
#endif
#if (defined(AVDT_INCLUDED) && AVDT_INCLUDED == TRUE && AVDT_DYNAMIC_MEMORY == TRUE)
osi_free(avdt_cb_ptr);
avdt_cb_ptr = NULL;
if (avdt_cb_ptr){
osi_free(avdt_cb_ptr);
avdt_cb_ptr = NULL;
}
#endif
#if (defined(AVRC_INCLUDED) && AVRC_INCLUDED == TRUE)
@ -397,3 +269,179 @@ void BTE_DeinitStack(void)
RFCOMM_Deinit();
#endif
}
/*****************************************************************************
**
** Function BTE_InitStack
**
** Description Initialize control block memory for each component.
**
** Note: The core stack components must be called
** before creating the BTU Task. The rest of the
** components can be initialized at a later time if desired
** as long as the component's init function is called
** before accessing any of its functions.
**
** Returns status
**
******************************************************************************/
bt_status_t BTE_InitStack(void)
{
#if (defined(RFCOMM_INCLUDED) && RFCOMM_INCLUDED == TRUE)
//Initialize the optional stack components
if (RFCOMM_Init() != BT_STATUS_SUCCESS) {
goto error_exit;
}
#endif
//BNEP and its profiles
#if (defined(BNEP_INCLUDED) && BNEP_INCLUDED == TRUE)
BNEP_Init();
#if (defined(PAN_INCLUDED) && PAN_INCLUDED == TRUE)
PAN_Init();
#endif // PAN
#endif // BNEP Included
//AVDT and its profiles
#if (defined(A2D_INCLUDED) && A2D_INCLUDED == TRUE)
if (A2D_Init() != BT_STATUS_SUCCESS) {
goto error_exit;
}
#endif // AADP
#if (defined(AVRC_INCLUDED) && AVRC_INCLUDED == TRUE)
if (AVRC_Init() != BT_STATUS_SUCCESS) {
goto error_exit;
}
#endif
#if (defined(AVDT_INCLUDED) && AVDT_INCLUDED == TRUE && AVDT_DYNAMIC_MEMORY == TRUE)
if ((avdt_cb_ptr = (tAVDT_CB *)osi_malloc(sizeof(tAVDT_CB))) == NULL) {
goto error_exit;
}
memset((void *)avdt_cb_ptr, 0, sizeof(tAVDT_CB));
#endif
#if (defined(AVCT_INCLUDED) && AVCT_INCLUDED == TRUE && AVCT_DYNAMIC_MEMORY == TRUE)
if ((avct_cb_ptr = (tAVCT_CB *)osi_malloc(sizeof(tAVCT_CB))) == NULL) {
goto error_exit;
}
memset((void *)avct_cb_ptr, 0, sizeof(tAVCT_CB));
#endif
#if (defined(GAP_INCLUDED) && GAP_INCLUDED == TRUE)
if (GAP_Init() != BT_STATUS_SUCCESS) {
goto error_exit;
}
#endif
#if (defined(HID_HOST_INCLUDED) && HID_HOST_INCLUDED == TRUE)
HID_HostInit();
#endif
#if (defined(MCA_INCLUDED) && MCA_INCLUDED == TRUE)
MCA_Init();
#endif
//BTA Modules
#if (BTA_INCLUDED == TRUE && BTA_DYNAMIC_MEMORY == TRUE)
if ((bta_sys_cb_ptr = (tBTA_SYS_CB *)osi_malloc(sizeof(tBTA_SYS_CB))) == NULL) {
goto error_exit;
}
if ((bta_dm_cb_ptr = (tBTA_DM_CB *)osi_malloc(sizeof(tBTA_DM_CB))) == NULL) {
goto error_exit;
}
if ((bta_dm_search_cb_ptr = (tBTA_DM_SEARCH_CB *)osi_malloc(sizeof(tBTA_DM_SEARCH_CB))) == NULL) {
goto error_exit;
}
if ((bta_dm_di_cb_ptr = (tBTA_DM_DI_CB *)osi_malloc(sizeof(tBTA_DM_DI_CB))) == NULL) {
goto error_exit;
}
if ((bta_dm_conn_srvcs_ptr = (tBTA_DM_CONNECTED_SRVCS *)osi_malloc(sizeof(tBTA_DM_CONNECTED_SRVCS))) == NULL) {
goto error_exit;
}
memset((void *)bta_sys_cb_ptr, 0, sizeof(tBTA_SYS_CB));
memset((void *)bta_dm_cb_ptr, 0, sizeof(tBTA_DM_CB));
memset((void *)bta_dm_search_cb_ptr, 0, sizeof(tBTA_DM_SEARCH_CB));
memset((void *)bta_dm_di_cb_ptr, 0, sizeof(tBTA_DM_DI_CB));
memset((void *)bta_dm_conn_srvcs_ptr, 0, sizeof(tBTA_DM_CONNECTED_SRVCS));
//memset((void *)bta_prm_cb_ptr, 0, sizeof(tBTA_PRM_CB));
#if (defined BTA_HF_INCLUDED && BTA_HF_INCLUDED == TRUE)
if ((bta_hf_client_cb_ptr = (tBTA_HF_CLIENT_CB *)osi_malloc(sizeof(tBTA_HF_CLIENT_CB))) == NULL) {
goto error_exit;
}
memset((void *)bta_hf_client_cb_ptr, 0, sizeof(tBTA_HF_CLIENT_CB));
#endif
#if (defined BTA_JV_INCLUDED && BTA_JV_INCLUDED == TRUE)
if ((bta_jv_cb_ptr = (tBTA_JV_CB *)osi_malloc(sizeof(tBTA_JV_CB))) == NULL) {
goto error_exit;
}
memset((void *)bta_jv_cb_ptr, 0, sizeof(tBTA_JV_CB));
#endif //JV
#if BTA_HS_INCLUDED == TRUE
memset((void *)bta_hs_cb_ptr, 0, sizeof(tBTA_HS_CB));
#endif
#if BTA_SDP_INCLUDED == TRUE
if ((bta_sdp_cb_ptr = (tBTA_SDP_CB *)osi_malloc(sizeof(tBTA_SDP_CB))) == NULL) {
goto error_exit;
}
memset((void *)bta_sdp_cb_ptr, 0, sizeof(tBTA_SDP_CB));
#endif
#if SDP_INCLUDED == TRUE
if ((g_disc_raw_data_buf = (UINT8 *)osi_malloc(MAX_DISC_RAW_DATA_BUF)) == NULL) {
goto error_exit;
}
memset((void *)g_disc_raw_data_buf, 0, MAX_DISC_RAW_DATA_BUF);
#endif
#if BTA_AR_INCLUDED==TRUE
if ((bta_ar_cb_ptr = (tBTA_AR_CB *)osi_malloc(sizeof(tBTA_AR_CB))) == NULL) {
goto error_exit;
}
memset((void *)bta_ar_cb_ptr, 0, sizeof(tBTA_AR_CB));
#endif
#if BTA_AV_INCLUDED==TRUE
if ((bta_av_cb_ptr = (tBTA_AV_CB *)osi_malloc(sizeof(tBTA_AV_CB))) == NULL) {
goto error_exit;
}
memset((void *)bta_av_cb_ptr, 0, sizeof(tBTA_AV_CB));
if ((bta_av_sbc_ups_cb_ptr = (tBTA_AV_SBC_UPS_CB *)osi_malloc(sizeof(tBTA_AV_SBC_UPS_CB))) == NULL) {
goto error_exit;
}
memset((void *)bta_av_sbc_ups_cb_ptr, 0, sizeof(tBTA_AV_SBC_UPS_CB));
#endif
#if BTA_HH_INCLUDED==TRUE
if ((bta_hh_cb_ptr = (tBTA_HH_CB *)osi_malloc(sizeof(tBTA_HH_CB))) == NULL) {
goto error_exit;
}
memset((void *)bta_hh_cb_ptr, 0, sizeof(tBTA_HH_CB));
#endif
#if BTA_HL_INCLUDED==TRUE
memset((void *)bta_hl_cb_ptr, 0, sizeof(tBTA_HL_CB));
#endif
#if GATTC_INCLUDED==TRUE
if ((bta_gattc_cb_ptr = (tBTA_GATTC_CB *)osi_malloc(sizeof(tBTA_GATTC_CB))) == NULL) {
goto error_exit;
}
memset((void *)bta_gattc_cb_ptr, 0, sizeof(tBTA_GATTC_CB));
#endif
#if GATTS_INCLUDED == TRUE
if ((bta_gatts_cb_ptr = (tBTA_GATTS_CB *)osi_malloc(sizeof(tBTA_GATTS_CB))) == NULL) {
goto error_exit;
}
memset((void *)bta_gatts_cb_ptr, 0, sizeof(tBTA_GATTS_CB));
#endif
#if BTA_PAN_INCLUDED==TRUE
memset((void *)bta_pan_cb_ptr, 0, sizeof(tBTA_PAN_CB));
#endif
#endif // BTA_INCLUDED == TRUE
return BT_STATUS_SUCCESS;
error_exit:;
LOG_ERROR("%s failed due to no memory", __func__);
BTE_DeinitStack();
return BT_STATUS_NOMEM;
}

14
components/bt/bluedroid/stack/a2dp/a2d_api.c
View File

@ -372,13 +372,16 @@ UINT8 A2D_BitsSet(UINT8 num)
** other API functions for this layer. It is typically called
** once during the start up of the stack.
**
** Returns void
** Returns status
**
*******************************************************************************/
void A2D_Init(void)
bt_status_t A2D_Init(void)
{
#if (A2D_DYNAMIC_MEMORY)
a2d_cb_ptr = (tA2D_CB *)osi_malloc(sizeof(tA2D_CB));
if (!a2d_cb_ptr) {
return BT_STATUS_NOMEM;
}
#endif /* #if (A2D_DYNAMIC_MEMORY) */
memset(&a2d_cb, 0, sizeof(tA2D_CB));
@ -389,6 +392,7 @@ void A2D_Init(void)
#else
a2d_cb.trace_level = BT_TRACE_LEVEL_NONE;
#endif
return BT_STATUS_SUCCESS;
}
/*******************************************************************************
@ -404,8 +408,10 @@ void A2D_Init(void)
void A2D_Deinit(void)
{
#if (A2D_DYNAMIC_MEMORY)
osi_free(a2d_cb_ptr);
a2d_cb_ptr = NULL;
if (a2d_cb_ptr) {
osi_free(a2d_cb_ptr);
a2d_cb_ptr = NULL;
}
#endif /* #if (A2D_DYNAMIC_MEMORY) */
}

14
components/bt/bluedroid/stack/avrc/avrc_sdp.c
View File

@ -340,13 +340,16 @@ UINT8 AVRC_SetTraceLevel (UINT8 new_level)
** control block (if using dynamic memory), and initializes the
** control block and tracing level.
**
** Returns void
** Returns status
**
*******************************************************************************/
void AVRC_Init(void)
bt_status_t AVRC_Init(void)
{
#if AVRC_DYNAMIC_MEMORY
avrc_cb_ptr = (tAVRC_CB *)osi_malloc(sizeof(tAVRC_CB));
if (!avrc_cb_ptr) {
return BT_STATUS_NOMEM;
}
#endif /* #if AVRC_DYNAMIC_MEMORY */
memset(&avrc_cb, 0, sizeof(tAVRC_CB));
@ -355,6 +358,7 @@ void AVRC_Init(void)
#else
avrc_cb.trace_level = BT_TRACE_LEVEL_NONE;
#endif
return BT_STATUS_SUCCESS;
}
/*******************************************************************************
@ -371,8 +375,10 @@ void AVRC_Init(void)
void AVRC_Deinit(void)
{
#if AVRC_DYNAMIC_MEMORY
osi_free(avrc_cb_ptr);
avrc_cb_ptr = NULL;
if (avrc_cb_ptr){
osi_free(avrc_cb_ptr);
avrc_cb_ptr = NULL;
}
#endif /* #if AVRC_DYNAMIC_MEMORY */
}

8
components/bt/bluedroid/stack/btm/btm_ble_gap.c
View File

@ -246,7 +246,7 @@ uint8_t adv_param_status = 0;
uint8_t scan_enable_status = 0;
uint8_t scan_param_status = 0;
void btm_lock_init(void)
void btm_ble_lock_init(void)
{
osi_mutex_new(&adv_enable_lock);
osi_mutex_new(&adv_data_lock);
@ -255,7 +255,7 @@ void btm_lock_init(void)
osi_mutex_new(&scan_param_lock);
}
void btm_lock_free(void)
void btm_ble_lock_free(void)
{
osi_mutex_free(&adv_enable_lock);
osi_mutex_free(&adv_data_lock);
@ -264,7 +264,7 @@ void btm_lock_free(void)
osi_mutex_free(&scan_param_lock);
}
void btm_sem_init(void)
void btm_ble_sem_init(void)
{
osi_sem_new(&adv_enable_sem, 1, 0);
osi_sem_new(&adv_data_sem, 1, 0);
@ -273,7 +273,7 @@ void btm_sem_init(void)
osi_sem_new(&scan_param_sem, 1, 0);
}
void btm_sem_free(void)
void btm_ble_sem_free(void)
{
osi_sem_free(&adv_enable_sem);
osi_sem_free(&adv_data_sem);

2
components/bt/bluedroid/stack/btm/btm_devctl.c
View File

@ -693,6 +693,7 @@ tBTM_STATUS BTM_VendorSpecificCommand(UINT16 opcode, UINT8 param_len,
void btm_vsc_complete (UINT8 *p, UINT16 opcode, UINT16 evt_len,
tBTM_CMPL_CB *p_vsc_cplt_cback)
{
#if (BLE_INCLUDED == TRUE)
tBTM_BLE_CB *ble_cb = &btm_cb.ble_ctr_cb;
switch(opcode) {
case HCI_VENDOR_BLE_LONG_ADV_DATA:
@ -721,6 +722,7 @@ void btm_vsc_complete (UINT8 *p, UINT16 opcode, UINT16 evt_len,
vcs_cplt_params.p_param_buf = p;
(*p_vsc_cplt_cback)(&vcs_cplt_params); /* Call the VSC complete callback function */
}
#endif
}
/*******************************************************************************

12
components/bt/bluedroid/stack/btm/btm_main.c
View File

@ -75,8 +75,10 @@ void btm_init (void)
#endif
btm_dev_init(); /* Device Manager Structures & HCI_Reset */
btm_lock_init();
btm_sem_init();
#if BLE_INCLUDED == TRUE
btm_ble_lock_init();
btm_ble_sem_init();
#endif
}
@ -96,6 +98,8 @@ void btm_free(void)
#if BTM_DYNAMIC_MEMORY
FREE_AND_RESET(btm_cb_ptr);
#endif
btm_lock_free();
btm_sem_free();
#if BLE_INCLUDED == TRUE
btm_ble_lock_free();
btm_ble_sem_free();
#endif
}

8
components/bt/bluedroid/stack/btm/include/btm_int.h
View File

@ -1148,13 +1148,13 @@ void btm_acl_paging (BT_HDR *p, BD_ADDR dest);
UINT8 btm_sec_clr_service_by_psm (UINT16 psm);
void btm_sec_clr_temp_auth_service (BD_ADDR bda);
void btm_lock_init(void);
void btm_ble_lock_init(void);
void btm_sem_init(void);
void btm_ble_sem_init(void);
void btm_sem_free(void);
void btm_ble_sem_free(void);
void btm_lock_free(void);
void btm_ble_lock_free(void);
/*
#ifdef __cplusplus

11
components/bt/bluedroid/stack/btu/btu_init.c
View File

@ -66,7 +66,7 @@ osi_thread_t *btu_thread = NULL;
extern void PLATFORM_DisableHciTransport(UINT8 bDisable);
extern void btu_task_thread_handler(void *arg);
void btu_task_start_up(void);
void btu_task_start_up(void * param);
void btu_task_shut_down(void);
/*****************************************************************************
@ -197,6 +197,15 @@ error_exit:;
BTU_ShutDown();
}
/*****************************************************************************
**
** Function BTU_ShutDown
**
** Description Deinitializes the BTU control block.
**
** Returns void
**
******************************************************************************/
void BTU_ShutDown(void)
{
#if BTU_DYNAMIC_MEMORY

61
components/bt/bluedroid/stack/btu/btu_task.c
View File

@ -90,7 +90,7 @@ typedef struct {
//#include "bt_app_common.h"
//#endif
extern void BTE_InitStack(void);
extern bt_status_t BTE_InitStack(void);
extern void BTE_DeinitStack(void);
/* Define BTU storage area
@ -119,17 +119,19 @@ extern bluedroid_init_done_cb_t bluedroid_init_done_cb;
/* 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_hci_msg_process(BT_HDR *p_msg);
static void btu_l2cap_alarm_process(void *param);
static void btu_general_alarm_process(void *param);
static void btu_hci_msg_process(void *param);
#if (defined(BTA_INCLUDED) && BTA_INCLUDED == TRUE)
static void btu_bta_alarm_process(TIMER_LIST_ENT *p_tle);
static void btu_bta_alarm_process(void *param);
#endif
static void btu_hci_msg_process(BT_HDR *p_msg)
static void btu_hci_msg_process(void *param)
{
/* Determine the input message type. */
BT_HDR *p_msg = (BT_HDR *)param;
switch (p_msg->event & BT_EVT_MASK) {
case BTU_POST_TO_TASK_NO_GOOD_HORRIBLE_HACK: // TODO(zachoverflow): remove this
{
@ -196,8 +198,9 @@ static void btu_hci_msg_process(BT_HDR *p_msg)
}
#if (defined(BTA_INCLUDED) && BTA_INCLUDED == TRUE)
static void btu_bta_alarm_process(TIMER_LIST_ENT *p_tle)
static void btu_bta_alarm_process(void *param)
{
TIMER_LIST_ENT *p_tle = (TIMER_LIST_ENT *)param;
// call timer callback
if (p_tle->p_cback) {
(*p_tle->p_cback)(p_tle);
@ -213,56 +216,42 @@ static void btu_bta_alarm_process(TIMER_LIST_ENT *p_tle)
}
#endif
void btu_thread_handler(void *arg)
bool btu_task_post(uint32_t sig, void *param, uint32_t timeout)
{
btu_thread_evt_t *evt = (btu_thread_evt_t *)arg;
bool status = false;
switch (evt->sig) {
switch (sig) {
case SIG_BTU_START_UP:
btu_task_start_up();
status = osi_thread_post(btu_thread, btu_task_start_up, param, 0, timeout);
break;
case SIG_BTU_HCI_MSG:
btu_hci_msg_process((BT_HDR *)evt->param);
status = osi_thread_post(btu_thread, btu_hci_msg_process, param, 0, timeout);
break;
#if (defined(BTA_INCLUDED) && BTA_INCLUDED == TRUE)
case SIG_BTU_BTA_MSG:
bta_sys_event((BT_HDR *)evt->param);
status = osi_thread_post(btu_thread, bta_sys_event, param, 0, timeout);
break;
case SIG_BTU_BTA_ALARM:
btu_bta_alarm_process((TIMER_LIST_ENT *)evt->param);
status = osi_thread_post(btu_thread, btu_bta_alarm_process, param, 0, timeout);
break;
#endif
case SIG_BTU_GENERAL_ALARM:
case SIG_BTU_ONESHOT_ALARM:
btu_general_alarm_process((TIMER_LIST_ENT *)evt->param);
status = osi_thread_post(btu_thread, btu_general_alarm_process, param, 0, timeout);
break;
case SIG_BTU_L2CAP_ALARM:
btu_l2cap_alarm_process((TIMER_LIST_ENT *)evt->param);
status = osi_thread_post(btu_thread, btu_l2cap_alarm_process, param, 0, timeout);
break;
default:
break;
}
osi_free(evt);
return status;
}
bool btu_task_post(uint32_t sig, void *param, uint32_t timeout)
{
btu_thread_evt_t *evt;
evt = (btu_thread_evt_t *)osi_malloc(sizeof(btu_thread_evt_t));
if (evt == NULL) {
return false;
}
evt->sig = sig;
evt->param = param;
return osi_thread_post(btu_thread, btu_thread_handler, evt, 0, timeout);
}
void btu_task_start_up(void)
void btu_task_start_up(void *param)
{
UNUSED(param);
/* Initialize the mandatory core stack control blocks
(BTU, BTM, L2CAP, and SDP)
*/
@ -305,8 +294,9 @@ void btu_task_shut_down(void)
** Returns void
**
*******************************************************************************/
static void btu_general_alarm_process(TIMER_LIST_ENT *p_tle)
static void btu_general_alarm_process(void *param)
{
TIMER_LIST_ENT *p_tle = (TIMER_LIST_ENT *)param;
assert(p_tle != NULL);
switch (p_tle->event) {
@ -511,8 +501,9 @@ void btu_free_timer(TIMER_LIST_ENT *p_tle)
** Returns void
**
*******************************************************************************/
static void btu_l2cap_alarm_process(TIMER_LIST_ENT *p_tle)
static void btu_l2cap_alarm_process(void *param)
{
TIMER_LIST_ENT *p_tle = (TIMER_LIST_ENT *)param;
assert(p_tle != NULL);
switch (p_tle->event) {

15
components/bt/bluedroid/stack/gap/gap_api.c
View File

@ -57,13 +57,16 @@ UINT8 GAP_SetTraceLevel (UINT8 new_level)
** This routine should not be called except once per
** stack invocation.
**
** Returns Nothing
** Returns status
**
*******************************************************************************/
void GAP_Init(void)
bt_status_t GAP_Init(void)
{
#if GAP_DYNAMIC_MEMORY == TRUE
gap_cb_ptr = (tGAP_CB *)osi_malloc(sizeof(tGAP_CB));
if (!gap_cb_ptr) {
return BT_STATUS_NOMEM;
}
#endif
memset (&gap_cb, 0, sizeof (tGAP_CB));
@ -81,6 +84,8 @@ void GAP_Init(void)
#if BLE_INCLUDED == TRUE && GATTS_INCLUDED == TRUE
gap_attr_db_init();
#endif
return BT_STATUS_SUCCESS;
}
/*******************************************************************************
@ -96,7 +101,9 @@ void GAP_Init(void)
void GAP_Deinit(void)
{
#if GAP_DYNAMIC_MEMORY == TRUE
osi_free(gap_cb_ptr);
gap_cb_ptr = NULL;
if (gap_cb_ptr) {
osi_free(gap_cb_ptr);
gap_cb_ptr = NULL;
}
#endif
}

3
components/bt/bluedroid/stack/include/stack/a2d_api.h
View File

@ -23,6 +23,7 @@
******************************************************************************/
#ifndef A2D_API_H
#define A2D_API_H
#include "common/bt_defs.h"
#include "stack/sdp_api.h"
#if (A2D_INCLUDED == TRUE)
/*****************************************************************************
@ -250,7 +251,7 @@ extern UINT8 A2D_BitsSet(UINT8 num);
** Returns void
**
*******************************************************************************/
extern void A2D_Init(void);
extern bt_status_t A2D_Init(void);
extern void A2D_Deinit(void);
#endif ///A2D_INCLUDED
#endif /* A2D_API_H */

5
components/bt/bluedroid/stack/include/stack/avrc_api.h
View File

@ -24,6 +24,7 @@
#ifndef AVRC_API_H
#define AVRC_API_H
#include "common/bt_target.h"
#include "common/bt_defs.h"
#include "stack/avct_api.h"
#include "stack/sdp_api.h"
#include "stack/avrc_defs.h"
@ -549,10 +550,10 @@ extern UINT8 AVRC_SetTraceLevel (UINT8 new_level);
** control block (if using dynamic memory), and initializes the
** control block and tracing level.
**
** Returns void
** Returns status
**
*******************************************************************************/
extern void AVRC_Init(void);
extern bt_status_t AVRC_Init(void);
/*******************************************************************************
**

2
components/bt/bluedroid/stack/include/stack/btu.h
View File

@ -283,7 +283,7 @@ void btu_free_core(void);
void BTU_StartUp(void);
void BTU_ShutDown(void);
void btu_task_start_up(void);
void btu_task_start_up(void *param);
void btu_task_shut_down(void);
UINT16 BTU_BleAclPktSize(void);

4
components/bt/bluedroid/stack/include/stack/gap_api.h
View File

@ -320,10 +320,10 @@ extern UINT8 GAP_SetTraceLevel (UINT8 new_level);
** This routine should not be called except once per
** stack invocation.
**
** Returns Nothing
** Returns status
**
*******************************************************************************/
extern void GAP_Init(void);
extern bt_status_t GAP_Init(void);
/*******************************************************************************
**

3
components/bt/bluedroid/stack/include/stack/port_api.h
View File

@ -25,6 +25,7 @@
#define PORT_API_H
#include "common/bt_target.h"
#include "common/bt_defs.h"
/*****************************************************************************
** Constants and Types
@ -621,7 +622,7 @@ extern int PORT_Test (UINT16 handle, UINT8 *p_data, UINT16 len);
** Description This function is called to initialize RFCOMM layer
**
*******************************************************************************/
extern void RFCOMM_Init (void);
extern bt_status_t RFCOMM_Init (void);
/*******************************************************************************
**

14
components/bt/bluedroid/stack/rfcomm/port_api.c
View File

@ -1711,11 +1711,16 @@ int PORT_Test (UINT16 handle, UINT8 *p_data, UINT16 len)
**
** Description This function is called to initialize RFCOMM layer
**
** Returns status
**
*******************************************************************************/
void RFCOMM_Init (void)
bt_status_t RFCOMM_Init (void)
{
#if RFC_DYNAMIC_MEMORY == TRUE
rfc_cb_ptr = (tRFC_CB *)osi_malloc(sizeof(tRFC_CB));
if (rfc_cb_ptr == NULL) {
return BT_STATUS_NOMEM;
}
#endif /* #if (RFC_DYNAMIC_MEMORY) */
memset (&rfc_cb, 0, sizeof (tRFC_CB)); /* Init RFCOMM control block */
@ -1728,6 +1733,7 @@ void RFCOMM_Init (void)
#endif
rfcomm_l2cap_if_init ();
return BT_STATUS_SUCCESS;
}
/*******************************************************************************
@ -1743,8 +1749,10 @@ void RFCOMM_Init (void)
void RFCOMM_Deinit(void)
{
#if RFC_DYNAMIC_MEMORY == TRUE
osi_free(rfc_cb_ptr);
rfc_cb_ptr = NULL;
if (rfc_cb_ptr){
osi_free(rfc_cb_ptr);
rfc_cb_ptr = NULL;
}
#endif
}

9
components/bt/bluedroid/stack/smp/smp_utils.c
View File

@ -974,13 +974,14 @@ void smp_proc_pairing_cmpl(tSMP_CB *p_cb)
tSMP_EVT_DATA evt_data = {0};
tSMP_CALLBACK *p_callback = p_cb->p_callback;
BD_ADDR pairing_bda;
tBTM_SEC_DEV_REC *p_rec = btm_find_dev (p_cb->pairing_bda);
SMP_TRACE_DEBUG ("smp_proc_pairing_cmpl \n");
evt_data.cmplt.reason = p_cb->status;
evt_data.cmplt.smp_over_br = p_cb->smp_over_br;
evt_data.cmplt.auth_mode = 0;
#if (BLE_INCLUDED == TRUE)
tBTM_SEC_DEV_REC *p_rec = btm_find_dev (p_cb->pairing_bda);
if (p_cb->status == SMP_SUCCESS) {
evt_data.cmplt.sec_level = p_cb->sec_level;
if (p_cb->auth_mode) { // the first encryption
@ -992,6 +993,12 @@ void smp_proc_pairing_cmpl(tSMP_CB *p_cb)
evt_data.cmplt.auth_mode = p_rec->ble.auth_mode;
}
}
#else
if (p_cb->status == SMP_SUCCESS) {
evt_data.cmplt.sec_level = p_cb->sec_level;
evt_data.cmplt.auth_mode = p_cb->auth_mode;
}
#endif
evt_data.cmplt.is_pair_cancel = FALSE;