Crash_Override/OVMS3-idf
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Merge branch 'feature/btdm_prf_task' into feature/btdm_bluedroid

Browse source 
# Conflicts:
#	components/bt/bluedroid/profiles/core/bt_prf_sys_main.c
#	components/bt/bluedroid/profiles/core/bt_prf_task.c
#	components/bt/bluedroid/profiles/core/include/bt_prf_sys.h
#	components/bt/bluedroid/profiles/core/include/bt_prf_task.h
#	components/bt/bluedroid/profiles/esp/include/wx_airsync_prf.h
#	components/bt/bluedroid/profiles/esp/wechat_AirSync/wx_airsync_prf.c
#	components/bt/bluedroid/stack/btm/btm_sec.c
This commit is contained in:
Tian Hao 2016-11-04 19:32:47 +08:00
parent 4ea38327b6 b83b0ed06a
commit acda125e8b
57 changed files with 3833 additions and 632 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

74
components/bt/bluedroid/bta/dm/bta_dm_act.c
View file

@ -4295,10 +4295,10 @@ void bta_dm_set_encryption (tBTA_DM_MSG *p_data)
{ {
UINT8 i ; UINT8 i ;
APPL_TRACE_DEBUG("bta_dm_set_encryption"); //todo APPL_TRACE_DEBUG("bta_dm_set_encryption\n"); //todo
if (!p_data->set_encryption.p_callback) if (!p_data->set_encryption.p_callback)
{ {
APPL_TRACE_ERROR("bta_dm_set_encryption callback is not provided"); APPL_TRACE_ERROR("bta_dm_set_encryption callback is not provided\n");
return; return;
} }
for (i=0; i<bta_dm_cb.device_list.count; i++) for (i=0; i<bta_dm_cb.device_list.count; i++)
@ -4311,7 +4311,7 @@ void bta_dm_set_encryption (tBTA_DM_MSG *p_data)
{ {
if (bta_dm_cb.device_list.peer_device[i].p_encrypt_cback) if (bta_dm_cb.device_list.peer_device[i].p_encrypt_cback)
{ {
APPL_TRACE_ERROR("earlier enc was not done for same device"); APPL_TRACE_ERROR("earlier enc was not done for same device\n");
(*p_data->set_encryption.p_callback)(p_data->set_encryption.bd_addr, (*p_data->set_encryption.p_callback)(p_data->set_encryption.bd_addr,
p_data->set_encryption.transport, p_data->set_encryption.transport,
BTA_BUSY); BTA_BUSY);
@ -4738,6 +4738,27 @@ void bta_dm_ble_set_scan_params(tBTA_DM_MSG *p_data)
p_data->ble_set_scan_params.scan_param_setup_cback); p_data->ble_set_scan_params.scan_param_setup_cback);
} }
/*******************************************************************************
**
** Function bta_dm_ble_set_scan_fil_params
**
** Description This function sets BLE scan filter & parameters.
**
** Parameters:
**
*******************************************************************************/
void bta_dm_ble_set_scan_fil_params(tBTA_DM_MSG *p_data)
{
BTM_BleSetScanFilterParams (p_data->ble_set_scan_fil_params.client_if,
p_data->ble_set_scan_fil_params.scan_int,
p_data->ble_set_scan_fil_params.scan_window,
p_data->ble_set_scan_fil_params.scan_mode,
p_data->ble_set_scan_fil_params.addr_type_own,
p_data->ble_set_scan_fil_params.scan_filter_policy,
p_data->ble_set_scan_fil_params.scan_param_setup_cback);
}
/******************************************************************************* /*******************************************************************************
** **
** Function bta_dm_ble_set_conn_scan_params ** Function bta_dm_ble_set_conn_scan_params
@ -4800,6 +4821,27 @@ void bta_dm_ble_set_rand_address(tBTA_DM_MSG *p_data)
} }
/*******************************************************************************
**
** Function bta_dm_ble_stop_advertising
**
** Description This function stop the BLE avdertising for the device.
**
** Parameters: void
** Explanation: This function added by Yulong at 2016/10/19
*******************************************************************************/
void bta_dm_ble_stop_advertising(tBTA_DM_MSG *p_data)
{
if(p_data->hdr.event != BTA_DM_API_BLE_STOP_ADV_EVT)
{
APPL_TRACE_ERROR("Invalid BTA event,cann't stop the BLE adverting\n");
}
btm_ble_stop_adv();
}
#if BLE_PRIVACY_SPT == TRUE #if BLE_PRIVACY_SPT == TRUE
/******************************************************************************* /*******************************************************************************
** **
@ -4836,7 +4878,7 @@ void bta_dm_ble_observe (tBTA_DM_MSG *p_data)
bta_dm_observe_results_cb, bta_dm_observe_cmpl_cb))!= BTM_CMD_STARTED) bta_dm_observe_results_cb, bta_dm_observe_cmpl_cb))!= BTM_CMD_STARTED)
{ {
tBTA_DM_SEARCH data; tBTA_DM_SEARCH data;
APPL_TRACE_WARNING(" %s BTM_BleObserve failed. status %d",__FUNCTION__,status); APPL_TRACE_WARNING(" %s BTM_BleObserve failed. status %d\n",__FUNCTION__,status);
data.inq_cmpl.num_resps = 0; data.inq_cmpl.num_resps = 0;
if (bta_dm_search_cb.p_scan_cback) if (bta_dm_search_cb.p_scan_cback)
{ {
@ -4867,6 +4909,28 @@ void bta_dm_ble_set_adv_params (tBTA_DM_MSG *p_data)
BTA_DM_BLE_ADV_CHNL_MAP); BTA_DM_BLE_ADV_CHNL_MAP);
} }
/*******************************************************************************
**
** Function bta_dm_ble_set_adv_params_all
**
** Description This function is called to set all of the advertising parameters.
**
** Parameters: None.
**
** Returns void
**
*******************************************************************************/
void bta_dm_ble_set_adv_params_all (tBTA_DM_MSG *p_data)
{
BTM_BleSetAdvParamsStartAdv(p_data->ble_set_adv_params_all.adv_int_min,
p_data->ble_set_adv_params_all.adv_int_max,
p_data->ble_set_adv_params_all.adv_type,
p_data->ble_set_adv_params_all.addr_type_own,
p_data->ble_set_adv_params_all.p_dir_bda,
p_data->ble_set_adv_params_all.channel_map,
p_data->ble_set_adv_params_all.adv_filter_policy);
}
/******************************************************************************* /*******************************************************************************
** **
** Function bta_dm_ble_set_adv_config ** Function bta_dm_ble_set_adv_config
@ -4927,7 +4991,7 @@ void bta_dm_ble_set_data_length(tBTA_DM_MSG *p_data)
if (BTM_SetBleDataLength(p_data->ble_set_data_length.remote_bda, if (BTM_SetBleDataLength(p_data->ble_set_data_length.remote_bda,
p_data->ble_set_data_length.tx_data_length) != BTM_SUCCESS) p_data->ble_set_data_length.tx_data_length) != BTM_SUCCESS)
{ {
APPL_TRACE_ERROR("%s failed", __FUNCTION__); APPL_TRACE_ERROR("%s failed\n", __FUNCTION__);
} }
} }

128
components/bt/bluedroid/bta/dm/bta_dm_api.c
View file

@ -207,7 +207,7 @@ void BTA_DmSetVisibility(tBTA_DM_DISC disc_mode, tBTA_DM_CONN conn_mode, UINT8 p
tBTA_DM_API_SET_VISIBILITY *p_msg; tBTA_DM_API_SET_VISIBILITY *p_msg;
if ((p_msg = (tBTA_DM_API_SET_VISIBILITY *) GKI_getbuf(sizeof(tBTA_DM_MSG))) != NULL) if ((p_msg = (tBTA_DM_API_SET_VISIBILITY *) GKI_getbuf(sizeof(tBTA_DM_API_SET_VISIBILITY))) != NULL)
{ {
p_msg->hdr.event = BTA_DM_API_SET_VISIBILITY_EVT; p_msg->hdr.event = BTA_DM_API_SET_VISIBILITY_EVT;
p_msg->disc_mode = disc_mode; p_msg->disc_mode = disc_mode;
@ -690,7 +690,7 @@ void bta_dmexecutecallback (tBTA_DM_EXEC_CBACK* p_callback, void * p_param)
{ {
tBTA_DM_API_EXECUTE_CBACK *p_msg; tBTA_DM_API_EXECUTE_CBACK *p_msg;
if ((p_msg = (tBTA_DM_API_EXECUTE_CBACK *) GKI_getbuf(sizeof(tBTA_DM_MSG))) != NULL) if ((p_msg = (tBTA_DM_API_EXECUTE_CBACK *) GKI_getbuf(sizeof(tBTA_DM_API_EXECUTE_CBACK))) != NULL)
{ {
p_msg->hdr.event = BTA_DM_API_EXECUTE_CBACK_EVT; p_msg->hdr.event = BTA_DM_API_EXECUTE_CBACK_EVT;
p_msg->p_param= p_param; p_msg->p_param= p_param;
@ -860,6 +860,8 @@ void BTA_DmBleSecurityGrant(BD_ADDR bd_addr, tBTA_DM_BLE_SEC_GRANT res)
} }
#endif #endif
} }
/******************************************************************************* /*******************************************************************************
** **
** Function BTA_DmSetBlePrefConnParams ** Function BTA_DmSetBlePrefConnParams
@ -965,6 +967,44 @@ void BTA_DmSetBleScanParams(tGATT_IF client_if, UINT32 scan_interval,
} }
} }
/*******************************************************************************
**
** Function BTA_DmSetBleScanFilterParams
**
** Description This function is called to set scan parameters
**
** Parameters: client_if - Client IF
** scan_interval - scan interval
** scan_window - scan window
** scan_mode - scan mode
** scan_param_setup_status_cback - Set scan param status callback
**
** Returns void
**
*******************************************************************************/
void BTA_DmSetBleScanFilterParams(tGATT_IF client_if, UINT32 scan_interval,
UINT32 scan_window, tBLE_SCAN_MODE scan_mode, UINT8 scan_fil_poilcy,
UINT8 addr_type_own, tBLE_SCAN_PARAM_SETUP_CBACK scan_param_setup_cback)
{
tBTA_DM_API_BLE_SCAN_FILTER_PARAMS *p_msg;
if ((p_msg = (tBTA_DM_API_BLE_SCAN_FILTER_PARAMS *)GKI_getbuf(sizeof(tBTA_DM_API_BLE_SCAN_FILTER_PARAMS))) != NULL)
{
memset(p_msg, 0, sizeof(tBTA_DM_API_BLE_SCAN_FILTER_PARAMS));
p_msg->hdr.event = BTA_DM_API_BLE_SCAN_FIL_PARAM_EVT;
p_msg->client_if = client_if;
p_msg->scan_int = scan_interval;
p_msg->scan_window = scan_window;
p_msg->scan_mode = scan_mode;
p_msg->addr_type_own = addr_type_own;
p_msg->scan_filter_policy = scan_fil_poilcy;
p_msg->scan_param_setup_cback = scan_param_setup_cback;
}
}
/******************************************************************************* /*******************************************************************************
** **
** Function BTA_DmSetBleAdvParams ** Function BTA_DmSetBleAdvParams
@ -985,9 +1025,10 @@ void BTA_DmSetBleAdvParams (UINT16 adv_int_min, UINT16 adv_int_max,
APPL_TRACE_API ("BTA_DmSetBleAdvParam: %d, %d\n", adv_int_min, adv_int_max); APPL_TRACE_API ("BTA_DmSetBleAdvParam: %d, %d\n", adv_int_min, adv_int_max);
if ((p_msg = (tBTA_DM_API_BLE_ADV_PARAMS *) GKI_getbuf(sizeof(tBTA_DM_API_BLE_ADV_PARAMS))) != NULL) if ((p_msg = (tBTA_DM_API_BLE_ADV_PARAMS *) GKI_getbuf(sizeof(tBTA_DM_API_BLE_ADV_PARAMS)
+ sizeof(tBLE_BD_ADDR))) != NULL)
{ {
memset(p_msg, 0, sizeof(tBTA_DM_API_BLE_ADV_PARAMS)); memset(p_msg, 0, sizeof(tBTA_DM_API_BLE_ADV_PARAMS)+sizeof(tBLE_BD_ADDR));
p_msg->hdr.event = BTA_DM_API_BLE_ADV_PARAM_EVT; p_msg->hdr.event = BTA_DM_API_BLE_ADV_PARAM_EVT;
@ -1004,6 +1045,44 @@ void BTA_DmSetBleAdvParams (UINT16 adv_int_min, UINT16 adv_int_max,
} }
#endif #endif
} }
void BTA_DmSetBleAdvParamsAll (UINT16 adv_int_min, UINT16 adv_int_max,
UINT8 adv_type, tBLE_ADDR_TYPE addr_type_own,
tBTM_BLE_ADV_CHNL_MAP chnl_map, tBTM_BLE_AFP adv_fil_pol,
tBLE_BD_ADDR *p_dir_bda)
{
#if BLE_INCLUDED == TRUE
tBTA_DM_API_BLE_ADV_PARAMS_ALL *p_msg;
APPL_TRACE_ERROR ("BTA_DmSetBleAdvParamsAll: %d, %d\n", adv_int_min, adv_int_max);
APPL_TRACE_ERROR ("adv_type = %d, addr_type_own = %d, chnl_map = %d, adv_fil_pol = %d\n",
adv_type,addr_type_own,chnl_map,adv_fil_pol);
if ((p_msg = (tBTA_DM_API_BLE_ADV_PARAMS_ALL *) GKI_getbuf(sizeof(tBTA_DM_API_BLE_ADV_PARAMS_ALL)
+ sizeof(tBLE_BD_ADDR))) != NULL)
{
memset(p_msg, 0, sizeof(tBTA_DM_API_BLE_ADV_PARAMS_ALL));
p_msg->hdr.event = BTA_DM_API_BLE_ADV_PARAM_All_EVT;
p_msg->adv_int_min = adv_int_min;
p_msg->adv_int_max = adv_int_max;
p_msg->adv_type = adv_type;
p_msg->addr_type_own = addr_type_own;
p_msg->channel_map = chnl_map;
p_msg->adv_filter_policy = adv_fil_pol;
if (p_dir_bda != NULL)
{
p_msg->p_dir_bda = (tBLE_BD_ADDR *)(p_msg + 1);
memcpy(p_msg->p_dir_bda, p_dir_bda, sizeof(tBLE_BD_ADDR));
}
bta_sys_sendmsg(p_msg);
}
#endif
}
/******************************************************************************* /*******************************************************************************
** BLE ADV data management API ** BLE ADV data management API
********************************************************************************/ ********************************************************************************/
@ -1248,7 +1327,7 @@ extern void BTA_DmBleBroadcast (BOOLEAN start)
{ {
tBTA_DM_API_BLE_OBSERVE *p_msg; tBTA_DM_API_BLE_OBSERVE *p_msg;
APPL_TRACE_API("BTA_DmBleBroadcast: start = %d ", start); APPL_TRACE_API("BTA_DmBleBroadcast: start = %d \n", start);
if ((p_msg = (tBTA_DM_API_BLE_OBSERVE *) GKI_getbuf(sizeof(tBTA_DM_API_BLE_OBSERVE))) != NULL) if ((p_msg = (tBTA_DM_API_BLE_OBSERVE *) GKI_getbuf(sizeof(tBTA_DM_API_BLE_OBSERVE))) != NULL)
{ {
@ -1498,7 +1577,7 @@ void BTA_DmBleUpdateConnectionParam(BD_ADDR bd_addr, UINT16 min_int,
** **
*******************************************************************************/ *******************************************************************************/
void BTA_DmBleConfigLocalPrivacy(BOOLEAN privacy_enable) void BTA_DmBleConfigLocalPrivacy(BOOLEAN privacy_enable)
{ { ///This function used the irk to generate the resolve address
#if BLE_INCLUDED == TRUE && BLE_PRIVACY_SPT == TRUE #if BLE_INCLUDED == TRUE && BLE_PRIVACY_SPT == TRUE
tBTA_DM_API_LOCAL_PRIVACY *p_msg; tBTA_DM_API_LOCAL_PRIVACY *p_msg;
@ -1534,7 +1613,7 @@ void BTA_DmBleConfigLocalPrivacy(BOOLEAN privacy_enable)
void BTA_BleEnableAdvInstance (tBTA_BLE_ADV_PARAMS *p_params, void BTA_BleEnableAdvInstance (tBTA_BLE_ADV_PARAMS *p_params,
tBTA_BLE_MULTI_ADV_CBACK *p_cback, tBTA_BLE_MULTI_ADV_CBACK *p_cback,
void *p_ref) void *p_ref)
{ { ///This function just used for vendor debug
tBTA_DM_API_BLE_MULTI_ADV_ENB *p_msg; tBTA_DM_API_BLE_MULTI_ADV_ENB *p_msg;
UINT16 len = sizeof(tBTA_BLE_ADV_PARAMS) + sizeof(tBTA_DM_API_BLE_MULTI_ADV_ENB); UINT16 len = sizeof(tBTA_BLE_ADV_PARAMS) + sizeof(tBTA_DM_API_BLE_MULTI_ADV_ENB);
@ -1572,6 +1651,7 @@ void BTA_BleEnableAdvInstance (tBTA_BLE_ADV_PARAMS *p_params,
*******************************************************************************/ *******************************************************************************/
void BTA_BleUpdateAdvInstParam (UINT8 inst_id, tBTA_BLE_ADV_PARAMS *p_params) void BTA_BleUpdateAdvInstParam (UINT8 inst_id, tBTA_BLE_ADV_PARAMS *p_params)
{ {
///This function just used for vendor debug
tBTA_DM_API_BLE_MULTI_ADV_PARAM *p_msg; tBTA_DM_API_BLE_MULTI_ADV_PARAM *p_msg;
UINT16 len = sizeof(tBTA_BLE_ADV_PARAMS) + sizeof(tBTA_DM_API_BLE_MULTI_ADV_PARAM); UINT16 len = sizeof(tBTA_BLE_ADV_PARAMS) + sizeof(tBTA_DM_API_BLE_MULTI_ADV_PARAM);
@ -1608,7 +1688,7 @@ void BTA_BleUpdateAdvInstParam (UINT8 inst_id, tBTA_BLE_ADV_PARAMS *p_params)
void BTA_BleCfgAdvInstData (UINT8 inst_id, BOOLEAN is_scan_rsp, void BTA_BleCfgAdvInstData (UINT8 inst_id, BOOLEAN is_scan_rsp,
tBTA_BLE_AD_MASK data_mask, tBTA_BLE_AD_MASK data_mask,
tBTA_BLE_ADV_DATA *p_data) tBTA_BLE_ADV_DATA *p_data)
{ { ///This function just used for vendor debug
tBTA_DM_API_BLE_MULTI_ADV_DATA *p_msg; tBTA_DM_API_BLE_MULTI_ADV_DATA *p_msg;
UINT16 len = sizeof(tBTA_DM_API_BLE_MULTI_ADV_DATA) ; UINT16 len = sizeof(tBTA_DM_API_BLE_MULTI_ADV_DATA) ;
@ -1638,7 +1718,7 @@ void BTA_BleCfgAdvInstData (UINT8 inst_id, BOOLEAN is_scan_rsp,
** Returns BTA_SUCCESS if command started sucessfully; otherwise failure. ** Returns BTA_SUCCESS if command started sucessfully; otherwise failure.
** **
*******************************************************************************/ *******************************************************************************/
void BTA_BleDisableAdvInstance (UINT8 inst_id) void BTA_BleDisableAdvInstance (UINT8 inst_id) //this function just used for vendor debug
{ {
tBTA_DM_API_BLE_MULTI_ADV_DISABLE *p_msg; tBTA_DM_API_BLE_MULTI_ADV_DISABLE *p_msg;
@ -1893,7 +1973,7 @@ void BTA_DmEnableScanFilter(UINT8 action, tBTA_DM_BLE_PF_STATUS_CBACK *p_cmpl_cb
{ {
#if BLE_ANDROID_CONTROLLER_SCAN_FILTER == TRUE #if BLE_ANDROID_CONTROLLER_SCAN_FILTER == TRUE
tBTA_DM_API_ENABLE_SCAN_FILTER *p_msg; tBTA_DM_API_ENABLE_SCAN_FILTER *p_msg;
APPL_TRACE_API ("BTA_DmEnableScanFilter: %d", action); APPL_TRACE_API ("BTA_DmEnableScanFilter: %d\n", action);
UINT16 len = sizeof(tBTA_DM_API_ENABLE_SCAN_FILTER) + sizeof(tBLE_BD_ADDR); UINT16 len = sizeof(tBTA_DM_API_ENABLE_SCAN_FILTER) + sizeof(tBLE_BD_ADDR);
@ -1991,7 +2071,7 @@ void BTA_DmBleSetDataLength(BD_ADDR remote_device, UINT16 tx_data_length)
** p_callback - Pointer to callback function to indicat the ** p_callback - Pointer to callback function to indicat the
** link encryption status ** link encryption status
** sec_act - This is the security action to indicate ** sec_act - This is the security action to indicate
** what knid of BLE security level is required for ** what kind of BLE security level is required for
** the BLE link if the BLE is supported ** the BLE link if the BLE is supported
** Note: This parameter is ignored for the BR/EDR link ** Note: This parameter is ignored for the BR/EDR link
** or the BLE is not supported ** or the BLE is not supported
@ -2089,6 +2169,32 @@ extern void BTA_DmBleObserve(BOOLEAN start, UINT8 duration,
} }
} }
/*******************************************************************************
**
** Function BTA_DmBleStopAdvertising
**
** Description This function set the random address for the APP
**
** Parameters void
**
** Returns void
**
**
*******************************************************************************/
extern void BTA_DmBleStopAdvertising(void)
{
BT_HDR *p_msg;
APPL_TRACE_API("BTA_DmBleStopAdvertising\n");
if ((p_msg = (BT_HDR *) GKI_getbuf(sizeof(BT_HDR))) != NULL)
{
memset(p_msg, 0, sizeof(BT_HDR));
p_msg->event = BTA_DM_API_BLE_STOP_ADV_EVT;
bta_sys_sendmsg(p_msg);
}
}
/******************************************************************************* /*******************************************************************************
** **

42
components/bt/bluedroid/bta/dm/bta_dm_int.h
View file

@ -90,15 +90,25 @@ enum
BTA_DM_API_BLE_CONN_PARAM_EVT, BTA_DM_API_BLE_CONN_PARAM_EVT,
BTA_DM_API_BLE_CONN_SCAN_PARAM_EVT, BTA_DM_API_BLE_CONN_SCAN_PARAM_EVT,
BTA_DM_API_BLE_SCAN_PARAM_EVT, BTA_DM_API_BLE_SCAN_PARAM_EVT,
/*******This event added by Yulong at 2016/10/25 to
support the scan filter setting for the APP******/
BTA_DM_API_BLE_SCAN_FIL_PARAM_EVT,
BTA_DM_API_BLE_OBSERVE_EVT, BTA_DM_API_BLE_OBSERVE_EVT,
BTA_DM_API_UPDATE_CONN_PARAM_EVT, BTA_DM_API_UPDATE_CONN_PARAM_EVT,
/*******This event added by Yulong at 2016/9/9 to /*******This event added by Yulong at 2016/9/9 to
support the random address setting for the APP******/ support the random address setting for the APP******/
BTA_DM_API_SET_RAND_ADDR_EVT, BTA_DM_API_SET_RAND_ADDR_EVT,
/*******This event added by Yulong at 2016/10/19 to
support stop the ble advertising setting by the APP******/
BTA_DM_API_BLE_STOP_ADV_EVT,
#if BLE_PRIVACY_SPT == TRUE #if BLE_PRIVACY_SPT == TRUE
BTA_DM_API_LOCAL_PRIVACY_EVT, BTA_DM_API_LOCAL_PRIVACY_EVT,
#endif #endif
BTA_DM_API_BLE_ADV_PARAM_EVT, BTA_DM_API_BLE_ADV_PARAM_EVT,
/*******This event added by Yulong at 2016/10/20 to
support setting the ble advertising param by the APP******/
BTA_DM_API_BLE_ADV_PARAM_All_EVT,
BTA_DM_API_BLE_SET_ADV_CONFIG_EVT, BTA_DM_API_BLE_SET_ADV_CONFIG_EVT,
BTA_DM_API_BLE_SET_SCAN_RSP_EVT, BTA_DM_API_BLE_SET_SCAN_RSP_EVT,
BTA_DM_API_BLE_BROADCAST_EVT, BTA_DM_API_BLE_BROADCAST_EVT,
@ -469,6 +479,19 @@ typedef struct
tBLE_SCAN_PARAM_SETUP_CBACK scan_param_setup_cback; tBLE_SCAN_PARAM_SETUP_CBACK scan_param_setup_cback;
}tBTA_DM_API_BLE_SCAN_PARAMS; }tBTA_DM_API_BLE_SCAN_PARAMS;
typedef struct
{
BT_HDR hdr;
tBTA_GATTC_IF client_if;
UINT32 scan_int;
UINT32 scan_window;
tBLE_SCAN_MODE scan_mode;
UINT8 addr_type_own;
UINT8 scan_filter_policy;
tBLE_SCAN_PARAM_SETUP_CBACK scan_param_setup_cback;
}tBTA_DM_API_BLE_SCAN_FILTER_PARAMS;
/* set scan parameter for BLE connections */ /* set scan parameter for BLE connections */
typedef struct typedef struct
{ {
@ -511,6 +534,20 @@ typedef struct
tBLE_BD_ADDR *p_dir_bda; tBLE_BD_ADDR *p_dir_bda;
}tBTA_DM_API_BLE_ADV_PARAMS; }tBTA_DM_API_BLE_ADV_PARAMS;
/* set adv parameter for BLE advertising */
typedef struct
{
BT_HDR hdr;
UINT16 adv_int_min;
UINT16 adv_int_max;
UINT8 adv_type;
tBLE_ADDR_TYPE addr_type_own;
tBTM_BLE_ADV_CHNL_MAP channel_map;
tBTM_BLE_AFP adv_filter_policy;
tBLE_BD_ADDR *p_dir_bda;
}tBTA_DM_API_BLE_ADV_PARAMS_ALL;
typedef struct typedef struct
{ {
BT_HDR hdr; BT_HDR hdr;
@ -726,10 +763,12 @@ typedef union
tBTA_DM_API_BLE_CONN_PARAMS ble_set_conn_params; tBTA_DM_API_BLE_CONN_PARAMS ble_set_conn_params;
tBTA_DM_API_BLE_CONN_SCAN_PARAMS ble_set_conn_scan_params; tBTA_DM_API_BLE_CONN_SCAN_PARAMS ble_set_conn_scan_params;
tBTA_DM_API_BLE_SCAN_PARAMS ble_set_scan_params; tBTA_DM_API_BLE_SCAN_PARAMS ble_set_scan_params;
tBTA_DM_API_BLE_SCAN_FILTER_PARAMS ble_set_scan_fil_params;
tBTA_DM_API_BLE_OBSERVE ble_observe; tBTA_DM_API_BLE_OBSERVE ble_observe;
tBTA_DM_API_ENABLE_PRIVACY ble_remote_privacy; tBTA_DM_API_ENABLE_PRIVACY ble_remote_privacy;
tBTA_DM_API_LOCAL_PRIVACY ble_local_privacy; tBTA_DM_API_LOCAL_PRIVACY ble_local_privacy;
tBTA_DM_API_BLE_ADV_PARAMS ble_set_adv_params; tBTA_DM_API_BLE_ADV_PARAMS ble_set_adv_params;
tBTA_DM_API_BLE_ADV_PARAMS_ALL ble_set_adv_params_all;
tBTA_DM_API_SET_ADV_CONFIG ble_set_adv_data; tBTA_DM_API_SET_ADV_CONFIG ble_set_adv_data;
#if BLE_ANDROID_CONTROLLER_SCAN_FILTER == TRUE #if BLE_ANDROID_CONTROLLER_SCAN_FILTER == TRUE
tBTA_DM_API_SCAN_FILTER_PARAM_SETUP ble_scan_filt_param_setup; tBTA_DM_API_SCAN_FILTER_PARAM_SETUP ble_scan_filt_param_setup;
@ -1123,13 +1162,16 @@ extern void bta_dm_security_grant (tBTA_DM_MSG *p_data);
extern void bta_dm_ble_set_bg_conn_type (tBTA_DM_MSG *p_data); extern void bta_dm_ble_set_bg_conn_type (tBTA_DM_MSG *p_data);
extern void bta_dm_ble_set_conn_params (tBTA_DM_MSG *p_data); extern void bta_dm_ble_set_conn_params (tBTA_DM_MSG *p_data);
extern void bta_dm_ble_set_scan_params(tBTA_DM_MSG *p_data); extern void bta_dm_ble_set_scan_params(tBTA_DM_MSG *p_data);
extern void bta_dm_ble_set_scan_fil_params(tBTA_DM_MSG *p_data);
extern void bta_dm_ble_set_conn_scan_params (tBTA_DM_MSG *p_data); extern void bta_dm_ble_set_conn_scan_params (tBTA_DM_MSG *p_data);
extern void bta_dm_close_gatt_conn(tBTA_DM_MSG *p_data); extern void bta_dm_close_gatt_conn(tBTA_DM_MSG *p_data);
extern void bta_dm_ble_observe (tBTA_DM_MSG *p_data); extern void bta_dm_ble_observe (tBTA_DM_MSG *p_data);
extern void bta_dm_ble_update_conn_params (tBTA_DM_MSG *p_data); extern void bta_dm_ble_update_conn_params (tBTA_DM_MSG *p_data);
extern void bta_dm_ble_set_rand_address(tBTA_DM_MSG *p_data); extern void bta_dm_ble_set_rand_address(tBTA_DM_MSG *p_data);
extern void bta_dm_ble_stop_advertising(tBTA_DM_MSG *p_data);
extern void bta_dm_ble_config_local_privacy (tBTA_DM_MSG *p_data); extern void bta_dm_ble_config_local_privacy (tBTA_DM_MSG *p_data);
extern void bta_dm_ble_set_adv_params (tBTA_DM_MSG *p_data); extern void bta_dm_ble_set_adv_params (tBTA_DM_MSG *p_data);
extern void bta_dm_ble_set_adv_params_all (tBTA_DM_MSG *p_data);
extern void bta_dm_ble_set_adv_config (tBTA_DM_MSG *p_data); extern void bta_dm_ble_set_adv_config (tBTA_DM_MSG *p_data);
extern void bta_dm_ble_set_scan_rsp (tBTA_DM_MSG *p_data); extern void bta_dm_ble_set_scan_rsp (tBTA_DM_MSG *p_data);
extern void bta_dm_ble_broadcast (tBTA_DM_MSG *p_data); extern void bta_dm_ble_broadcast (tBTA_DM_MSG *p_data);

7
components/bt/bluedroid/bta/dm/bta_dm_main.c
View file

@ -87,15 +87,20 @@ const tBTA_DM_ACTION bta_dm_action[BTA_DM_MAX_EVT] =
bta_dm_ble_set_conn_params, /* BTA_DM_API_BLE_CONN_PARAM_EVT */ bta_dm_ble_set_conn_params, /* BTA_DM_API_BLE_CONN_PARAM_EVT */
bta_dm_ble_set_conn_scan_params, /* BTA_DM_API_BLE_CONN_SCAN_PARAM_EVT */ bta_dm_ble_set_conn_scan_params, /* BTA_DM_API_BLE_CONN_SCAN_PARAM_EVT */
bta_dm_ble_set_scan_params, /* BTA_DM_API_BLE_SCAN_PARAM_EVT */ bta_dm_ble_set_scan_params, /* BTA_DM_API_BLE_SCAN_PARAM_EVT */
bta_dm_ble_observe, bta_dm_ble_set_scan_fil_params, /* BTA_DM_API_BLE_SCAN_FIL_PARAM_EVT */
bta_dm_ble_observe, /* BTA_DM_API_BLE_OBSERVE_EVT*/
bta_dm_ble_update_conn_params, /* BTA_DM_API_UPDATE_CONN_PARAM_EVT */ bta_dm_ble_update_conn_params, /* BTA_DM_API_UPDATE_CONN_PARAM_EVT */
/*******This handler function added by Yulong at 2016/9/9 to /*******This handler function added by Yulong at 2016/9/9 to
support the random address setting for the APP******/ support the random address setting for the APP******/
bta_dm_ble_set_rand_address, /*BTA_DM_API_SET_RAND_ADDR_EVT*/ bta_dm_ble_set_rand_address, /*BTA_DM_API_SET_RAND_ADDR_EVT*/
/*******This handler function added by Yulong at 2016/10/19 to
support stop the ble advertising setting by the APP******/
bta_dm_ble_stop_advertising, /*BTA_DM_API_BLE_STOP_ADV_EVT*/
#if BLE_PRIVACY_SPT == TRUE #if BLE_PRIVACY_SPT == TRUE
bta_dm_ble_config_local_privacy, /* BTA_DM_API_LOCAL_PRIVACY_EVT */ bta_dm_ble_config_local_privacy, /* BTA_DM_API_LOCAL_PRIVACY_EVT */
#endif #endif
bta_dm_ble_set_adv_params, /* BTA_DM_API_BLE_ADV_PARAM_EVT */ bta_dm_ble_set_adv_params, /* BTA_DM_API_BLE_ADV_PARAM_EVT */
bta_dm_ble_set_adv_params_all, /* BTA_DM_API_BLE_ADV_PARAM_All_EVT */
bta_dm_ble_set_adv_config, /* BTA_DM_API_BLE_SET_ADV_CONFIG_EVT */ bta_dm_ble_set_adv_config, /* BTA_DM_API_BLE_SET_ADV_CONFIG_EVT */
bta_dm_ble_set_scan_rsp, /* BTA_DM_API_BLE_SET_SCAN_RSPT */ bta_dm_ble_set_scan_rsp, /* BTA_DM_API_BLE_SET_SCAN_RSPT */
bta_dm_ble_broadcast, /* BTA_DM_API_BLE_BROADCAST_EVT */ bta_dm_ble_broadcast, /* BTA_DM_API_BLE_BROADCAST_EVT */

1
components/bt/bluedroid/bta/gatt/bta_gattc_act.c
View file

@ -271,6 +271,7 @@ void bta_gattc_start_if(tBTA_GATTC_CB *p_cb, tBTA_GATTC_DATA *p_msg)
APPL_TRACE_ERROR("Unable to start app.: Unknown interface =%d",p_msg->int_start_if.client_if ); APPL_TRACE_ERROR("Unable to start app.: Unknown interface =%d",p_msg->int_start_if.client_if );
} }
} }
/******************************************************************************* /*******************************************************************************
** **
** Function bta_gattc_deregister ** Function bta_gattc_deregister

2
components/bt/bluedroid/bta/gatt/bta_gattc_api.c
View file

@ -60,7 +60,7 @@ void BTA_GATTC_Disable(void)
if (bta_sys_is_register(BTA_ID_GATTC) == FALSE) if (bta_sys_is_register(BTA_ID_GATTC) == FALSE)
{ {
APPL_TRACE_WARNING("GATTC Module not enabled/already disabled"); APPL_TRACE_WARNING("GATTC Module not enabled/already disabled\n");
return; return;
} }
if ((p_buf = (BT_HDR *) GKI_getbuf(sizeof(BT_HDR))) != NULL) if ((p_buf = (BT_HDR *) GKI_getbuf(sizeof(BT_HDR))) != NULL)

4
components/bt/bluedroid/bta/gatt/bta_gattc_main.c
View file

@ -364,7 +364,7 @@ BOOLEAN bta_gattc_hdl_event(BT_HDR *p_msg)
tBTA_GATTC_RCB *p_clreg; tBTA_GATTC_RCB *p_clreg;
BOOLEAN rt = TRUE; BOOLEAN rt = TRUE;
#if BTA_GATT_DEBUG == TRUE #if BTA_GATT_DEBUG == TRUE
APPL_TRACE_DEBUG("bta_gattc_hdl_event: Event [%s]", gattc_evt_code(p_msg->event)); APPL_TRACE_DEBUG("bta_gattc_hdl_event: Event [%s]\n", gattc_evt_code(p_msg->event));
#endif #endif
switch (p_msg->event) switch (p_msg->event)
{ {
@ -424,7 +424,7 @@ BOOLEAN bta_gattc_hdl_event(BT_HDR *p_msg)
} }
else else
{ {
APPL_TRACE_DEBUG("Ignore unknown conn ID: %d", p_msg->layer_specific); APPL_TRACE_DEBUG("Ignore unknown conn ID: %d\n", p_msg->layer_specific);
} }
break; break;

32
components/bt/bluedroid/bta/include/bta_api.h
View file

@ -921,7 +921,7 @@ typedef struct
} tBTA_DM_BOND_CANCEL_CMPL; } tBTA_DM_BOND_CANCEL_CMPL;
/* Union of all security callback structures */ /* Union of all security callback structures */
typedef union typedef union
{ {
tBTA_DM_ENABLE enable; /* BTA enabled */ tBTA_DM_ENABLE enable; /* BTA enabled */
tBTA_DM_PIN_REQ pin_req; /* PIN request. */ tBTA_DM_PIN_REQ pin_req; /* PIN request. */
@ -1901,6 +1901,27 @@ extern void BTA_DmSetBleScanParams(tGATT_IF client_if, UINT32 scan_interval,
UINT32 scan_window, tBLE_SCAN_MODE scan_mode, UINT32 scan_window, tBLE_SCAN_MODE scan_mode,
tBLE_SCAN_PARAM_SETUP_CBACK scan_param_setup_status_cback); tBLE_SCAN_PARAM_SETUP_CBACK scan_param_setup_status_cback);
/*******************************************************************************
**
** Function BTA_DmSetBleScanFilterParams
**
** Description This function is called to set scan parameters
**
** Parameters: client_if - Client IF
** scan_interval - scan interval
** scan_window - scan window
** scan_mode - scan mode
** scan_param_setup_status_cback - Set scan param status callback
**
** Returns void
**
*******************************************************************************/
extern void BTA_DmSetBleScanFilterParams(tGATT_IF client_if, UINT32 scan_interval,
UINT32 scan_window, tBLE_SCAN_MODE scan_mode, UINT8 scan_fil_poilcy,
UINT8 addr_type_own, tBLE_SCAN_PARAM_SETUP_CBACK scan_param_setup_cback);
/******************************************************************************* /*******************************************************************************
** **
** Function BTA_DmSetBleAdvParams ** Function BTA_DmSetBleAdvParams
@ -1918,6 +1939,13 @@ extern void BTA_DmSetBleScanParams(tGATT_IF client_if, UINT32 scan_interval,
*******************************************************************************/ *******************************************************************************/
extern void BTA_DmSetBleAdvParams (UINT16 adv_int_min, UINT16 adv_int_max, extern void BTA_DmSetBleAdvParams (UINT16 adv_int_min, UINT16 adv_int_max,
tBLE_BD_ADDR *p_dir_bda); tBLE_BD_ADDR *p_dir_bda);
extern void BTA_DmSetBleAdvParamsAll (UINT16 adv_int_min, UINT16 adv_int_max,
UINT8 adv_type, tBLE_ADDR_TYPE addr_type_own,
tBTM_BLE_ADV_CHNL_MAP chnl_map, tBTM_BLE_AFP adv_fil_pol,
tBLE_BD_ADDR *p_dir_bda);
/******************************************************************************* /*******************************************************************************
** **
** Function BTA_DmSearchExt ** Function BTA_DmSearchExt
@ -2023,6 +2051,8 @@ extern void BTA_DmSetEncryption(BD_ADDR bd_addr, tBTA_TRANSPORT transport,
extern void BTA_DmBleObserve(BOOLEAN start, UINT8 duration, extern void BTA_DmBleObserve(BOOLEAN start, UINT8 duration,
tBTA_DM_SEARCH_CBACK *p_results_cb); tBTA_DM_SEARCH_CBACK *p_results_cb);
extern void BTA_DmBleStopAdvertising(void);
extern void BTA_DmSetRandAddress(BD_ADDR rand_addr); extern void BTA_DmSetRandAddress(BD_ADDR rand_addr);
#endif #endif

2
components/bt/bluedroid/bta/include/bta_gatt_api.h
View file

@ -523,7 +523,7 @@ typedef tGATTS_RSP tBTA_GATTS_RSP;
typedef tGATT_EXEC_FLAG tBTA_GATT_EXEC_FLAG; typedef tGATT_EXEC_FLAG tBTA_GATT_EXEC_FLAG;
/* read request always based on UUID */ /* read request always based on UUID */
typedef tGATT_READ_REQ tTA_GBATT_READ_REQ; typedef tGATT_READ_REQ tBTA_GATT_READ_REQ;
/* write request data */ /* write request data */
typedef tGATT_WRITE_REQ tBTA_GATT_WRITE_REQ; typedef tGATT_WRITE_REQ tBTA_GATT_WRITE_REQ;

12
components/bt/bluedroid/bta/sys/bta_sys_main.c
View file

@ -318,7 +318,7 @@ void bta_sys_hw_error(tBTA_SYS_HW_MSG *p_sys_hw_msg)
UINT8 module_index; UINT8 module_index;
UNUSED(p_sys_hw_msg); UNUSED(p_sys_hw_msg);
APPL_TRACE_DEBUG("%s", __FUNCTION__); APPL_TRACE_DEBUG("%s\n", __FUNCTION__);
for (module_index = 0; module_index < BTA_SYS_MAX_HW_MODULES; module_index++) for (module_index = 0; module_index < BTA_SYS_MAX_HW_MODULES; module_index++)
{ {
@ -377,7 +377,7 @@ void bta_sys_hw_api_enable( tBTA_SYS_HW_MSG *p_sys_hw_msg )
bta_sys_cb.sys_hw_cback[p_sys_hw_msg->hw_module ]( BTA_SYS_HW_ON_EVT ); bta_sys_cb.sys_hw_cback[p_sys_hw_msg->hw_module ]( BTA_SYS_HW_ON_EVT );
} }
APPL_TRACE_EVENT ("bta_sys_hw_api_enable for %d, active modules 0x%04X", APPL_TRACE_EVENT ("bta_sys_hw_api_enable for %d, active modules 0x%04X\n",
p_sys_hw_msg->hw_module, bta_sys_cb.sys_hw_module_active); p_sys_hw_msg->hw_module, bta_sys_cb.sys_hw_module_active);
} }
@ -394,7 +394,7 @@ void bta_sys_hw_api_enable( tBTA_SYS_HW_MSG *p_sys_hw_msg )
*******************************************************************************/ *******************************************************************************/
void bta_sys_hw_api_disable(tBTA_SYS_HW_MSG *p_sys_hw_msg) void bta_sys_hw_api_disable(tBTA_SYS_HW_MSG *p_sys_hw_msg)
{ {
APPL_TRACE_DEBUG("bta_sys_hw_api_disable for %d, active modules: 0x%04X", APPL_TRACE_DEBUG("bta_sys_hw_api_disable for %d, active modules: 0x%04X\n",
p_sys_hw_msg->hw_module, bta_sys_cb.sys_hw_module_active ); p_sys_hw_msg->hw_module, bta_sys_cb.sys_hw_module_active );
/* make sure the related SW blocks were stopped */ /* make sure the related SW blocks were stopped */
@ -442,7 +442,7 @@ void bta_sys_hw_api_disable(tBTA_SYS_HW_MSG *p_sys_hw_msg)
*******************************************************************************/ *******************************************************************************/
void bta_sys_hw_evt_enabled(tBTA_SYS_HW_MSG *p_sys_hw_msg) void bta_sys_hw_evt_enabled(tBTA_SYS_HW_MSG *p_sys_hw_msg)
{ {
APPL_TRACE_EVENT("bta_sys_hw_evt_enabled for %i", p_sys_hw_msg->hw_module); APPL_TRACE_EVENT("bta_sys_hw_evt_enabled for %i\n", p_sys_hw_msg->hw_module);
BTM_DeviceReset( NULL ); BTM_DeviceReset( NULL );
} }
@ -461,7 +461,7 @@ void bta_sys_hw_evt_disabled(tBTA_SYS_HW_MSG *p_sys_hw_msg)
{ {
UINT8 hw_module_index; UINT8 hw_module_index;
APPL_TRACE_DEBUG("bta_sys_hw_evt_disabled - module 0x%X", p_sys_hw_msg->hw_module); APPL_TRACE_DEBUG("bta_sys_hw_evt_disabled - module 0x%X\n", p_sys_hw_msg->hw_module);
for (hw_module_index = 0; hw_module_index < BTA_SYS_MAX_HW_MODULES; hw_module_index++) for (hw_module_index = 0; hw_module_index < BTA_SYS_MAX_HW_MODULES; hw_module_index++)
{ {
@ -485,7 +485,7 @@ void bta_sys_hw_evt_stack_enabled(tBTA_SYS_HW_MSG *p_sys_hw_msg)
UINT8 hw_module_index; UINT8 hw_module_index;
UNUSED(p_sys_hw_msg); UNUSED(p_sys_hw_msg);
APPL_TRACE_DEBUG(" bta_sys_hw_evt_stack_enabled!notify the callers"); APPL_TRACE_DEBUG(" bta_sys_hw_evt_stack_enabled!notify the callers\n");
for (hw_module_index = 0; hw_module_index < BTA_SYS_MAX_HW_MODULES; hw_module_index++ ) for (hw_module_index = 0; hw_module_index < BTA_SYS_MAX_HW_MODULES; hw_module_index++ )
{ {

32
components/bt/bluedroid/include/bt_target.h
View file

@ -40,6 +40,11 @@
#include "gki_target.h" #include "gki_target.h"
#include "dyn_mem.h" /* defines static and/or dynamic memory for components */ #include "dyn_mem.h" /* defines static and/or dynamic memory for components */
#ifndef CLASSIC_BT_INCLUDED
#define CLASSIC_BT_INCLUDED TRUE
#endif ///CLASSIC_BT_INCLUDED
//------------------Added from bdroid_buildcfg.h--------------------- //------------------Added from bdroid_buildcfg.h---------------------
#ifndef L2CAP_EXTFEA_SUPPORTED_MASK #ifndef L2CAP_EXTFEA_SUPPORTED_MASK
#define L2CAP_EXTFEA_SUPPORTED_MASK (L2CAP_EXTFEA_ENH_RETRANS | L2CAP_EXTFEA_STREAM_MODE | L2CAP_EXTFEA_NO_CRC | L2CAP_EXTFEA_FIXED_CHNLS) #define L2CAP_EXTFEA_SUPPORTED_MASK (L2CAP_EXTFEA_ENH_RETRANS | L2CAP_EXTFEA_STREAM_MODE | L2CAP_EXTFEA_NO_CRC | L2CAP_EXTFEA_FIXED_CHNLS)
@ -895,6 +900,33 @@
#define GATT_MAX_BG_CONN_DEV 8 /*MAX is 32*/ #define GATT_MAX_BG_CONN_DEV 8 /*MAX is 32*/
#endif #endif
/******************************************************************************
**
** GATT
**
******************************************************************************/
#ifndef GATTC_INCLUDED
#if BLE_INCLUDED == TRUE
#define GATTC_INCLUDED TRUE
#else
#define GATTC_INCLUDED FALSE
#endif
#endif
#ifndef GATTS_INCLUDED
#if BLE_INCLUDED == TRUE
#define GATTS_INCLUDED TRUE
#else
#define GATTS_INCLUDED FALSE
#endif
#endif
#if SMP_INCLUDED == TRUE && BLE_INCLUDED == FALSE
#error "can't have SMP without BLE"
#endif
/****************************************************************************** /******************************************************************************
** **
** SMP ** SMP

20
components/bt/bluedroid/profiles/core/bt_prf_sys_main.c
View file

@ -17,6 +17,7 @@
#include "fixed_queue.h" #include "fixed_queue.h"
#include "bt_prf_task.h" #include "bt_prf_task.h"
#include "gki.h" #include "gki.h"
#include "bt_trace.h"
#include <string.h> #include <string.h>
@ -34,7 +35,9 @@ static const tBT_PRF_SYS_REG bt_prf_sys_reg =
void bt_prf_sys_init(void) void bt_prf_sys_init(void)
{ {
memset(&bt_prf_sys_cb,0,sizeof(tBT_PRF_SYS_CB)); LOG_ERROR("bt_prf_sys_init\n");
memset(&bt_prf_sys_cb, 0, sizeof(tBT_PRF_SYS_CB));
bt_prf_StartUp();
} }
@ -48,12 +51,12 @@ void bt_prf_sys_init(void)
** Returns void ** Returns void
** **
*******************************************************************************/ *******************************************************************************/
void bt_prf_sys_event(BT_HDR *p_msg) void bt_prf_sys_event(prf_hdr_evt_t *p_msg)
{ {
UINT8 id; UINT8 id;
BOOLEAN freebuf = TRUE; BOOLEAN freebuf = TRUE;
APPL_TRACE_EVENT("profile task got event 0x%x\n", p_msg->event); LOG_ERROR("profile task got event 0x%x\n", p_msg->event);
/* get subsystem id from event */ /* get subsystem id from event */
id = (UINT8) (p_msg->event >> 8); id = (UINT8) (p_msg->event >> 8);
@ -65,7 +68,7 @@ void bt_prf_sys_event(BT_HDR *p_msg)
} }
else else
{ {
APPL_TRACE_WARNING("profile task got unregistered event id %d\n", id); LOG_ERROR("profile task got unregistered event id %d\n", id);
} }
if (freebuf) if (freebuf)
@ -107,6 +110,7 @@ void bt_prf_sys_register(UINT8 id, const tBT_PRF_SYS_REG *p_reg)
*******************************************************************************/ *******************************************************************************/
void bt_prf_sys_deregister(UINT8 id) void bt_prf_sys_deregister(UINT8 id)
{ {
bt_prf_sys_cb.reg[id] = NULL;
bt_prf_sys_cb.is_reg[id] = FALSE; bt_prf_sys_cb.is_reg[id] = FALSE;
} }
@ -130,7 +134,7 @@ BOOLEAN bt_prf_sys_is_register(UINT8 id)
** **
** Function bt_prf_sys_sendmsg ** Function bt_prf_sys_sendmsg
** **
** Description Send a GKI message to the profile task. ** Description Send a message to the profile task.
** **
** **
** Returns void ** Returns void
@ -140,7 +144,7 @@ void bt_prf_sys_sendmsg(void *p_msg)
{ {
// There is a race condition that occurs if the stack is shut down while // There is a race condition that occurs if the stack is shut down while
// there is a procedure in progress that can schedule a task via this // 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 // message queue. This causes |bt_profile_msg_queue| to get cleaned up before
// it gets used here; hence we check for NULL before using it. // it gets used here; hence we check for NULL before using it.
if (bt_profile_msg_queue) { if (bt_profile_msg_queue) {
fixed_queue_enqueue(bt_profile_msg_queue, p_msg); fixed_queue_enqueue(bt_profile_msg_queue, p_msg);
@ -148,7 +152,3 @@ void bt_prf_sys_sendmsg(void *p_msg)
bt_prf_task_post(SIG_PRF_WORK); bt_prf_task_post(SIG_PRF_WORK);
} }
} }

22
components/bt/bluedroid/profiles/core/bt_prf_task.c
View file

@ -15,6 +15,7 @@
#include "bt_prf_task.h" #include "bt_prf_task.h"
#include "bt_prf_sys.h" #include "bt_prf_sys.h"
#include "allocator.h" #include "allocator.h"
#include "bt_trace.h"
#include "thread.h" #include "thread.h"
#include "gki.h" #include "gki.h"
@ -35,17 +36,16 @@
******************************************************************************/ ******************************************************************************/
void bt_prf_task_thread_handler(void *arg) void bt_prf_task_thread_handler(void *arg)
{ {
//ke_event_clear(KE_EVENT_BTU_TASK_THREAD);
BtTaskEvt_t *e; BtTaskEvt_t *e;
for (;;) { for (;;) {
if (pdTRUE == xQueueReceive(xProfileQueue, &e, (portTickType)portMAX_DELAY)) { if (pdTRUE == xQueueReceive(xProfileQueue, &e, (portTickType)portMAX_DELAY)) {
if (e->sig == SIG_BTU_WORK) { if (e->sig == SIG_PRF_WORK) {
fixed_queue_process(bt_profile_msg_queue); fixed_queue_process(bt_profile_msg_queue);
LOG_ERROR("bt_prf_task_thread_handler\n");
} }
else if (e->sig == SIG_BTU_START_UP) { else if (e->sig == SIG_PRF_START_UP) {
bt_prf_task_start_up(); bt_prf_task_start_up();
} }
osi_free(e); osi_free(e);
@ -68,10 +68,10 @@
} }
void bt_profile_msg_ready(fixed_queue_t *queue) { void bt_profile_msg_ready(fixed_queue_t *queue) {
BT_HDR *p_msg; prf_hdr_evt_t *p_msg;
while (!fixed_queue_is_empty(queue)) { while (!fixed_queue_is_empty(queue)) {
p_msg = (BT_HDR *)fixed_queue_dequeue(queue); p_msg = (prf_hdr_evt_t *)fixed_queue_dequeue(queue);
if(p_msg != NULL) if(p_msg != NULL)
{ {
bt_prf_sys_event(p_msg); bt_prf_sys_event(p_msg);
@ -82,6 +82,7 @@ void bt_profile_msg_ready(fixed_queue_t *queue) {
void bt_prf_task_start_up(void) void bt_prf_task_start_up(void)
{ {
LOG_ERROR("bt_prf_task_start_up\n");
fixed_queue_register_dequeue(bt_profile_msg_queue, bt_profile_msg_ready); fixed_queue_register_dequeue(bt_profile_msg_queue, bt_profile_msg_ready);
} }
@ -98,10 +99,13 @@ void bt_prf_StartUp(void)
bt_profile_msg_queue = fixed_queue_new(SIZE_MAX); bt_profile_msg_queue = fixed_queue_new(SIZE_MAX);
if (bt_profile_msg_queue == NULL) if (bt_profile_msg_queue == NULL)
goto error_exit; goto error_exit;
xProfileQueue = xQueueCreate(60, sizeof(void *));
xTaskCreate(bt_prf_task_thread_handler, "Bt_prf", 4096, NULL, configMAX_PRIORITIES - 1, &xProfileTaskHandle);
bt_prf_task_post(SIG_PRF_START_UP);
return; return;
error_exit:; error_exit:
LOG_ERROR("%s Unable to allocate resources for bt_workqueue\n", __func__); LOG_ERROR("%s Unable to allocate resources for bt_workqueue\n", __func__);
bt_prf_ShutDown(); bt_prf_ShutDown();

18
components/bt/bluedroid/profiles/core/include/bt_prf_sys.h
View file

@ -16,6 +16,7 @@
#define _PROFILE_SYS_H__ #define _PROFILE_SYS_H__
#include "bt_types.h" #include "bt_types.h"
#include "prf_defs.h"
enum enum
{ {
@ -38,7 +39,7 @@ typedef UINT8 tBT_PRF_SYS_CONN_STATUS;
/* disable function type */ /* disable function type */
typedef void (tBT_PRF_SYS_DISABLE)(void); typedef void (tBT_PRF_SYS_DISABLE)(void);
/* event handler function type */ /* event handler function type */
typedef BOOLEAN (tBT_PRF_SYS_EVT_HDLR)(BT_HDR *p_msg); typedef BOOLEAN (tBT_PRF_SYS_EVT_HDLR)(prf_hdr_evt_t *p_msg);
/* conn callback for role / low power manager*/ /* conn callback for role / low power manager*/
typedef void (tBT_PRF_SYS_CONN_CBACK)(tBT_PRF_SYS_CONN_STATUS status, typedef void (tBT_PRF_SYS_CONN_CBACK)(tBT_PRF_SYS_CONN_STATUS status,
@ -73,14 +74,17 @@ extern tBT_PRF_SYS_CB bt_prf_sys_cb;
extern void bt_prf_sys_init(void); extern void bt_prf_sys_init(void);
extern void bt_prf_sys_free(void); extern void bt_prf_sys_free(void);
extern void bt_prf_sys_event(BT_HDR *p_msg); extern void bt_prf_sys_event(prf_hdr_evt_t *p_msg);
extern void bt_prf_sys_register(UINT8 id, const tBT_PRF_SYS_REG *p_reg); extern void bt_prf_sys_sendmsg(void *p_msg);
extern void bt_prf_sys_deregister(UINT8 id);
extern BOOLEAN bt_prf_sys_is_register(UINT8 id);
extern void bt_prf_sys_idle(UINT8 id, UINT8 app_id, BD_ADDR peer_addr);
extern void bt_prf_sys_busy(UINT8 id, UINT8 app_id, BD_ADDR peer_addr); extern void bt_prf_sys_register(uint8_t id, const tBT_PRF_SYS_REG *p_reg);
extern void bt_prf_sys_deregister(uint8_t id);
extern BOOLEAN bt_prf_sys_is_register(uint8_t id);
extern void bt_prf_sys_idle(uint8_t id, uint8_t app_id, BD_ADDR peer_addr);
extern void bt_prf_sys_busy(uint8_t id, uint8_t app_id, BD_ADDR peer_addr);
#endif ///_PROFILE_SYS_H__ #endif ///_PROFILE_SYS_H__

44
components/bt/bluedroid/profiles/core/include/bt_prf_task.h
View file

@ -1,25 +1,25 @@
/** /**
**************************************************************************************** ****************************************************************************************
* *
* @file bt_prf_task.h * @file bt_prf_task.h
* *
* @brief Application entry point * @brief Application entry point
* *
* Copyright (C) Espressif 2016 * Copyright (C) Espressif 2016
* Created by Yulong at 2016/10/11 * Created by Yulong at 2016/10/11
* *
* *
**************************************************************************************** ****************************************************************************************
*/ */
#include <stddef.h> #include <stddef.h>
#include "bt_defs.h" #include "bt_defs.h"
#include "fixed_queue.h" #include "fixed_queue.h"
#ifndef BT_PRF_TASK_H__ #ifndef BT_PRF_TASK_H__
#define BT_PRF_TASK_H__ #define BT_PRF_TASK_H__
/* Functions provided by btu_core.c /* Functions provided by bt_prf_task.c
************************************ ************************************
*/ */

142
components/bt/bluedroid/profiles/esp/ble_button/button_pro.c
View file

@ -35,14 +35,15 @@
#define ARRAY_SIZE(x) (sizeof(x)/sizeof((x)[0])) #define ARRAY_SIZE(x) (sizeof(x)/sizeof((x)[0]))
tBUTTON_CB_ENV button_cb_env; button_env_cb_t button_cb_env;
/***************************************************************************** /*****************************************************************************
** Constants ** Constants
*****************************************************************************/ *****************************************************************************/
static void button_profile_cb(tBTA_GATTS_EVT event, tBTA_GATTS *p_data); static void button_profile_cb(esp_gatts_evt_t event, esp_gatts_t *p_data);
/******************************************************************************* /*******************************************************************************
@ -54,14 +55,14 @@ static void button_profile_cb(tBTA_GATTS_EVT event, tBTA_GATTS *p_data);
** Returns NULL ** Returns NULL
** **
*******************************************************************************/ *******************************************************************************/
static void button_profile_cb(tBTA_GATTS_EVT event, tBTA_GATTS *p_data) static void button_profile_cb(esp_gatts_evt_t event, esp_gatts_t *p_data)
{ {
tBTA_GATTS_RSP rsp; esp_gatts_rsp_t rsp;
tBT_UUID uuid = {LEN_UUID_16, {ATT_SVC_BUTTON}}; esp_bt_uuid_t uuid = {LEN_UUID_16, {ATT_SVC_BUTTON}};
tBUT_INST *p_inst = &button_cb_env.button_inst; but_inst_t *p_inst = &button_cb_env.button_inst;
UINT8 net_event = 0xff; uint8_t net_event = 0xff;
UINT8 len = 0; uint8_t len = 0;
UINT8 *p_rec_data = NULL; uint8_t *p_rec_data = NULL;
//LOG_ERROR("p_data->status = %x\n",p_data->status); //LOG_ERROR("p_data->status = %x\n",p_data->status);
//if(p_data->status != BTA_GATT_OK){ //if(p_data->status != BTA_GATT_OK){
// LOG_ERROR("button profile register failed\n"); // LOG_ERROR("button profile register failed\n");
@ -70,7 +71,7 @@ static void button_profile_cb(tBTA_GATTS_EVT event, tBTA_GATTS *p_data)
LOG_ERROR("button profile cb event = %x\n",event); LOG_ERROR("button profile cb event = %x\n",event);
switch(event) switch(event)
{ {
case BTA_GATTS_REG_EVT: case ESP_GATTS_REG_EVT:
LOG_ERROR("p_data->reg_oper.status = %x\n",p_data->reg_oper.status); LOG_ERROR("p_data->reg_oper.status = %x\n",p_data->reg_oper.status);
LOG_ERROR("(p_data->reg_oper.uuid.uu.uuid16=%x\n",p_data->reg_oper.uuid.uu.uuid16); LOG_ERROR("(p_data->reg_oper.uuid.uu.uuid16=%x\n",p_data->reg_oper.uuid.uu.uuid16);
@ -87,16 +88,16 @@ static void button_profile_cb(tBTA_GATTS_EVT event, tBTA_GATTS *p_data)
Button_CreateService(); Button_CreateService();
} }
break; break;
case BTA_GATTS_READ_EVT: case ESP_GATTS_READ_EVT:
//tBTA_GATTS_RSP rsp; //tBTA_GATTS_RSP rsp;
memset(&rsp,0,sizeof(tBTA_GATTS_API_RSP)); memset(&rsp,0,sizeof(tBTA_GATTS_API_RSP));
rsp.attr_value.handle = p_data->req_data.p_data->read_req.handle; rsp.attr_value.handle = p_data->req_data.p_data->read_req.handle;
rsp.attr_value.len = 2; rsp.attr_value.len = 2;
BTA_GATTS_SendRsp(p_data->req_data.conn_id,p_data->req_data.trans_id, esp_ble_gatts_send_rsp(p_data->req_data.conn_id,p_data->req_data.trans_id,
p_data->req_data.status,&rsp); p_data->req_data.status,&rsp);
break; break;
case BTA_GATTS_WRITE_EVT: case ESP_GATTS_WRITE_EVT:
BTA_GATTS_SendRsp(p_data->req_data.conn_id,p_data->req_data.trans_id, esp_ble_gatts_send_rsp(p_data->req_data.conn_id,p_data->req_data.trans_id,
p_data->req_data.status,NULL); p_data->req_data.status,NULL);
LOG_ERROR("Received button data:"); LOG_ERROR("Received button data:");
for(int i = 0; i < p_data->req_data.p_data->write_req.len; i++){ for(int i = 0; i < p_data->req_data.p_data->write_req.len; i++){
@ -111,27 +112,27 @@ static void button_profile_cb(tBTA_GATTS_EVT event, tBTA_GATTS *p_data)
} }
break; break;
case BTA_GATTS_CONF_EVT: case ESP_GATTS_CFM_EVT:
break; break;
case BTA_GATTS_CREATE_EVT: case ESP_GATTS_CREATE_EVT:
//tBT_UUID uuid_butt_write; //tBT_UUID uuid_butt_write;
uuid.uu.uuid16 = ATT_CHAR_BUTTON_WIT; uuid.uu.uuid16 = ATT_CHAR_BUTTON_WIT;
//tBTA_GATT_PERM perm = (GATT_PERM_WRITE|GATT_PERM_READ); //tBTA_GATT_PERM perm = (GATT_PERM_WRITE|GATT_PERM_READ);
//tBTA_GATT_CHAR_PROP prop = (GATT_CHAR_PROP_BIT_READ|GATT_CHAR_PROP_BIT_WRITE); //tBTA_GATT_CHAR_PROP prop = (GATT_CHAR_PROP_BIT_READ|GATT_CHAR_PROP_BIT_WRITE);
//uuid = {LEN_UUID_16, {ATT_SVC_BUTTON}}; //uuid = {LEN_UUID_16, {ATT_SVC_BUTTON}};
button_cb_env.clcb.cur_srvc_id= p_data->create.service_id; button_cb_env.clcb.cur_srvc_id= p_data->create.service_id;
button_cb_env.is_primery = p_data->create.is_primary; button_cb_env.is_primery = p_data->create.is_primary;
//uuid = {LEN_UUID_16, {ATT_CHAR_BUTTON_WIT}}; //uuid = {LEN_UUID_16, {ATT_CHAR_BUTTON_WIT}};
//start the button service after created //start the button service after created
BTA_GATTS_StartService(p_data->create.service_id,BTA_GATT_TRANSPORT_LE); esp_ble_gatts_start_srvc(p_data->create.service_id);
//add the frist button characteristic --> write characteristic //add the frist button characteristic --> write characteristic
BTA_GATTS_AddCharacteristic(button_cb_env.clcb.cur_srvc_id,&uuid, esp_ble_gatts_add_char(button_cb_env.clcb.cur_srvc_id,&uuid,
(GATT_PERM_WRITE|GATT_PERM_READ), (GATT_PERM_WRITE|GATT_PERM_READ),
(GATT_CHAR_PROP_BIT_READ|GATT_CHAR_PROP_BIT_WRITE)); (GATT_CHAR_PROP_BIT_READ|GATT_CHAR_PROP_BIT_WRITE));
break; break;
case BTA_GATTS_ADD_CHAR_EVT: case ESP_GATTS_ADD_CHAR_EVT:
if(p_data->add_result.char_uuid.uu.uuid16 == ATT_CHAR_BUTTON_WIT) if(p_data->add_result.char_uuid.uu.uuid16 == ATT_CHAR_BUTTON_WIT)
{ {
uuid.uu.uuid16 = ATT_CHAR_BUTTON_NTF; uuid.uu.uuid16 = ATT_CHAR_BUTTON_NTF;
@ -140,44 +141,50 @@ static void button_profile_cb(tBTA_GATTS_EVT event, tBTA_GATTS *p_data)
//save the att handle to the env //save the att handle to the env
button_cb_env.button_inst.but_wirt_hdl = p_data->add_result.attr_id; button_cb_env.button_inst.but_wirt_hdl = p_data->add_result.attr_id;
//add the frist button characteristic --> Notify characteristic //add the frist button characteristic --> Notify characteristic
BTA_GATTS_AddCharacteristic(button_cb_env.clcb.cur_srvc_id,&uuid, esp_ble_gatts_add_char(button_cb_env.clcb.cur_srvc_id,&uuid,
GATT_PERM_READ,(GATT_CHAR_PROP_BIT_READ|GATT_CHAR_PROP_BIT_NOTIFY)); GATT_PERM_READ,(GATT_CHAR_PROP_BIT_READ|GATT_CHAR_PROP_BIT_NOTIFY));
}else if(p_data->add_result.char_uuid.uu.uuid16 == ATT_CHAR_BUTTON_NTF){ // add the gattc config descriptor to the notify charateristic }else if(p_data->add_result.char_uuid.uu.uuid16 == ATT_CHAR_BUTTON_NTF){ // add the gattc config descriptor to the notify charateristic
//tBTA_GATT_PERM perm = (GATT_PERM_WRITE|GATT_PERM_WRITE); //tBTA_GATT_PERM perm = (GATT_PERM_WRITE|GATT_PERM_WRITE);
uuid.uu.uuid16 = GATT_UUID_CHAR_CLIENT_CONFIG; uuid.uu.uuid16 = GATT_UUID_CHAR_CLIENT_CONFIG;
button_cb_env.button_inst.but_ntf_hdl = p_data->add_result.attr_id; button_cb_env.button_inst.but_ntf_hdl = p_data->add_result.attr_id;
BTA_GATTS_AddCharDescriptor (button_cb_env.clcb.cur_srvc_id, esp_ble_gatts_add_char_descr (button_cb_env.clcb.cur_srvc_id,
(GATT_PERM_WRITE|GATT_PERM_WRITE), (GATT_PERM_WRITE|GATT_PERM_WRITE),
&uuid); &uuid);
} }
break; break;
case BTA_GATTS_ADD_CHAR_DESCR_EVT: case ESP_GATTS_ADD_CHAR_DESCR_EVT:
if(p_data->add_result.char_uuid.uu.uuid16 == GATT_UUID_CHAR_CLIENT_CONFIG) if(p_data->add_result.char_uuid.uu.uuid16 == GATT_UUID_CHAR_CLIENT_CONFIG)
{ {
button_cb_env.button_inst.but_cfg_hdl = p_data->add_result.attr_id; button_cb_env.button_inst.but_cfg_hdl = p_data->add_result.attr_id;
} }
///Start advertising
LOG_ERROR("\n*******Start sent the ADV.*************\n");
//esp_ble_start_advertising (&adv_params);
//BTA_GATTS_Listen(button_cb_env.gatt_if, true, NULL);
break; break;
case BTA_GATTS_CONNECT_EVT: case ESP_GATTS_CONNECT_EVT:
LOG_ERROR("############BUTTON CONNCET EVT################\n");
//esp_ble_stop_advertising();
//set the connection flag to true //set the connection flag to true
button_env_clcb_alloc(p_data->conn.conn_id, p_data->conn.remote_bda); button_env_clcb_alloc(p_data->conn.conn_id, p_data->conn.remote_bda);
break; break;
case BTA_GATTS_DISCONNECT_EVT: case ESP_GATTS_DISCONNECT_EVT:
//set the connection flag to true //set the connection flag to true
button_cb_env.clcb.connected = false; button_cb_env.clcb.connected = false;
break; break;
case BTA_GATTS_OPEN_EVT: case ESP_GATTS_OPEN_EVT:
///stop the advertising after connected
break; break;
case BTA_GATTS_CLOSE_EVT: case ESP_GATTS_CLOSE_EVT:
if(button_cb_env.clcb.connected && (button_cb_env.clcb.conn_id == p_data->conn.conn_id)) if(button_cb_env.clcb.connected && (button_cb_env.clcb.conn_id == p_data->conn.conn_id))
{ {
//set the connection channal congested flag to true //set the connection channal congested flag to true
button_cb_env.clcb.congest = p_data->congest.congested; button_cb_env.clcb.congest = p_data->congest.congested;
} }
break; break;
case BTA_GATTS_LISTEN_EVT: case ESP_GATTS_CONGEST_EVT:
break;
case BTA_GATTS_CONGEST_EVT:
break; break;
default: default:
break; break;
@ -196,17 +203,17 @@ static void button_profile_cb(tBTA_GATTS_EVT event, tBTA_GATTS *p_data)
*******************************************************************************/ *******************************************************************************/
void Button_CreateService(void) void Button_CreateService(void)
{ {
tBTA_GATTS_IF server_if ; esp_gatts_if_t server_if ;
tBT_UUID uuid = {LEN_UUID_16, {ATT_SVC_BUTTON}}; esp_bt_uuid_t uuid = {LEN_UUID_16, {ATT_SVC_BUTTON}};
UINT16 num_handle = KEY_IDX_NB; uint16_t num_handle = KEY_IDX_NB;
UINT8 inst = 0x00; uint8_t inst = 0x00;
server_if = button_cb_env.gatt_if; server_if = button_cb_env.gatt_if;
button_cb_env.inst_id = inst; button_cb_env.inst_id = inst;
//if(!button_cb_env.enabled) //if(!button_cb_env.enabled)
//{ //{
// LOG_ERROR("button service added error."); // LOG_ERROR("button service added error.");
//} //}
BTA_GATTS_CreateService(server_if,&uuid,inst,num_handle,true); esp_ble_gatts_create_srvc(server_if,&uuid,inst,num_handle,true);
} }
@ -219,9 +226,9 @@ void Button_CreateService(void)
** Returns NULL if not found. Otherwise pointer to the connection link block. ** Returns NULL if not found. Otherwise pointer to the connection link block.
** **
*******************************************************************************/ *******************************************************************************/
tBUT_CLCB *button_env_clcb_alloc (UINT16 conn_id, BD_ADDR remote_bda) but_clcb_t *button_env_clcb_alloc (uint16_t conn_id, BD_ADDR remote_bda)
{ {
tBUT_CLCB *p_clcb = NULL; but_clcb_t *p_clcb = NULL;
p_clcb = &button_cb_env.clcb; p_clcb = &button_cb_env.clcb;
if(!p_clcb->in_use) if(!p_clcb->in_use)
@ -245,10 +252,10 @@ tBUT_CLCB *button_env_clcb_alloc (UINT16 conn_id, BD_ADDR remote_bda)
** Returns total number of clcb found. ** Returns total number of clcb found.
** **
*******************************************************************************/ *******************************************************************************/
UINT16 button_env_find_conn_id_by_bd_adddr(BD_ADDR remote_bda) uint16_t button_env_find_conn_id_by_bd_adddr(BD_ADDR remote_bda)
{ {
UINT8 i_clcb; uint8_t i_clcb;
tBUT_CLCB *p_clcb = NULL; but_clcb_t *p_clcb = NULL;
for(i_clcb = 0, p_clcb = &button_cb_env.clcb; i_clcb < BUTT_MAX_APPS; i_clcb++, p_clcb++) for(i_clcb = 0, p_clcb = &button_cb_env.clcb; i_clcb < BUTT_MAX_APPS; i_clcb++, p_clcb++)
{ {
@ -270,32 +277,23 @@ UINT16 button_env_find_conn_id_by_bd_adddr(BD_ADDR remote_bda)
** Returns True the deallocation is successful ** Returns True the deallocation is successful
** **
*******************************************************************************/ *******************************************************************************/
/*
BOOLEAN button_env_clcb_dealloc(UINT16 conn_id)
{
UINT8 i_clcb = 0;
tBUT_CLCB *p_clcb = NULL;
for(i_clcb = 0, p_clcb = &button_cb_env.clcb; i_clcb < BUTT_MAX_APPS; i_clcb++, p_clcb++) BOOLEAN button_env_clcb_dealloc(uint16_t conn_id)
{
uint16_t i_clcb = 0;
but_clcb_t *p_clcb = NULL;
for(i_clcb = 0, p_clcb = &button_cb_env.clcb; i_clcb < 1; i_clcb++, p_clcb++)
{ {
if(p_clcb->in_use && p_clcb->connected && (p_clcb->conn_id == conn_id)) if(p_clcb->in_use && p_clcb->connected && (p_clcb->conn_id == conn_id))
{ {
unsigned j; memset(p_clcb, 0, sizeof(but_clcb_t));
for(j = 0; j < ARRAY_SIZE(p_clcb->button_value.data_string);j++)
{
if(p_clcb->button_value.data_string[j])
{
GKI_freebuf(p_clcb->button_value.data_string[j]);
}
}
memset(p_clcb, 0, sizeof(tBUT_CLCB));
return TRUE; return TRUE;
} }
} }
return FALSE; return FALSE;
}*/ }
/******************************************************************************* /*******************************************************************************
** **
@ -304,19 +302,19 @@ BOOLEAN button_env_clcb_dealloc(UINT16 conn_id)
** Description Initializa the GATT Service for button profiles. ** Description Initializa the GATT Service for button profiles.
** **
*******************************************************************************/ *******************************************************************************/
tGATT_STATUS button_init (tBU_CBACK *call_back) esp_gatt_status_t button_init (but_prf_cb_t call_back)
{ {
tBT_UUID app_uuid = {LEN_UUID_16,{ATT_SVC_BUTTON}}; tBT_UUID app_uuid = {LEN_UUID_16,{ATT_SVC_BUTTON}};
LOG_ERROR("\n=============================button_init==============================================\n");
if(button_cb_env.enabled) if(button_cb_env.enabled)
{ {
LOG_ERROR("button svc already initaliezd"); LOG_ERROR("button svc already initaliezd\n");
return GATT_ERROR; return ESP_GATT_ERROR;
} }
else else
{ {
memset(&button_cb_env,0,sizeof(tBUTTON_CB_ENV)); memset(&button_cb_env,0,sizeof(button_env_cb_t));
} }
@ -327,27 +325,33 @@ tGATT_STATUS button_init (tBU_CBACK *call_back)
/* register the button profile to the BTA_GATTS module*/ /* register the button profile to the BTA_GATTS module*/
BTA_GATTS_AppRegister(&app_uuid,button_profile_cb); esp_ble_gatts_app_register(&app_uuid,button_profile_cb);
button_cb_env.enabled = TRUE; button_cb_env.enabled = TRUE;
return GATT_SUCCESS; return ESP_GATT_OK;
} }
void button_msg_notify(UINT8 len, UINT8 *button_msg) void button_disable(uint16_t connid)
{
button_env_clcb_dealloc(connid);
}
void button_msg_notify(uint16_t len, uint8_t *button_msg)
{ {
BOOLEAN conn_status = button_cb_env.clcb.connected; BOOLEAN conn_status = button_cb_env.clcb.connected;
UINT16 conn_id = button_cb_env.clcb.conn_id; uint16_t conn_id = button_cb_env.clcb.conn_id;
UINT16 attr_id = button_cb_env.button_inst.but_ntf_hdl; uint16_t attr_id = button_cb_env.button_inst.but_ntf_hdl;
//notify rsp==false; indicate rsp==true. //notify rsp==false; indicate rsp==true.
BOOLEAN rsp = false; BOOLEAN rsp = false;
if(!conn_status && button_cb_env.clcb.congest) if(!conn_status && button_cb_env.clcb.congest)
{ {
LOG_ERROR("the conneciton for button profile has been loss"); LOG_ERROR("the conneciton for button profile has been loss\n");
return; return;
} }
BTA_GATTS_HandleValueIndication (conn_id, attr_id, len, esp_ble_gatts_hdl_val_indica (conn_id, attr_id, len,
button_msg, rsp); button_msg, rsp);
} }

8
components/bt/bluedroid/profiles/esp/blufi/include/blufi_adv.h
View file

@ -3,13 +3,7 @@
#include "bta_api.h" #include "bta_api.h"
#include "btm_ble_api.h" #include "btm_ble_api.h"
#include "bt_app_defs.h"
enum
{
BLE_ADV_DATA_IDX,
BLE_SCAN_RSP_DATA_IDX,
ADV_SCAN_IDX_MAX
};
typedef struct typedef struct
{ {

55
components/bt/bluedroid/profiles/esp/include/button_pro.h
View file

@ -17,6 +17,7 @@
#include "bt_target.h" #include "bt_target.h"
#include "gatt_api.h" #include "gatt_api.h"
#include "gattdefs.h" #include "gattdefs.h"
#include "bt_app_api.h"
#define KEY_SUCCESS GATT_SUCCESS #define KEY_SUCCESS GATT_SUCCESS
#define KEY_ILLEGAL_PARAM GATT_ILLEGAL_PARAMETER #define KEY_ILLEGAL_PARAM GATT_ILLEGAL_PARAMETER
@ -36,7 +37,7 @@
#define BUT_MAX_STRING_DATA 7 #define BUT_MAX_STRING_DATA 7
typedef void (tBU_CBACK)(UINT8 app_id, UINT8 event, UINT8 len, UINT8 *data); typedef void (*but_prf_cb_t)(uint8_t app_id, uint8_t event, uint16_t len, uint8_t *value);
#ifndef BUT_MAX_INT_NUM #ifndef BUT_MAX_INT_NUM
#define BUT_MAX_INT_NUM 4 #define BUT_MAX_INT_NUM 4
@ -64,59 +65,61 @@ enum
typedef struct typedef struct
{ {
BD_ADDR remote_bda; BD_ADDR remote_bda;
BOOLEAN need_rsp; BOOLEAN need_rsp;
UINT16 clt_cfg; uint16_t clt_cfg;
}tBUT_WRITE_DATA; }but_write_data_t;
typedef struct typedef struct
{ {
BOOLEAN in_use; BOOLEAN in_use;
BOOLEAN congest; BOOLEAN congest;
UINT16 conn_id; uint16_t conn_id;
BOOLEAN connected; BOOLEAN connected;
BD_ADDR remote_bda; BD_ADDR remote_bda;
UINT32 trans_id; uint32_t trans_id;
UINT8 cur_srvc_id; uint8_t cur_srvc_id;
}tBUT_CLCB; }but_clcb_t;
typedef struct typedef struct
{ {
UINT8 app_id; uint8_t app_id;
UINT16 but_wirt_hdl; uint16_t but_wirt_hdl;
UINT16 but_ntf_hdl; uint16_t but_ntf_hdl;
UINT16 but_cfg_hdl; uint16_t but_cfg_hdl;
tBU_CBACK *p_cback; but_prf_cb_t p_cback;
}tBUT_INST; }but_inst_t;
/* service engine control block */ /* service engine control block */
typedef struct typedef struct
{ {
tBUT_CLCB clcb; /* connection link*/ but_clcb_t clcb; /* connection link*/
tGATT_IF gatt_if; esp_gatt_if_t gatt_if;
BOOLEAN enabled; BOOLEAN enabled;
BOOLEAN is_primery; BOOLEAN is_primery;
tBUT_INST button_inst; but_inst_t button_inst;
UINT8 inst_id; uint8_t inst_id;
}tBUTTON_CB_ENV; }button_env_cb_t;
void Button_CreateService(void); void Button_CreateService(void);
tBUT_CLCB *button_env_clcb_alloc(UINT16 conn_id, BD_ADDR bda); but_clcb_t *button_env_clcb_alloc(uint16_t conn_id, BD_ADDR bda);
UINT16 button_env_find_conn_id_by_bd_adddr(BD_ADDR bda); uint16_t button_env_find_conn_id_by_bd_adddr(BD_ADDR bda);
BOOLEAN button_env_clcb_dealloc(UINT16 conn_id); BOOLEAN button_env_clcb_dealloc(uint16_t conn_id);
tGATT_STATUS button_init(tBU_CBACK *call_back); esp_gatt_status_t button_init(but_prf_cb_t call_back);
void button_msg_notify(UINT8 len, UINT8 *button_msg); void button_disable(uint16_t connid);
extern tBUTTON_CB_ENV button_cb_env; void button_msg_notify(uint16_t len, uint8_t *button_msg);
extern button_env_cb_t button_cb_env;
#endif ///BUT_PROFILE_CFG #endif ///BUT_PROFILE_CFG

156
components/bt/bluedroid/profiles/esp/include/wx_airsync_prf.h
View file

@ -19,6 +19,7 @@
#include "bt_target.h" #include "bt_target.h"
#include "gatt_api.h" #include "gatt_api.h"
#include "gattdefs.h" #include "gattdefs.h"
#include "bt_app_api.h"
/// Maximum Transmission Unit /// Maximum Transmission Unit
@ -33,83 +34,82 @@
#define ATT_CHAR_AIRSYNC_WIT 0xFEC7 #define ATT_CHAR_AIRSYNC_WIT 0xFEC7
#define ATT_CHAR_AIRSYBC_NTF 0xFEC8 #define ATT_CHAR_AIRSYBC_NTF 0xFEC8
#define ATT_CHAR_AIRSYNC_READ 0xFEC9 #define ATT_CHAR_AIRSYNC_READ 0xFEC9
typedef void (tAIRSYNC_CBACK)(UINT8 app_id, UINT8 event, UINT8 len, UINT8 *data);
/// WX AirSync Service Attributes Indexes
enum
{
WX_IDX_SVC,
WX_IDX_AIRSYNC_WIT_CHAR,
WX_IDX_AIRSYNC_WIT_VAL,
WX_IDX_AIRSYNC_NTF_CHAR,
WX_IDX_AIRSYNC_NTF_VAL,
WX_IDX_AIRSYNC_READ_CHAR,
WX_IDX_AIRSYNC_READ_VAL,
WX_IDX_AIRSYNC_NTF_CFG,
KEY_IDX_NB,
};
typedef struct
{
BD_ADDR remote_bda;
BOOLEAN need_rsp;
UINT16 clt_cfg;
}tAirSync_WRITE_DATA;
typedef struct
{
BOOLEAN in_use;
BOOLEAN congest;
UINT16 conn_id;
BOOLEAN connected;
BD_ADDR remote_bda;
UINT32 trans_id;
UINT8 cur_srvc_id;
}tAirSync_CLCB;
typedef struct
{
UINT8 app_id;
UINT16 airsync_wirt_hdl;
UINT16 airsync_ntf_hdl;
UINT16 airsync_read_hdl;
UINT16 airsync_cfg_hdl;
tAIRSYNC_CBACK *p_cback;
}tAirSync_INST;
/* service engine control block */
typedef struct
{
tAirSync_CLCB clcb; /* connection link*/
tGATT_IF gatt_if;
BOOLEAN enabled;
BOOLEAN is_primery;
tAirSync_INST airsync_inst;
UINT8 inst_id;
}tAIRSYNC_CB_ENV;
void AirSync_CreateService(void);
tAirSync_CLCB *airsync_env_clcb_alloc (UINT16 conn_id, BD_ADDR remote_bda);
UINT16 AirSync_env_find_conn_id_by_bd_adddr(BD_ADDR bda);
BOOLEAN AirSync_env_clcb_dealloc(UINT16 conn_id);
tGATT_STATUS AirSync_Init(tAIRSYNC_CBACK *call_back);
void AirSync_msg_notify(UINT8 len, UINT8 *button_msg);
extern tAIRSYNC_CB_ENV airsync_cb_env;
#endif ///WX_AIRSYNC_CFG
typedef void (tAIRSYNC_CBACK)(UINT8 app_id, UINT8 event, UINT8 len, UINT8 *data);
/// WX AirSync Service Attributes Indexes
enum
{
WX_IDX_SVC,
WX_IDX_AIRSYNC_WIT_CHAR,
WX_IDX_AIRSYNC_WIT_VAL,
WX_IDX_AIRSYNC_NTF_CHAR,
WX_IDX_AIRSYNC_NTF_VAL,
WX_IDX_AIRSYNC_READ_CHAR,
WX_IDX_AIRSYNC_READ_VAL,
WX_IDX_AIRSYNC_NTF_CFG,
WX_IDX_NB,
};
typedef struct
{
BD_ADDR remote_bda;
BOOLEAN need_rsp;
UINT16 clt_cfg;
}tAirSync_WRITE_DATA;
typedef struct
{
BOOLEAN in_use;
BOOLEAN congest;
UINT16 conn_id;
BOOLEAN connected;
BD_ADDR remote_bda;
UINT32 trans_id;
UINT8 cur_srvc_id;
}tAirSync_CLCB;
typedef struct
{
UINT8 app_id;
UINT16 airsync_wirt_hdl;
UINT16 airsync_ntf_hdl;
UINT16 airsync_read_hdl;
UINT16 airsync_cfg_hdl;
tAIRSYNC_CBACK *p_cback;
}tAirSync_INST;
/* service engine control block */
typedef struct
{
tAirSync_CLCB clcb; /* connection link*/
tGATT_IF gatt_if;
BOOLEAN enabled;
BOOLEAN is_primery;
tAirSync_INST airsync_inst;
UINT8 inst_id;
}tAIRSYNC_CB_ENV;
void AirSync_CreateService(void);
tAirSync_CLCB *airsync_env_clcb_alloc (UINT16 conn_id, BD_ADDR remote_bda);
UINT16 AirSync_env_find_conn_id_by_bd_adddr(BD_ADDR bda);
BOOLEAN AirSync_env_clcb_dealloc(UINT16 conn_id);
tGATT_STATUS AirSync_Init(tAIRSYNC_CBACK *call_back);
void AirSync_msg_notify(UINT8 len, UINT8 *button_msg);
extern tAIRSYNC_CB_ENV airsync_cb_env;
#endif ///WX_AIRSYNC_CFG

71
components/bt/bluedroid/profiles/esp/wechat_AirSync/wx_airsync_prf.c
View file

@ -37,7 +37,7 @@ tAIRSYNC_CB_ENV airsync_cb_env;
/***************************************************************************** /*****************************************************************************
** Constants ** Constants
*****************************************************************************/ *****************************************************************************/
static void airsync_profile_cb(tBTA_GATTS_EVT event, tBTA_GATTS *p_data); static void airsync_profile_cb(esp_gatts_evt_t event, esp_gatts_t *p_data);
/******************************************************************************* /*******************************************************************************
@ -49,17 +49,17 @@ static void airsync_profile_cb(tBTA_GATTS_EVT event, tBTA_GATTS *p_data);
** Returns NULL ** Returns NULL
** **
*******************************************************************************/ *******************************************************************************/
static void airsync_profile_cb(tBTA_GATTS_EVT event, tBTA_GATTS *p_data) static void airsync_profile_cb(esp_gatts_evt_t event, esp_gatts_t *p_data)
{ {
tBTA_GATTS_RSP rsp; esp_gatts_rsp_t rsp;
tBT_UUID uuid = {LEN_UUID_16, {ATT_SVC_AIRSYNC}}; esp_bt_uuid_t uuid = {LEN_UUID_16, {ATT_SVC_AIRSYNC}};
tAirSync_INST *p_inst = &airsync_cb_env.airsync_inst; tAirSync_INST *p_inst = &airsync_cb_env.airsync_inst;
LOG_ERROR("airsync profile cb event = %x\n",event); LOG_ERROR("airsync profile cb event = %x\n",event);
switch(event) switch(event)
{ {
case BTA_GATTS_REG_EVT: case ESP_GATTS_REG_EVT:
if(p_data->reg_oper.status != BTA_GATT_OK) if(p_data->reg_oper.status != BTA_GATT_OK)
{ {
@ -73,41 +73,41 @@ static void airsync_profile_cb(tBTA_GATTS_EVT event, tBTA_GATTS *p_data)
AirSync_CreateService(); AirSync_CreateService();
} }
break; break;
case BTA_GATTS_READ_EVT: case ESP_GATTS_READ_EVT:
if(airsync_cb_env.clcb.connected && airsync_cb_env.enabled){ if(airsync_cb_env.clcb.connected && airsync_cb_env.enabled){
//tBTA_GATTS_RSP rsp; //tBTA_GATTS_RSP rsp;
memset(&rsp,0,sizeof(tBTA_GATTS_API_RSP)); memset(&rsp,0,sizeof(tBTA_GATTS_API_RSP));
rsp.attr_value.handle = p_data->req_data.p_data->read_req.handle; rsp.attr_value.handle = p_data->req_data.p_data->read_req.handle;
rsp.attr_value.len = 2; rsp.attr_value.len = 2;
BTA_GATTS_SendRsp(p_data->req_data.conn_id,p_data->req_data.trans_id, esp_ble_gatts_send_rsp(p_data->req_data.conn_id,p_data->req_data.trans_id,
p_data->req_data.status,&rsp); p_data->req_data.status,&rsp);
} }
break; break;
case BTA_GATTS_WRITE_EVT: case ESP_GATTS_WRITE_EVT:
if(airsync_cb_env.clcb.connected && airsync_cb_env.enabled){ if(airsync_cb_env.clcb.connected && airsync_cb_env.enabled){
BTA_GATTS_SendRsp(p_data->req_data.conn_id,p_data->req_data.trans_id, esp_ble_gatts_send_rsp(p_data->req_data.conn_id,p_data->req_data.trans_id,
p_data->req_data.status,NULL); p_data->req_data.status,NULL);
} }
break; break;
case BTA_GATTS_CONF_EVT: case ESP_GATTS_CFM_EVT:
break; break;
case BTA_GATTS_CREATE_EVT: case ESP_GATTS_CREATE_EVT:
uuid.uu.uuid16 = ATT_CHAR_AIRSYNC_WIT; uuid.uu.uuid16 = ATT_CHAR_AIRSYNC_WIT;
airsync_cb_env.clcb.cur_srvc_id= p_data->create.service_id; airsync_cb_env.clcb.cur_srvc_id= p_data->create.service_id;
airsync_cb_env.is_primery = p_data->create.is_primary; airsync_cb_env.is_primery = p_data->create.is_primary;
//start the airsync service after created //start the airsync service after created
BTA_GATTS_StartService(p_data->create.service_id,BTA_GATT_TRANSPORT_LE); esp_ble_gatts_start_srvc(p_data->create.service_id);
//add the frist airsync characteristic --> write characteristic //add the frist airsync characteristic --> write characteristic
BTA_GATTS_AddCharacteristic(airsync_cb_env.clcb.cur_srvc_id,&uuid, esp_ble_gatts_add_char(airsync_cb_env.clcb.cur_srvc_id,&uuid,
(GATT_PERM_WRITE|GATT_PERM_READ), (GATT_PERM_WRITE|GATT_PERM_READ),
(GATT_CHAR_PROP_BIT_READ|GATT_CHAR_PROP_BIT_WRITE)); (GATT_CHAR_PROP_BIT_READ|GATT_CHAR_PROP_BIT_WRITE));
break; break;
case BTA_GATTS_ADD_CHAR_EVT: case ESP_GATTS_ADD_CHAR_EVT:
if(p_data->add_result.char_uuid.uu.uuid16 == ATT_CHAR_AIRSYNC_WIT) if(p_data->add_result.char_uuid.uu.uuid16 == ATT_CHAR_AIRSYNC_WIT)
{ {
uuid.uu.uuid16 = ATT_CHAR_AIRSYBC_NTF; uuid.uu.uuid16 = ATT_CHAR_AIRSYBC_NTF;
@ -116,19 +116,19 @@ static void airsync_profile_cb(tBTA_GATTS_EVT event, tBTA_GATTS *p_data)
//save the att handle to the env //save the att handle to the env
airsync_cb_env.airsync_inst.airsync_wirt_hdl = p_data->add_result.attr_id; airsync_cb_env.airsync_inst.airsync_wirt_hdl = p_data->add_result.attr_id;
//add the second airsync characteristic --> Notify characteristic //add the second airsync characteristic --> Notify characteristic
BTA_GATTS_AddCharacteristic(airsync_cb_env.clcb.cur_srvc_id,&uuid, esp_ble_gatts_add_char(airsync_cb_env.clcb.cur_srvc_id,&uuid,
GATT_PERM_READ,(GATT_CHAR_PROP_BIT_READ|GATT_CHAR_PROP_BIT_INDICATE)); GATT_PERM_READ,(GATT_CHAR_PROP_BIT_READ|GATT_CHAR_PROP_BIT_INDICATE));
}else if(p_data->add_result.char_uuid.uu.uuid16 == ATT_CHAR_AIRSYBC_NTF){ }else if(p_data->add_result.char_uuid.uu.uuid16 == ATT_CHAR_AIRSYBC_NTF){
//tBTA_GATT_PERM perm = (GATT_PERM_WRITE|GATT_PERM_WRITE); //tBTA_GATT_PERM perm = (GATT_PERM_WRITE|GATT_PERM_WRITE);
uuid.uu.uuid16 = GATT_UUID_CHAR_CLIENT_CONFIG; uuid.uu.uuid16 = GATT_UUID_CHAR_CLIENT_CONFIG;
airsync_cb_env.airsync_inst.airsync_ntf_hdl = p_data->add_result.attr_id; airsync_cb_env.airsync_inst.airsync_ntf_hdl = p_data->add_result.attr_id;
BTA_GATTS_AddCharDescriptor (airsync_cb_env.clcb.cur_srvc_id, esp_ble_gatts_add_char_descr (airsync_cb_env.clcb.cur_srvc_id,
(GATT_PERM_WRITE|GATT_PERM_WRITE), (GATT_PERM_WRITE|GATT_PERM_WRITE),
&uuid); &uuid);
uuid.uu.uuid16 = ATT_CHAR_AIRSYNC_READ; uuid.uu.uuid16 = ATT_CHAR_AIRSYNC_READ;
//add the third airsync characteristic --> Read characteristic //add the third airsync characteristic --> Read characteristic
BTA_GATTS_AddCharacteristic(airsync_cb_env.clcb.cur_srvc_id,&uuid, esp_ble_gatts_add_char(airsync_cb_env.clcb.cur_srvc_id,&uuid,
GATT_PERM_READ, GATT_PERM_READ,
GATT_CHAR_PROP_BIT_READ); GATT_CHAR_PROP_BIT_READ);
}else if(p_data->add_result.char_uuid.uu.uuid16 == ATT_CHAR_AIRSYNC_READ){ }else if(p_data->add_result.char_uuid.uu.uuid16 == ATT_CHAR_AIRSYNC_READ){
@ -136,32 +136,30 @@ static void airsync_profile_cb(tBTA_GATTS_EVT event, tBTA_GATTS *p_data)
} }
break; break;
case BTA_GATTS_ADD_CHAR_DESCR_EVT: case ESP_GATTS_ADD_CHAR_DESCR_EVT:
if(p_data->add_result.char_uuid.uu.uuid16 == GATT_UUID_CHAR_CLIENT_CONFIG) if(p_data->add_result.char_uuid.uu.uuid16 == GATT_UUID_CHAR_CLIENT_CONFIG)
{ {
airsync_cb_env.airsync_inst.airsync_cfg_hdl = p_data->add_result.attr_id; airsync_cb_env.airsync_inst.airsync_cfg_hdl = p_data->add_result.attr_id;
} }
break; break;
case BTA_GATTS_CONNECT_EVT: case ESP_GATTS_CONNECT_EVT:
//set the connection flag to true //set the connection flag to true
airsync_env_clcb_alloc(p_data->conn.conn_id, p_data->conn.remote_bda); airsync_env_clcb_alloc(p_data->conn.conn_id, p_data->conn.remote_bda);
break; break;
case BTA_GATTS_DISCONNECT_EVT: case ESP_GATTS_DISCONNECT_EVT:
//set the connection flag to true //set the connection flag to true
airsync_cb_env.clcb.connected = false; airsync_cb_env.clcb.connected = false;
break; break;
case BTA_GATTS_OPEN_EVT: case ESP_GATTS_OPEN_EVT:
break; break;
case BTA_GATTS_CLOSE_EVT: case ESP_GATTS_CLOSE_EVT:
if(airsync_cb_env.clcb.connected && (airsync_cb_env.clcb.conn_id == p_data->conn.conn_id)) if(airsync_cb_env.clcb.connected && (airsync_cb_env.clcb.conn_id == p_data->conn.conn_id))
{ {
//set the connection channal congested flag to true //set the connection channal congested flag to true
airsync_cb_env.clcb.congest = p_data->congest.congested; airsync_cb_env.clcb.congest = p_data->congest.congested;
} }
break; break;
case BTA_GATTS_LISTEN_EVT: case ESP_GATTS_CONGEST_EVT:
break;
case BTA_GATTS_CONGEST_EVT:
//set the congest flag //set the congest flag
airsync_cb_env.clcb.congest = p_data->congest.congested; airsync_cb_env.clcb.congest = p_data->congest.congested;
break; break;
@ -182,14 +180,14 @@ static void airsync_profile_cb(tBTA_GATTS_EVT event, tBTA_GATTS *p_data)
*******************************************************************************/ *******************************************************************************/
void AirSync_CreateService(void) void AirSync_CreateService(void)
{ {
tBTA_GATTS_IF server_if ; esp_gatts_if_t server_if ;
tBT_UUID uuid = {LEN_UUID_16, {ATT_SVC_AIRSYNC}}; esp_bt_uuid_t uuid = {LEN_UUID_16, {ATT_SVC_AIRSYNC}};
UINT16 num_handle = KEY_IDX_NB; UINT16 num_handle = WX_IDX_NB;
UINT8 inst = 0x00; UINT8 inst = 0x00;
server_if = airsync_cb_env.gatt_if; server_if = airsync_cb_env.gatt_if;
airsync_cb_env.inst_id = inst; airsync_cb_env.inst_id = inst;
BTA_GATTS_CreateService(server_if,&uuid,inst,num_handle,true); esp_ble_gatts_create_srvc(server_if,&uuid,inst,num_handle,true);
} }
@ -254,13 +252,13 @@ UINT16 airsync_env_find_conn_id_by_bd_adddr(BD_ADDR remote_bda)
*******************************************************************************/ *******************************************************************************/
tGATT_STATUS AirSync_Init(tAIRSYNC_CBACK *call_back) tGATT_STATUS AirSync_Init(tAIRSYNC_CBACK *call_back)
{ {
tBT_UUID app_uuid = {LEN_UUID_16,{ATT_SVC_AIRSYNC}}; esp_bt_uuid_t app_uuid = {LEN_UUID_16,{ATT_SVC_AIRSYNC}};
if(airsync_cb_env.enabled) if(airsync_cb_env.enabled)
{ {
LOG_ERROR("airsync svc already initaliezd\n"); LOG_ERROR("airsync svc already initaliezd\n");
return GATT_ERROR; return ESP_GATT_ERROR;
} }
else else
{ {
@ -269,18 +267,17 @@ tGATT_STATUS AirSync_Init(tAIRSYNC_CBACK *call_back)
if(call_back != NULL) if(call_back != NULL)
{ {
airsync_cb_env.airsync_inst.p_cback = call_back; airsync_cb_env.airsync_inst.p_cback = call_back;
} }
/* register the airsync profile to the BTA_GATTS module*/ /* register the airsync profile to the BTA_GATTS module*/
BTA_GATTS_AppRegister(&app_uuid,airsync_profile_cb); esp_ble_gatts_app_register(&app_uuid,airsync_profile_cb);
airsync_cb_env.enabled = TRUE; airsync_cb_env.enabled = TRUE;
return GATT_SUCCESS; return ESP_GATT_OK;
} }
#endif ///WX_AIRSYNC_CFG #endif ///WX_AIRSYNC_CFG

95
components/bt/bluedroid/profiles/std/battery/battery_prf.c
View file

@ -35,7 +35,7 @@
#define BT_BD_ADDR_STR "%02x:%02x:%02x:%02x:%02x:%02x" #define BT_BD_ADDR_STR "%02x:%02x:%02x:%02x:%02x:%02x"
#define BT_BD_ADDR_HEX(addr) addr[0], addr[1], addr[2], addr[3], addr[4], addr[5] #define BT_BD_ADDR_HEX(addr) addr[0], addr[1], addr[2], addr[3], addr[4], addr[5]
tBTA_GATTS_IF server_if; esp_gatts_if_t server_if;
tBATTERY_CB battery_cb; tBATTERY_CB battery_cb;
tGATT_CHAR_PROP prop = GATT_CHAR_PROP_BIT_READ; tGATT_CHAR_PROP prop = GATT_CHAR_PROP_BIT_READ;
@ -43,19 +43,19 @@ tBA_REG_INFO ba_reg_info;
UINT8 attr_handle_bit = 0x00; UINT8 attr_handle_bit = 0x00;
extern tDIS_CB dis_cb; extern tDIS_CB dis_cb;
tBT_UUID bas_uuid = {LEN_UUID_16, {UUID_SERVCLASS_BATTERY}}; esp_bt_uuid_t bas_uuid = {LEN_UUID_16, {UUID_SERVCLASS_BATTERY}};
/****************************************************************************** /******************************************************************************
** Function bas_gatts_callback ** Function bas_gatts_callback
** **
** Description battery service register callback function ** Description battery service register callback function
*******************************************************************************/ *******************************************************************************/
static void bas_gatts_callback(tBTA_GATTS_EVT event, tBTA_GATTS* p_data) static void bas_gatts_callback(esp_gatts_evt_t event, tBTA_GATTS* p_data)
{ {
switch (event) switch (event)
{ {
case BTA_GATTS_REG_EVT: case ESP_GATTS_REG_EVT:
{ {
tBTA_GATT_STATUS status = p_data->reg_oper.status; esp_gatt_status_t status = p_data->reg_oper.status;
server_if = p_data->reg_oper.server_if; server_if = p_data->reg_oper.server_if;
LOG_ERROR("BAS register completed: event=%d, status=%d, server_if=%d\n", LOG_ERROR("BAS register completed: event=%d, status=%d, server_if=%d\n",
event, status, server_if); event, status, server_if);
@ -69,7 +69,7 @@ static void bas_gatts_callback(tBTA_GATTS_EVT event, tBTA_GATTS* p_data)
break; break;
/*connect callback*/ /*connect callback*/
case BTA_GATTS_CONNECT_EVT: case ESP_GATTS_CONNECT_EVT:
{ {
LOG_ERROR("\ndevice is connected "BT_BD_ADDR_STR", server_if=%d,reason=0x%x,connect_id=%d\n", LOG_ERROR("\ndevice is connected "BT_BD_ADDR_STR", server_if=%d,reason=0x%x,connect_id=%d\n",
BT_BD_ADDR_HEX(p_data->conn.remote_bda), p_data->conn.server_if, BT_BD_ADDR_HEX(p_data->conn.remote_bda), p_data->conn.server_if,
@ -81,7 +81,7 @@ static void bas_gatts_callback(tBTA_GATTS_EVT event, tBTA_GATTS* p_data)
break; break;
/*create service callback*/ /*create service callback*/
case BTA_GATTS_CREATE_EVT: case ESP_GATTS_CREATE_EVT:
{ {
LOG_ERROR("create service:server_if=%d,service_id=0x%x,service_uuid=0x%x\n", LOG_ERROR("create service:server_if=%d,service_id=0x%x,service_uuid=0x%x\n",
p_data->create.server_if, p_data->create.service_id, p_data->create.server_if, p_data->create.service_id,
@ -103,7 +103,7 @@ static void bas_gatts_callback(tBTA_GATTS_EVT event, tBTA_GATTS* p_data)
} }
break; break;
case BTA_GATTS_ADD_CHAR_EVT: case ESP_GATTS_ADD_CHAR_EVT:
{ {
LOG_ERROR("create characteristic:server_if=%d,service_id=0x%x,char_uuid=0x%x\n", LOG_ERROR("create characteristic:server_if=%d,service_id=0x%x,char_uuid=0x%x\n",
p_data->add_result.server_if, p_data->add_result.service_id, p_data->add_result.server_if, p_data->add_result.service_id,
@ -141,7 +141,7 @@ static void bas_gatts_callback(tBTA_GATTS_EVT event, tBTA_GATTS* p_data)
} }
break; break;
case BTA_GATTS_ADD_CHAR_DESCR_EVT: case ESP_GATTS_ADD_CHAR_DESCR_EVT:
{ {
LOG_ERROR("create descriptor:server_if=%d,service_id=0x%x,attr_id=0x%x,char_uuid=0x%x\n", LOG_ERROR("create descriptor:server_if=%d,service_id=0x%x,attr_id=0x%x,char_uuid=0x%x\n",
@ -151,20 +151,20 @@ static void bas_gatts_callback(tBTA_GATTS_EVT event, tBTA_GATTS* p_data)
} }
break; break;
case BTA_GATTS_START_EVT: case ESP_GATTS_START_EVT:
{ {
LOG_ERROR("start service:server_if=%d,service_id=0x%x\n", p_data->srvc_oper.server_if, LOG_ERROR("start service:server_if=%d,service_id=0x%x\n", p_data->srvc_oper.server_if,
p_data->srvc_oper.service_id); p_data->srvc_oper.service_id);
bas_service_cmpl(p_data->srvc_oper.service_id, p_data->srvc_oper.status); bas_service_cmpl(p_data->srvc_oper.service_id, p_data->srvc_oper.status);
/*start advertising*/ /*start advertising*/
if(p_data->srvc_oper.status == GATT_SUCCESS) //if(p_data->srvc_oper.status == GATT_SUCCESS)
BTA_GATTS_Listen(server_if, true, NULL); // BTA_GATTS_Listen(server_if, true, NULL);
// BTA_GATTC_Broadcast(client_if, true); //non-connectable // BTA_GATTC_Broadcast(client_if, true); //non-connectable
} }
break; break;
case BTA_GATTS_READ_EVT: case ESP_GATTS_READ_EVT:
{ {
UINT32 trans_id = p_data->req_data.trans_id; UINT32 trans_id = p_data->req_data.trans_id;
UINT16 conn_id = p_data->req_data.conn_id; UINT16 conn_id = p_data->req_data.conn_id;
@ -186,7 +186,7 @@ static void bas_gatts_callback(tBTA_GATTS_EVT event, tBTA_GATTS* p_data)
} }
break; break;
case BTA_GATTS_WRITE_EVT: case ESP_GATTS_WRITE_EVT:
{ {
UINT32 trans_id = p_data->req_data.trans_id; UINT32 trans_id = p_data->req_data.trans_id;
@ -199,7 +199,7 @@ static void bas_gatts_callback(tBTA_GATTS_EVT event, tBTA_GATTS* p_data)
} }
break; break;
case BTA_GATTS_EXEC_WRITE_EVT: case ESP_GATTS_EXEC_WRITE_EVT:
{ {
UINT32 trans_id = p_data->req_data.trans_id; UINT32 trans_id = p_data->req_data.trans_id;
UINT16 conn_id = p_data->req_data.conn_id; UINT16 conn_id = p_data->req_data.conn_id;
@ -209,7 +209,7 @@ static void bas_gatts_callback(tBTA_GATTS_EVT event, tBTA_GATTS* p_data)
} }
break; break;
case BTA_GATTS_MTU_EVT: case ESP_GATTS_MTU_EVT:
{ {
UINT32 trans_id = p_data->req_data.trans_id; UINT32 trans_id = p_data->req_data.trans_id;
UINT16 conn_id = p_data->req_data.conn_id; UINT16 conn_id = p_data->req_data.conn_id;
@ -219,7 +219,7 @@ static void bas_gatts_callback(tBTA_GATTS_EVT event, tBTA_GATTS* p_data)
} }
break; break;
case BTA_GATTS_CONF_EVT: case ESP_GATTS_CFM_EVT:
{ {
UINT32 trans_id = p_data->req_data.trans_id; UINT32 trans_id = p_data->req_data.trans_id;
@ -231,6 +231,7 @@ static void bas_gatts_callback(tBTA_GATTS_EVT event, tBTA_GATTS* p_data)
default: default:
LOG_ERROR("unsettled event: %d\n", event); LOG_ERROR("unsettled event: %d\n", event);
break;
} }
} }
@ -243,7 +244,7 @@ static void bas_callback(UINT32 trans_id, UINT16 conn_id, UINT8 app_id,
UINT8 event, tBA_WRITE_DATA *p_data) UINT8 event, tBA_WRITE_DATA *p_data)
{ {
tBA_RSP_DATA p_rsp; tBA_RSP_DATA p_rsp;
tGATT_STATUS st = GATT_SUCCESS; tGATT_STATUS st = ESP_GATT_OK;
switch(event) switch(event)
{ {
case BA_READ_LEVEL_REQ : case BA_READ_LEVEL_REQ :
@ -299,10 +300,10 @@ static void bas_callback(UINT32 trans_id, UINT16 conn_id, UINT8 app_id,
void bas_s_read_attr_value(tGATTS_DATA *p_data, UINT32 trans_id, UINT16 conn_id) void bas_s_read_attr_value(tGATTS_DATA *p_data, UINT32 trans_id, UINT16 conn_id)
{ {
tBA_INST *p_inst = &battery_cb.battery_inst[0]; tBA_INST *p_inst = &battery_cb.battery_inst[0];
UINT8 i; UINT8 i;
tGATT_STATUS st = GATT_NOT_FOUND; esp_gatt_status_t st = ESP_GATT_NOT_FOUND;
UINT16 handle = p_data->read_req.handle; UINT16 handle = p_data->read_req.handle;
for (i = 0; i < BA_MAX_INT_NUM; i ++, p_inst ++) for (i = 0; i < BA_MAX_INT_NUM; i ++, p_inst ++)
@ -314,7 +315,7 @@ void bas_s_read_attr_value(tGATTS_DATA *p_data, UINT32 trans_id, UINT16 conn_id)
handle == p_inst->pres_fmt_hdl) handle == p_inst->pres_fmt_hdl)
{ {
if (p_data->read_req.is_long) if (p_data->read_req.is_long)
st = GATT_NOT_LONG; st = ESP_GATT_NOT_LONG;
if (p_inst->p_cback) if (p_inst->p_cback)
{ {
@ -329,7 +330,7 @@ void bas_s_read_attr_value(tGATTS_DATA *p_data, UINT32 trans_id, UINT16 conn_id)
(*p_inst->p_cback)(trans_id, conn_id, p_inst->app_id, p_inst->pending_evt, NULL); (*p_inst->p_cback)(trans_id, conn_id, p_inst->app_id, p_inst->pending_evt, NULL);
} }
else /* application is not registered */ else /* application is not registered */
st = GATT_ERR_UNLIKELY; st = ESP_GATT_ERR_UNLIKELY;
break; break;
} }
/* else attribute not found */ /* else attribute not found */
@ -343,12 +344,12 @@ void bas_s_read_attr_value(tGATTS_DATA *p_data, UINT32 trans_id, UINT16 conn_id)
******************************************************************************/ ******************************************************************************/
void bas_s_write_attr_value(tGATTS_DATA *p_data, UINT32 trans_id, UINT16 conn_id, BD_ADDR bd_addr) void bas_s_write_attr_value(tGATTS_DATA *p_data, UINT32 trans_id, UINT16 conn_id, BD_ADDR bd_addr)
{ {
tBA_WRITE_DATA cfg; tBA_WRITE_DATA cfg;
UINT8 *p = p_data->write_req.value; UINT8 *p = p_data->write_req.value;
tBA_INST *p_inst = &battery_cb.battery_inst[0]; tBA_INST *p_inst = &battery_cb.battery_inst[0];
UINT8 i; UINT8 i;
tGATT_STATUS st = GATT_NOT_FOUND; esp_gatt_status_t st = ESP_GATT_NOT_FOUND;
UINT16 handle = p_data->write_req.handle; UINT16 handle = p_data->write_req.handle;
for (i = 0; i < BA_MAX_INT_NUM; i ++, p_inst ++) for (i = 0; i < BA_MAX_INT_NUM; i ++, p_inst ++)
@ -366,7 +367,7 @@ void bas_s_write_attr_value(tGATTS_DATA *p_data, UINT32 trans_id, UINT16 conn_id
(*p_inst->p_cback)(trans_id, conn_id, p_inst->app_id, p_inst->pending_evt, &cfg); (*p_inst->p_cback)(trans_id, conn_id, p_inst->app_id, p_inst->pending_evt, &cfg);
} }
else /* all other handle is not writable */ else /* all other handle is not writable */
st = GATT_WRITE_NOT_PERMIT; st = ESP_GATT_WRITE_NOT_PERMIT;
break; break;
} }
@ -381,7 +382,7 @@ void bas_s_write_attr_value(tGATTS_DATA *p_data, UINT32 trans_id, UINT16 conn_id
****************************************************************/ ****************************************************************/
void bas_register(void) void bas_register(void)
{ {
BTA_GATTS_AppRegister(&bas_uuid, bas_gatts_callback); esp_ble_gatts_app_register(&bas_uuid, bas_gatts_callback);
} }
/*************************************************************** /***************************************************************
@ -410,7 +411,7 @@ void bas_init(tBTA_GATTS_IF gatt_if, UINT16 app_id)
LOG_ERROR("create battery service\n"); LOG_ERROR("create battery service\n");
LOG_ERROR("inst_id=%d\n", battery_cb.inst_id); LOG_ERROR("inst_id=%d\n", battery_cb.inst_id);
BTA_GATTS_CreateService (gatt_if, &bas_uuid, battery_cb.inst_id , esp_ble_gatts_create_srvc (gatt_if, &bas_uuid, battery_cb.inst_id ,
BA_MAX_ATTR_NUM, ba_reg_info.is_pri); BA_MAX_ATTR_NUM, ba_reg_info.is_pri);
battery_cb.inst_id ++; battery_cb.inst_id ++;
@ -432,7 +433,7 @@ void bas_AddChar(UINT16 service_id, tBT_UUID *char_uuid)
if (ba_reg_info.ba_level_descr & BA_LEVEL_NOTIFY) if (ba_reg_info.ba_level_descr & BA_LEVEL_NOTIFY)
prop |= GATT_CHAR_PROP_BIT_NOTIFY; prop |= GATT_CHAR_PROP_BIT_NOTIFY;
attr_handle_bit = 0x01; attr_handle_bit = 0x01;
BTA_GATTS_AddCharacteristic(service_id, char_uuid, BATTER_LEVEL_PERM, prop); esp_ble_gatts_add_char(service_id, char_uuid, BATTER_LEVEL_PERM, prop);
} }
@ -468,7 +469,7 @@ void bas_AddCharDescr(UINT16 service_id, UINT16 attr_id)
uuid.uu.uuid16 = GATT_UUID_CHAR_CLIENT_CONFIG; uuid.uu.uuid16 = GATT_UUID_CHAR_CLIENT_CONFIG;
ba_reg_info.ba_level_descr &= 0xfe; ba_reg_info.ba_level_descr &= 0xfe;
attr_handle_bit = 0x02; attr_handle_bit = 0x02;
BTA_GATTS_AddCharDescriptor(service_id, (GATT_PERM_READ|GATT_PERM_WRITE), &uuid); esp_ble_gatts_add_char_descr(service_id, (GATT_PERM_READ|GATT_PERM_WRITE), &uuid);
return; return;
} }
@ -476,7 +477,7 @@ void bas_AddCharDescr(UINT16 service_id, UINT16 attr_id)
if (ba_reg_info.ba_level_descr & BA_LEVEL_PRE_FMT) if (ba_reg_info.ba_level_descr & BA_LEVEL_PRE_FMT)
{ {
uuid.uu.uuid16 = GATT_UUID_CHAR_PRESENT_FORMAT; uuid.uu.uuid16 = GATT_UUID_CHAR_PRESENT_FORMAT;
BTA_GATTS_AddCharDescriptor(service_id, GATT_PERM_READ, &uuid); esp_ble_gatts_add_char_descr(service_id, GATT_PERM_READ, &uuid);
ba_reg_info.ba_level_descr &= 0xfd; ba_reg_info.ba_level_descr &= 0xfd;
attr_handle_bit = 0x04; attr_handle_bit = 0x04;
return; return;
@ -486,14 +487,14 @@ void bas_AddCharDescr(UINT16 service_id, UINT16 attr_id)
{ {
uuid.uu.uuid16 = GATT_UUID_RPT_REF_DESCR; uuid.uu.uuid16 = GATT_UUID_RPT_REF_DESCR;
ba_reg_info.ba_level_descr &= 0xfb; ba_reg_info.ba_level_descr &= 0xfb;
BTA_GATTS_AddCharDescriptor(service_id, GATT_PERM_READ, &uuid); esp_ble_gatts_add_char_descr(service_id, GATT_PERM_READ, &uuid);
attr_handle_bit = 0x08; attr_handle_bit = 0x08;
return; return;
} }
} }
else else
BTA_GATTS_StartService(service_id, ba_reg_info.transport); esp_ble_gatts_start_srvc(service_id);
} }
@ -504,12 +505,12 @@ void bas_AddCharDescr(UINT16 service_id, UINT16 attr_id)
** Description create battery service complete ** Description create battery service complete
** **
****************************************************************/ ****************************************************************/
void bas_service_cmpl(UINT16 service_id, tBTA_GATT_STATUS status) void bas_service_cmpl(UINT16 service_id, esp_gatt_status_t status)
{ {
if(status != GATT_SUCCESS) if(status != ESP_GATT_OK)
{ {
battery_cb.inst_id --; battery_cb.inst_id --;
BTA_GATTS_DeleteService(service_id); esp_ble_gatts_dele_srvc(service_id);
} }
} }
@ -521,7 +522,7 @@ void bas_service_cmpl(UINT16 service_id, tBTA_GATT_STATUS status)
** **
*******************************************************************************/ *******************************************************************************/
void Battery_Rsp (UINT32 trans_id, UINT16 conn_id, UINT8 app_id, void Battery_Rsp (UINT32 trans_id, UINT16 conn_id, UINT8 app_id,
tGATT_STATUS st, UINT8 event, tBA_RSP_DATA *p_rsp) esp_gatt_status_t st, UINT8 event, tBA_RSP_DATA *p_rsp)
{ {
tBA_INST *p_inst = &battery_cb.battery_inst[0]; tBA_INST *p_inst = &battery_cb.battery_inst[0];
tGATTS_RSP rsp; tGATTS_RSP rsp;
@ -549,7 +550,7 @@ void Battery_Rsp (UINT32 trans_id, UINT16 conn_id, UINT8 app_id,
rsp.attr_value.len = 2; rsp.attr_value.len = 2;
pp = rsp.attr_value.value; pp = rsp.attr_value.value;
UINT16_TO_STREAM(pp, p_rsp->clt_cfg); UINT16_TO_STREAM(pp, p_rsp->clt_cfg);
BTA_GATTS_SendRsp(conn_id, trans_id, st, &rsp); esp_ble_gatts_send_rsp(conn_id, trans_id, st, &rsp);
//srvc_sr_rsp(p_inst->pending_clcb_idx, st, &rsp); //srvc_sr_rsp(p_inst->pending_clcb_idx, st, &rsp);
break; break;
@ -558,12 +559,12 @@ void Battery_Rsp (UINT32 trans_id, UINT16 conn_id, UINT8 app_id,
rsp.attr_value.len = 1; rsp.attr_value.len = 1;
pp = rsp.attr_value.value; pp = rsp.attr_value.value;
UINT8_TO_STREAM(pp, p_rsp->ba_level); UINT8_TO_STREAM(pp, p_rsp->ba_level);
BTA_GATTS_SendRsp(conn_id, trans_id, st, &rsp); esp_ble_gatts_send_rsp(conn_id, trans_id, st, &rsp);
//srvc_sr_rsp(p_inst->pending_clcb_idx, st, &rsp); //srvc_sr_rsp(p_inst->pending_clcb_idx, st, &rsp);
break; break;
case BA_WRITE_CLT_CFG_REQ: case BA_WRITE_CLT_CFG_REQ:
BTA_GATTS_SendRsp(conn_id, trans_id, st, NULL); esp_ble_gatts_send_rsp(conn_id, trans_id, st, NULL);
//srvc_sr_rsp(p_inst->pending_clcb_idx, st, NULL); //srvc_sr_rsp(p_inst->pending_clcb_idx, st, NULL);
break; break;
@ -573,7 +574,7 @@ void Battery_Rsp (UINT32 trans_id, UINT16 conn_id, UINT8 app_id,
pp = rsp.attr_value.value; pp = rsp.attr_value.value;
UINT8_TO_STREAM(pp, p_rsp->rpt_ref.rpt_id); UINT8_TO_STREAM(pp, p_rsp->rpt_ref.rpt_id);
UINT8_TO_STREAM(pp, p_rsp->rpt_ref.rpt_type); UINT8_TO_STREAM(pp, p_rsp->rpt_ref.rpt_type);
BTA_GATTS_SendRsp(conn_id, trans_id, st, &rsp); esp_ble_gatts_send_rsp(conn_id, trans_id, st, &rsp);
//srvc_sr_rsp(p_inst->pending_clcb_idx, st, &rsp); //srvc_sr_rsp(p_inst->pending_clcb_idx, st, &rsp);
break; break;
@ -607,7 +608,7 @@ void Battery_Notify (UINT16 conn_id, UINT8 app_id, BD_ADDR remote_bda, UINT8 bat
if (i == BA_MAX_INT_NUM || p_inst->clt_cfg_hdl == 0) if (i == BA_MAX_INT_NUM || p_inst->clt_cfg_hdl == 0)
return; return;
BTA_GATTS_HandleValueIndication(conn_id, p_inst->ba_level_hdl, 1, &battery_level, false); esp_ble_gatts_hdl_val_indica(conn_id, p_inst->ba_level_hdl, 1, &battery_level, false);
//srvc_sr_notify(remote_bda, p_inst->ba_level_hdl, 1, &battery_level); //srvc_sr_notify(remote_bda, p_inst->ba_level_hdl, 1, &battery_level);
} }

30
components/bt/bluedroid/profiles/std/dis/dis_profile.c
View file

@ -44,10 +44,10 @@
#define STREAM_TO_UINT64(u64, p) {u64 = (((UINT64)(*(p))) + ((((UINT64)(*((p) + 1)))) << 8) + ((((UINT64)(*((p) + 2)))) << 16) + ((((UINT64)(*((p) + 3)))) << 24) \ #define STREAM_TO_UINT64(u64, p) {u64 = (((UINT64)(*(p))) + ((((UINT64)(*((p) + 1)))) << 8) + ((((UINT64)(*((p) + 2)))) << 16) + ((((UINT64)(*((p) + 3)))) << 24) \
+ ((((UINT64)(*((p) + 4)))) << 32) + ((((UINT64)(*((p) + 5)))) << 40) + ((((UINT64)(*((p) + 6)))) << 48) + ((((UINT64)(*((p) + 7)))) << 56)); (p) += 8;} + ((((UINT64)(*((p) + 4)))) << 32) + ((((UINT64)(*((p) + 5)))) << 40) + ((((UINT64)(*((p) + 6)))) << 48) + ((((UINT64)(*((p) + 7)))) << 56)); (p) += 8;}
tBT_UUID uuid = {LEN_UUID_16, {UUID_SERVCLASS_DEVICE_INFO}}; esp_bt_uuid_t uuid = {LEN_UUID_16, {UUID_SERVCLASS_DEVICE_INFO}};
UINT16 i = 0; UINT16 i = 0;
tDIS_ATTR_MASK dis_mask; tDIS_ATTR_MASK dis_mask;
static const UINT16 dis_attr_uuid[DIS_MAX_CHAR_NUM] = static const UINT16 dis_attr_uuid[DIS_MAX_CHAR_NUM] =
{ {
GATT_UUID_SYSTEM_ID, GATT_UUID_SYSTEM_ID,
GATT_UUID_MODEL_NUMBER_STR, GATT_UUID_MODEL_NUMBER_STR,
@ -106,12 +106,12 @@ BOOLEAN dis_valid_handle_range(UINT16 handle)
** **
** Process write DIS attribute request. ** Process write DIS attribute request.
*******************************************************************************/ *******************************************************************************/
UINT8 dis_write_attr_value(tGATT_WRITE_REQ * p_data, tGATT_STATUS *p_status) UINT8 dis_write_attr_value(tGATT_WRITE_REQ * p_data, esp_gatt_status_t *p_status)
{ {
UNUSED(p_data); UNUSED(p_data);
*p_status = GATT_WRITE_NOT_PERMIT; *p_status = GATT_WRITE_NOT_PERMIT;
return GATT_SUCCESS; return ESP_GATT_OK;
} }
/******************************************************************************* /*******************************************************************************
** DIS Attributes Database Server Request callback ** DIS Attributes Database Server Request callback
@ -127,7 +127,7 @@ void dis_s_read_attr_value (tGATTS_DATA *p_data, tGATT_VALUE *p_value, UINT32 tr
tDIS_DB_ENTRY *p_db_attr = dis_cb.dis_attr; tDIS_DB_ENTRY *p_db_attr = dis_cb.dis_attr;
UINT8 *p = p_value->value, i, *pp; UINT8 *p = p_value->value, i, *pp;
UINT16 offset = p_data->read_req.offset; UINT16 offset = p_data->read_req.offset;
tGATT_STATUS st = GATT_NOT_FOUND; tGATT_STATUS st = ESP_GATT_NOT_FOUND;
UINT16 handle = p_data->read_req.handle; UINT16 handle = p_data->read_req.handle;
bool is_long = p_data->read_req.is_long; bool is_long = p_data->read_req.is_long;
@ -138,10 +138,10 @@ void dis_s_read_attr_value (tGATTS_DATA *p_data, tGATT_VALUE *p_value, UINT32 tr
if ((p_db_attr->uuid == GATT_UUID_PNP_ID || p_db_attr->uuid == GATT_UUID_SYSTEM_ID)&& if ((p_db_attr->uuid == GATT_UUID_PNP_ID || p_db_attr->uuid == GATT_UUID_SYSTEM_ID)&&
is_long == TRUE) is_long == TRUE)
{ {
st = GATT_NOT_LONG; st = ESP_GATT_NOT_LONG;
break; break;
} }
st = GATT_SUCCESS; st = ESP_GATT_NOT_FOUND;
switch (p_db_attr->uuid) switch (p_db_attr->uuid)
{ {
@ -165,7 +165,7 @@ void dis_s_read_attr_value (tGATTS_DATA *p_data, tGATT_VALUE *p_value, UINT32 tr
if (offset > p_value->len) if (offset > p_value->len)
{ {
st = GATT_INVALID_OFFSET; st = ESP_GATT_INVALID_OFFSET;
break; break;
} }
else else
@ -197,7 +197,7 @@ void dis_s_read_attr_value (tGATTS_DATA *p_data, tGATT_VALUE *p_value, UINT32 tr
} }
tGATTS_RSP rsp; tGATTS_RSP rsp;
rsp.attr_value = *p_value; rsp.attr_value = *p_value;
BTA_GATTS_SendRsp(conn_id, trans_id, st, &rsp); esp_ble_gatts_send_rsp(conn_id, trans_id, st, &rsp);
} }
@ -209,7 +209,7 @@ void dis_s_read_attr_value (tGATTS_DATA *p_data, tGATT_VALUE *p_value, UINT32 tr
** Description Initialize the Device Information Service Server. ** Description Initialize the Device Information Service Server.
** **
*******************************************************************************/ *******************************************************************************/
void DIS_Init (tBTA_GATTS_IF gatt_if, tDIS_ATTR_MASK dis_attr_mask) void DIS_Init (esp_gatts_if_t gatt_if, tDIS_ATTR_MASK dis_attr_mask)
{ {
tGATT_STATUS status; tGATT_STATUS status;
@ -222,7 +222,7 @@ void DIS_Init (tBTA_GATTS_IF gatt_if, tDIS_ATTR_MASK dis_attr_mask)
memset(&dis_cb, 0, sizeof(tDIS_CB)); memset(&dis_cb, 0, sizeof(tDIS_CB));
BTA_GATTS_CreateService (gatt_if , &uuid, 0, DIS_MAX_ATTR_NUM, TRUE); esp_ble_gatts_create_srvc (gatt_if , &uuid, 0, DIS_MAX_ATTR_NUM, TRUE);
} }
/******************************************************************************* /*******************************************************************************
@ -241,14 +241,14 @@ void dis_AddChar(UINT16 service_id)
while(dis_mask != 0 && i < DIS_MAX_CHAR_NUM) while(dis_mask != 0 && i < DIS_MAX_CHAR_NUM)
{ {
uuid.uu.uuid16 = p_db_attr->uuid = dis_attr_uuid[i]; uuid.uu.uuid16 = p_db_attr->uuid = dis_attr_uuid[i];
BTA_GATTS_AddCharacteristic(dis_cb.service_handle, &uuid, GATT_PERM_READ, esp_ble_gatts_add_char(dis_cb.service_handle, &uuid, GATT_PERM_READ,
GATT_CHAR_PROP_BIT_READ); GATT_CHAR_PROP_BIT_READ);
p_db_attr ++; p_db_attr ++;
i ++; i ++;
dis_mask >>= 1; dis_mask >>= 1;
} }
/*start service*/ /*start service*/
BTA_GATTS_StartService(dis_cb.service_handle, GATT_TRANSPORT_LE_BR_EDR); esp_ble_gatts_start_srvc(dis_cb.service_handle);
dis_cb.enabled = TRUE; dis_cb.enabled = TRUE;
} }
/******************************************************************************* /*******************************************************************************

162
components/bt/bluedroid/profiles/std/hid_le/hid_le_prf.c
View file

@ -16,14 +16,14 @@
#include "prf_defs.h" #include "prf_defs.h"
#if (HIDD_LE_PROFILE_CFG) #if (HIDD_LE_PROFILE_CFG)
tHIDD_LE_ENV hidd_le_env; hidd_le_env_t hidd_le_env;
#define HI_UINT16(a) (((a) >> 8) & 0xFF) #define HI_UINT16(a) (((a) >> 8) & 0xFF)
#define LO_UINT16(a) ((a) & 0xFF) #define LO_UINT16(a) ((a) & 0xFF)
// HID Information characteristic value // HID Information characteristic value
static const UINT8 hidInfo[HID_INFORMATION_LEN] = static const uint8_t hidInfo[HID_INFORMATION_LEN] =
{ {
LO_UINT16(0x0111), HI_UINT16(0x0111), // bcdHID (USB HID version) LO_UINT16(0x0111), HI_UINT16(0x0111), // bcdHID (USB HID version)
0x00, // bCountryCode 0x00, // bCountryCode
@ -32,7 +32,7 @@ static const UINT8 hidInfo[HID_INFORMATION_LEN] =
// HID Report Map characteristic value // HID Report Map characteristic value
// Keyboard report descriptor (using format for Boot interface descriptor) // Keyboard report descriptor (using format for Boot interface descriptor)
static const UINT8 hidReportMap[] = static const uint8_t hidReportMap[] =
{ {
0x05, 0x01, // Usage Page (Generic Desktop) 0x05, 0x01, // Usage Page (Generic Desktop)
0x09, 0x02, // Usage (Mouse) 0x09, 0x02, // Usage (Mouse)
@ -169,27 +169,27 @@ static const UINT8 hidReportMap[] =
}; };
// HID report map length // HID report map length
UINT8 hidReportMapLen = sizeof(hidReportMap); uint8_t hidReportMapLen = sizeof(hidReportMap);
UINT8 hidProtocolMode = HID_PROTOCOL_MODE_REPORT; uint8_t hidProtocolMode = HID_PROTOCOL_MODE_REPORT;
// HID report mapping table // HID report mapping table
static hidRptMap_t hidRptMap[HID_NUM_REPORTS]; static hidRptMap_t hidRptMap[HID_NUM_REPORTS];
tBT_UUID char_info_uuid = {LEN_UUID_16, {CHAR_HID_INFO_UUID}}; esp_bt_uuid_t char_info_uuid = {LEN_UUID_16, {CHAR_HID_INFO_UUID}};
tBT_UUID char_ctnl_pt_uuid = {LEN_UUID_16, {CHAR_HID_CTNL_PT_UUID}}; esp_bt_uuid_t char_ctnl_pt_uuid = {LEN_UUID_16, {CHAR_HID_CTNL_PT_UUID}};
tBT_UUID char_report_map_uuid = {LEN_UUID_16, {CHAR_REPORT_MAP_UUID}}; esp_bt_uuid_t char_report_map_uuid = {LEN_UUID_16, {CHAR_REPORT_MAP_UUID}};
tBT_UUID char_report_uuid = {LEN_UUID_16, {CHAR_REPORT_UUID}}; esp_bt_uuid_t char_report_uuid = {LEN_UUID_16, {CHAR_REPORT_UUID}};
tBT_UUID char_proto_mode_uuid = {LEN_UUID_16, {CHAR_PROTOCOL_MODE_UUID}}; esp_bt_uuid_t char_proto_mode_uuid = {LEN_UUID_16, {CHAR_PROTOCOL_MODE_UUID}};
tBT_UUID char_kb_in_report_uuid = {LEN_UUID_16, {CHAR_BOOT_KB_IN_REPORT_UUID}}; esp_bt_uuid_t char_kb_in_report_uuid = {LEN_UUID_16, {CHAR_BOOT_KB_IN_REPORT_UUID}};
tBT_UUID char_kb_out_report_uuid = {LEN_UUID_16,{CHAR_BOOT_KB_OUT_REPORT_UUID}}; esp_bt_uuid_t char_kb_out_report_uuid = {LEN_UUID_16,{CHAR_BOOT_KB_OUT_REPORT_UUID}};
tBT_UUID char_mouse_in_report_uuid = {LEN_UUID_16,{CHAR_BOOT_MOUSE_IN_REPORT_UUID}}; esp_bt_uuid_t char_mouse_in_report_uuid = {LEN_UUID_16,{CHAR_BOOT_MOUSE_IN_REPORT_UUID}};
/// Full HID device Database Description - Used to add attributes into the database /// Full HID device Database Description - Used to add attributes into the database
const tCHAR_DESC hids_char_db[HIDD_LE_CHAR_MAX] = const char_desc_t hids_char_db[HIDD_LE_CHAR_MAX] =
{ {
// HID Information Characteristic Value // HID Information Characteristic Value
[HIDD_LE_INFO_CHAR] = { [HIDD_LE_INFO_CHAR] = {
@ -247,25 +247,25 @@ const tCHAR_DESC hids_char_db[HIDD_LE_CHAR_MAX] =
}, },
}; };
static void HID_AddCharacteristic(const tCHAR_DESC *char_desc); static void hidd_add_characterisitc(const char_desc_t *char_desc);
/***************************************************************************** /*****************************************************************************
** Constants ** Constants
*****************************************************************************/ *****************************************************************************/
static void hidd_le_profile_cb(tBTA_GATTS_EVT event, tBTA_GATTS *p_data); static void hidd_le_profile_cb(esp_gatts_evt_t event, esp_gatts_t *p_data);
/******************************************************************************* /*******************************************************************************
** **
** Function hidd_le_profile_cb ** Function hidd_add_characterisitc
** **
** Description the callback function after the hid device profile has been register to the BTA manager module ** Description the callback function after the hid device profile has been register to the BTA manager module
** **
** Returns NULL ** Returns NULL
** **
*******************************************************************************/ *******************************************************************************/
static void HID_AddCharacteristic(const tCHAR_DESC *char_desc) static void hidd_add_characterisitc(const char_desc_t *char_desc)
{ {
UINT16 service_id; uint16_t service_id;
if(char_desc == NULL) if(char_desc == NULL)
{ {
LOG_ERROR("Invalid hid characteristic\n"); LOG_ERROR("Invalid hid characteristic\n");
@ -282,7 +282,7 @@ static void HID_AddCharacteristic(const tCHAR_DESC *char_desc)
if(char_desc->char_uuid != 0x00) if(char_desc->char_uuid != 0x00)
{ {
// start added the charact to the data base // start added the charact to the data base
BTA_GATTS_AddCharacteristic(service_id, esp_ble_gatts_add_char (service_id,
char_desc->char_uuid, char_desc->char_uuid,
char_desc->perm, char_desc->perm,
char_desc->prop); char_desc->prop);
@ -299,19 +299,19 @@ static void HID_AddCharacteristic(const tCHAR_DESC *char_desc)
** Returns NULL ** Returns NULL
** **
*******************************************************************************/ *******************************************************************************/
static void hidd_le_profile_cb(tBTA_GATTS_EVT event, tBTA_GATTS *p_data) static void hidd_le_profile_cb(esp_gatts_evt_t event, esp_gatts_t *p_data)
{ {
tBTA_GATTS_RSP rsp; esp_gatts_rsp_t rsp;
tBT_UUID uuid = {LEN_UUID_16, {ATT_SVC_HID}}; esp_bt_uuid_t uuid = {LEN_UUID_16, {ATT_SVC_HID}};
static UINT8 hid_char_idx; static uint8_t hid_char_idx;
tHIDD_CLCB *p_clcb = NULL; hidd_clcb_t *p_clcb = NULL;
UINT8 app_id = 0xff; uint8_t app_id = 0xff;
switch(event) switch(event)
{ {
case BTA_GATTS_REG_EVT: case ESP_GATTS_REG_EVT:
//check the register of the hid device profile has been succeess or not //check the register of the hid device profile has been succeess or not
if(p_data->reg_oper.status != BTA_GATT_OK) if(p_data->reg_oper.status != ESP_GATT_OK)
{ {
LOG_ERROR("hidd profile register failed\n"); LOG_ERROR("hidd profile register failed\n");
} }
@ -323,27 +323,27 @@ static void hidd_le_profile_cb(tBTA_GATTS_EVT event, tBTA_GATTS *p_data)
//create the hid device service to the service data base. //create the hid device service to the service data base.
if(p_data->reg_oper.uuid.uu.uuid16 == ATT_SVC_HID) if(p_data->reg_oper.uuid.uu.uuid16 == ATT_SVC_HID)
{ {
hidd_le_CreateService(true); hidd_le_create_service(true);
} }
break; break;
case BTA_GATTS_CREATE_EVT: case ESP_GATTS_CREATE_EVT:
if(p_data->create.uuid.uu.uuid16 == ATT_SVC_HID) if(p_data->create.uuid.uu.uuid16 == ATT_SVC_HID)
{ {
///store the service id to the env ///store the service id to the env
hidd_le_env.hidd_clcb.cur_srvc_id = p_data->create.service_id; hidd_le_env.hidd_clcb.cur_srvc_id = p_data->create.service_id;
//start the button service after created //start the button service after created
BTA_GATTS_StartService(p_data->create.service_id,BTA_GATT_TRANSPORT_LE); esp_ble_gatts_start_srvc(p_data->create.service_id);
hid_char_idx = HIDD_LE_INFO_CHAR; hid_char_idx = HIDD_LE_INFO_CHAR;
//added the info character to the data base. //added the info character to the data base.
HID_AddCharacteristic(&hids_char_db[hid_char_idx]); hidd_add_characterisitc(&hids_char_db[hid_char_idx]);
hid_char_idx++; hid_char_idx++;
} }
break; break;
case BTA_GATTS_ADD_INCL_SRVC_EVT: case ESP_GATTS_ADD_INCL_SRVC_EVT:
break; break;
case BTA_GATTS_ADD_CHAR_EVT: case ESP_GATTS_ADD_CHAR_EVT:
//save the charateristic handle to the env //save the charateristic handle to the env
hidd_le_env.hidd_inst.att_tbl[hid_char_idx-1] = p_data->add_result.attr_id; hidd_le_env.hidd_inst.att_tbl[hid_char_idx-1] = p_data->add_result.attr_id;
LOG_ERROR("hanlder = %x, p_data->add_result.char_uuid.uu.uuid16 = %x\n",p_data->add_result.attr_id, LOG_ERROR("hanlder = %x, p_data->add_result.char_uuid.uu.uuid16 = %x\n",p_data->add_result.attr_id,
@ -360,18 +360,18 @@ static void hidd_le_profile_cb(tBTA_GATTS_EVT event, tBTA_GATTS *p_data)
uuid.uu.uuid16 = GATT_UUID_CHAR_CLIENT_CONFIG; uuid.uu.uuid16 = GATT_UUID_CHAR_CLIENT_CONFIG;
LOG_ERROR("p_data->add_result.char_uuid.uu.uuid16 = %x\n", LOG_ERROR("p_data->add_result.char_uuid.uu.uuid16 = %x\n",
p_data->add_result.char_uuid.uu.uuid16); p_data->add_result.char_uuid.uu.uuid16);
BTA_GATTS_AddCharDescriptor (hidd_le_env.hidd_clcb.cur_srvc_id, esp_ble_gatts_add_char_descr (hidd_le_env.hidd_clcb.cur_srvc_id,
GATT_PERM_WRITE, GATT_PERM_WRITE,
&uuid); &uuid);
break; break;
} }
HID_AddCharacteristic(&hids_char_db[hid_char_idx]); hidd_add_characterisitc(&hids_char_db[hid_char_idx]);
} }
hid_char_idx++; hid_char_idx++;
break; break;
case BTA_GATTS_ADD_CHAR_DESCR_EVT: case ESP_GATTS_ADD_CHAR_DESCR_EVT:
if(p_data->add_result.char_uuid.uu.uuid16 == GATT_UUID_CHAR_CLIENT_CONFIG) if(p_data->add_result.char_uuid.uu.uuid16 == GATT_UUID_CHAR_CLIENT_CONFIG)
{ {
uuid.uu.uuid16 = GATT_UUID_RPT_REF_DESCR; uuid.uu.uuid16 = GATT_UUID_RPT_REF_DESCR;
@ -385,12 +385,12 @@ static void hidd_le_profile_cb(tBTA_GATTS_EVT event, tBTA_GATTS *p_data)
{ {
if(hid_char_idx < HIDD_LE_CHAR_MAX) if(hid_char_idx < HIDD_LE_CHAR_MAX)
{ {
HID_AddCharacteristic(&hids_char_db[hid_char_idx]); hidd_add_characterisitc(&hids_char_db[hid_char_idx]);
hid_char_idx++; hid_char_idx++;
} }
} }
break; break;
case BTA_GATTS_READ_EVT: case ESP_GATTS_READ_EVT:
{ {
LOG_ERROR("Hidd profile BTA_GATTS_READ_EVT\n"); LOG_ERROR("Hidd profile BTA_GATTS_READ_EVT\n");
UINT32 trans_id = p_data->req_data.trans_id; UINT32 trans_id = p_data->req_data.trans_id;
@ -403,11 +403,11 @@ static void hidd_le_profile_cb(tBTA_GATTS_EVT event, tBTA_GATTS *p_data)
hidd_read_attr_value(p_data->req_data.p_data,trans_id); hidd_read_attr_value(p_data->req_data.p_data,trans_id);
} }
break; break;
case BTA_GATTS_WRITE_EVT: case ESP_GATTS_WRITE_EVT:
BTA_GATTS_SendRsp(p_data->req_data.conn_id,p_data->req_data.trans_id, esp_ble_gatts_send_rsp (p_data->req_data.conn_id,p_data->req_data.trans_id,
p_data->req_data.status,NULL); p_data->req_data.status,NULL);
break; break;
case BTA_GATTS_CONNECT_EVT: case ESP_GATTS_CONNECT_EVT:
p_clcb = &hidd_le_env.hidd_clcb; p_clcb = &hidd_le_env.hidd_clcb;
if(!p_clcb->in_use) if(!p_clcb->in_use)
@ -419,16 +419,16 @@ static void hidd_le_profile_cb(tBTA_GATTS_EVT event, tBTA_GATTS *p_data)
memcpy(p_clcb->remote_bda, p_data->conn.remote_bda,BD_ADDR_LEN); memcpy(p_clcb->remote_bda, p_data->conn.remote_bda,BD_ADDR_LEN);
} }
break; break;
case BTA_GATTS_DISCONNECT_EVT: case ESP_GATTS_DISCONNECT_EVT:
p_clcb = &hidd_le_env.hidd_clcb; p_clcb = &hidd_le_env.hidd_clcb;
//set the connection flag to true //set the connection flag to true
p_clcb->connected = false; p_clcb->connected = false;
p_clcb->in_use = TRUE; p_clcb->in_use = TRUE;
memset(p_clcb->remote_bda,0,BD_ADDR_LEN); memset(p_clcb->remote_bda, 0, BD_ADDR_LEN);
break; break;
case BTA_GATTS_START_EVT: case ESP_GATTS_START_EVT:
break; break;
case BTA_GATTS_CONGEST_EVT: case ESP_GATTS_CONGEST_EVT:
if(hidd_le_env.hidd_clcb.connected && (hidd_le_env.hidd_clcb.conn_id == p_data->conn.conn_id)) if(hidd_le_env.hidd_clcb.connected && (hidd_le_env.hidd_clcb.conn_id == p_data->conn.conn_id))
{ {
//set the connection channal congested flag to true //set the connection channal congested flag to true
@ -442,7 +442,7 @@ static void hidd_le_profile_cb(tBTA_GATTS_EVT event, tBTA_GATTS *p_data)
/******************************************************************************* /*******************************************************************************
** **
** Function hidd_le_CreateService ** Function hidd_le_create_service
** **
** Description Create a Service for the hid device profile ** Description Create a Service for the hid device profile
** **
@ -453,17 +453,17 @@ static void hidd_le_profile_cb(tBTA_GATTS_EVT event, tBTA_GATTS *p_data)
** Returns NULL ** Returns NULL
** **
*******************************************************************************/ *******************************************************************************/
void hidd_le_CreateService(BOOLEAN is_primary) void hidd_le_create_service(BOOLEAN is_primary)
{ {
tBTA_GATTS_IF server_if ; esp_gatts_if_t server_if ;
tBT_UUID uuid = {LEN_UUID_16, {ATT_SVC_HID}}; esp_bt_uuid_t uuid = {LEN_UUID_16, {ATT_SVC_HID}};
//the number of the hid device attributes in the hid service. //the number of the hid device attributes in the hid service.
UINT16 num_handle = HIDD_LE_IDX_NB+5; UINT16 num_handle = HIDD_LE_IDX_NB;
UINT8 inst = 0x00; UINT8 inst = 0x00;
server_if = hidd_le_env.gatt_if; server_if = hidd_le_env.gatt_if;
hidd_le_env.inst_id = inst; hidd_le_env.inst_id = inst;
//start create the hid device service //start create the hid device service
BTA_GATTS_CreateService(server_if,&uuid,inst,num_handle,is_primary); esp_ble_gatts_create_srvc (server_if,&uuid,inst,num_handle,is_primary);
} }
@ -472,16 +472,16 @@ void hidd_le_CreateService(BOOLEAN is_primary)
** **
** Description it will be called when client sends a read request ** Description it will be called when client sends a read request
******************************************************************************/ ******************************************************************************/
void hidd_read_attr_value(tGATTS_DATA *p_data, UINT32 trans_id) void hidd_read_attr_value(tGATTS_DATA *p_data, uint32_t trans_id)
{ {
tHIDD_INST *p_inst = &hidd_le_env.hidd_inst; hidd_inst_t *p_inst = &hidd_le_env.hidd_inst;
UINT8 i; uint8_t i;
UINT8 status = GATT_SUCCESS; uint8_t status = ESP_GATT_OK;
UINT8 app_id = hidd_le_env.hidd_inst.app_id; uint8_t app_id = hidd_le_env.hidd_inst.app_id;
tGATT_STATUS st = GATT_NOT_FOUND; esp_gatt_status_t st = ESP_GATT_NOT_FOUND;
UINT16 handle = p_data->read_req.handle; uint16_t handle = p_data->read_req.handle;
UINT16 conn_id = hidd_le_env.hidd_clcb.conn_id; uint16_t conn_id = hidd_le_env.hidd_clcb.conn_id;
if (handle == p_inst->att_tbl[HIDD_LE_INFO_CHAR]) if (handle == p_inst->att_tbl[HIDD_LE_INFO_CHAR])
{ {
@ -512,22 +512,22 @@ void hidd_read_attr_value(tGATTS_DATA *p_data, UINT32 trans_id)
} }
//start build the rsp message //start build the rsp message
Hidd_Rsp(trans_id,conn_id,app_id,status, p_inst->pending_evt,p_data); hidd_rsp(trans_id, conn_id, app_id, status, p_inst->pending_evt, p_data);
} }
/******************************************************************************* /*******************************************************************************
** **
** Function Hidd_Rsp ** Function hidd_rsp
** **
** Description Respond to a hid device service request ** Description Respond to a hid device service request
** **
*******************************************************************************/ *******************************************************************************/
void Hidd_Rsp (UINT32 trans_id, UINT16 conn_id, UINT8 app_id, void hidd_rsp (uint32_t trans_id, uint16_t conn_id, uint8_t app_id,
tGATT_STATUS status, UINT8 event, tGATTS_DATA *p_rsp) esp_gatt_status_t status, uint8_t event, tGATTS_DATA *p_rsp)
{ {
tHIDD_INST *p_inst = &hidd_le_env.hidd_inst; hidd_inst_t *p_inst = &hidd_le_env.hidd_inst;
tGATTS_RSP rsp; tGATTS_RSP rsp;
UINT8 *pp; uint8_t *pp;
LOG_ERROR("conn_id = %x, trans_id = %x, event = %x\n", LOG_ERROR("conn_id = %x, trans_id = %x, event = %x\n",
conn_id,trans_id,event); conn_id,trans_id,event);
@ -548,7 +548,7 @@ void Hidd_Rsp (UINT32 trans_id, UINT16 conn_id, UINT8 app_id,
//copy the infomation value to the att value to sent to the peer device //copy the infomation value to the att value to sent to the peer device
memcpy(rsp.attr_value.value,hidInfo,HID_INFORMATION_LEN); memcpy(rsp.attr_value.value,hidInfo,HID_INFORMATION_LEN);
//start send the rsp to the peer device //start send the rsp to the peer device
BTA_GATTS_SendRsp(conn_id, trans_id, status, &rsp); esp_ble_gatts_send_rsp(conn_id, trans_id, status, &rsp);
break; break;
case HIDD_LE_READ_CTNL_PT_EVT: case HIDD_LE_READ_CTNL_PT_EVT:
@ -557,7 +557,7 @@ void Hidd_Rsp (UINT32 trans_id, UINT16 conn_id, UINT8 app_id,
rsp.attr_value.handle = p_inst->att_tbl[HIDD_LE_CTNL_PT_CHAR]; rsp.attr_value.handle = p_inst->att_tbl[HIDD_LE_CTNL_PT_CHAR];
rsp.attr_value.len = 0; rsp.attr_value.len = 0;
//start send the rsp to the peer device //start send the rsp to the peer device
BTA_GATTS_SendRsp(conn_id, trans_id, status, &rsp); esp_ble_gatts_send_rsp(conn_id, trans_id, status, &rsp);
break; break;
case HIDD_LE_READ_REPORT_MAP_EVT: case HIDD_LE_READ_REPORT_MAP_EVT:
@ -568,7 +568,7 @@ void Hidd_Rsp (UINT32 trans_id, UINT16 conn_id, UINT8 app_id,
//copy the infomation value to the att value to sent to the peer device //copy the infomation value to the att value to sent to the peer device
memcpy(rsp.attr_value.value,hidReportMap,hidReportMapLen); memcpy(rsp.attr_value.value,hidReportMap,hidReportMapLen);
//start send the rsp to the peer device //start send the rsp to the peer device
BTA_GATTS_SendRsp(conn_id, trans_id, status, &rsp); esp_ble_gatts_send_rsp(conn_id, trans_id, status, &rsp);
break; break;
case HIDD_LE_READ_REPORT_EVT: case HIDD_LE_READ_REPORT_EVT:
LOG_ERROR("p_inst->att_tbl[HIDD_LE_BOOT_KB_IN_REPORT_CHAR] = %x\n", LOG_ERROR("p_inst->att_tbl[HIDD_LE_BOOT_KB_IN_REPORT_CHAR] = %x\n",
@ -576,7 +576,7 @@ void Hidd_Rsp (UINT32 trans_id, UINT16 conn_id, UINT8 app_id,
rsp.attr_value.handle = p_inst->att_tbl[HIDD_LE_BOOT_KB_IN_REPORT_CHAR]; rsp.attr_value.handle = p_inst->att_tbl[HIDD_LE_BOOT_KB_IN_REPORT_CHAR];
rsp.attr_value.len = 0; rsp.attr_value.len = 0;
BTA_GATTS_SendRsp(conn_id, trans_id, status, &rsp); esp_ble_gatts_send_rsp(conn_id, trans_id, status, &rsp);
break; break;
case HIDD_LE_READ_PROTO_MODE_EVT: case HIDD_LE_READ_PROTO_MODE_EVT:
LOG_ERROR("p_inst->att_tbl[HIDD_LE_PROTO_MODE_CHAR] = %x\n", LOG_ERROR("p_inst->att_tbl[HIDD_LE_PROTO_MODE_CHAR] = %x\n",
@ -586,7 +586,7 @@ void Hidd_Rsp (UINT32 trans_id, UINT16 conn_id, UINT8 app_id,
pp = rsp.attr_value.value; pp = rsp.attr_value.value;
//copy the infomation value to the att value to sent to the peer device //copy the infomation value to the att value to sent to the peer device
memcpy(rsp.attr_value.value,&hidProtocolMode,rsp.attr_value.len); memcpy(rsp.attr_value.value,&hidProtocolMode,rsp.attr_value.len);
BTA_GATTS_SendRsp(conn_id, trans_id, status, &rsp); esp_ble_gatts_send_rsp(conn_id, trans_id, status, &rsp);
break; break;
case HIDD_LE_BOOT_KB_IN_REPORT_EVT: case HIDD_LE_BOOT_KB_IN_REPORT_EVT:
LOG_ERROR("p_inst->att_tbl[HIDD_LE_BOOT_KB_IN_REPORT_CHAR] = %x\n", LOG_ERROR("p_inst->att_tbl[HIDD_LE_BOOT_KB_IN_REPORT_CHAR] = %x\n",
@ -594,7 +594,7 @@ void Hidd_Rsp (UINT32 trans_id, UINT16 conn_id, UINT8 app_id,
rsp.attr_value.handle = p_inst->att_tbl[HIDD_LE_BOOT_KB_IN_REPORT_CHAR]; rsp.attr_value.handle = p_inst->att_tbl[HIDD_LE_BOOT_KB_IN_REPORT_CHAR];
rsp.attr_value.len = 0; rsp.attr_value.len = 0;
BTA_GATTS_SendRsp(conn_id, trans_id, status, &rsp); esp_ble_gatts_send_rsp(conn_id, trans_id, status, &rsp);
break; break;
case HIDD_LE_BOOT_KB_OUT_REPORT_EVT: case HIDD_LE_BOOT_KB_OUT_REPORT_EVT:
LOG_ERROR("p_inst->att_tbl[HIDD_LE_BOOT_KB_IN_REPORT_CHAR] = %x\n", LOG_ERROR("p_inst->att_tbl[HIDD_LE_BOOT_KB_IN_REPORT_CHAR] = %x\n",
@ -602,7 +602,7 @@ void Hidd_Rsp (UINT32 trans_id, UINT16 conn_id, UINT8 app_id,
rsp.attr_value.handle = p_inst->att_tbl[HIDD_LE_BOOT_KB_IN_REPORT_CHAR]; rsp.attr_value.handle = p_inst->att_tbl[HIDD_LE_BOOT_KB_IN_REPORT_CHAR];
rsp.attr_value.len = 0; rsp.attr_value.len = 0;
BTA_GATTS_SendRsp(conn_id, trans_id, status, &rsp); esp_ble_gatts_send_rsp(conn_id, trans_id, status, &rsp);
break; break;
case HIDD_LE_BOOT_MOUSE_IN_REPORT_EVT: case HIDD_LE_BOOT_MOUSE_IN_REPORT_EVT:
LOG_ERROR("p_inst->att_tbl[HIDD_LE_BOOT_KB_IN_REPORT_CHAR] = %x\n", LOG_ERROR("p_inst->att_tbl[HIDD_LE_BOOT_KB_IN_REPORT_CHAR] = %x\n",
@ -610,7 +610,7 @@ void Hidd_Rsp (UINT32 trans_id, UINT16 conn_id, UINT8 app_id,
rsp.attr_value.handle = p_inst->att_tbl[HIDD_LE_BOOT_KB_IN_REPORT_CHAR]; rsp.attr_value.handle = p_inst->att_tbl[HIDD_LE_BOOT_KB_IN_REPORT_CHAR];
rsp.attr_value.len = 0; rsp.attr_value.len = 0;
BTA_GATTS_SendRsp(conn_id, trans_id, status, &rsp); esp_ble_gatts_send_rsp(conn_id, trans_id, status, &rsp);
break; break;
default: default:
break; break;
@ -630,28 +630,28 @@ void Hidd_Rsp (UINT32 trans_id, UINT16 conn_id, UINT8 app_id,
** Description Initializa the GATT Service for button profiles. ** Description Initializa the GATT Service for button profiles.
** Returns NULL ** Returns NULL
*******************************************************************************/ *******************************************************************************/
tGATT_STATUS hidd_le_init (void) esp_gatt_status_t hidd_le_init (void)
{ {
tBT_UUID app_uuid = {LEN_UUID_16,{ATT_SVC_HID}}; tBT_UUID app_uuid = {LEN_UUID_16,{ATT_SVC_HID}};
if(hidd_le_env.enabled) if(hidd_le_env.enabled)
{ {
LOG_ERROR("hid device svc already initaliezd"); LOG_ERROR("hid device svc already initaliezd\n");
return GATT_ERROR; return ESP_GATT_ERROR;
} }
else else
{ {
memset(&hidd_le_env,0,sizeof(tHIDD_LE_ENV)); memset(&hidd_le_env,0,sizeof(hidd_le_env_t));
} }
/* /*
register the hid deivce profile to the BTA_GATTS module*/ register the hid deivce profile to the BTA_GATTS module*/
BTA_GATTS_AppRegister(&app_uuid,hidd_le_profile_cb); esp_ble_gatts_app_register(&app_uuid, hidd_le_profile_cb);
hidd_le_env.enabled = TRUE; hidd_le_env.enabled = TRUE;
return GATT_SUCCESS; return ESP_GATT_OK;
} }

1
components/bt/bluedroid/profiles/std/include/dis_api.h
View file

@ -28,6 +28,7 @@
#include "bt_target.h" #include "bt_target.h"
#include "gatt_api.h" #include "gatt_api.h"
#include "gattdefs.h" #include "gattdefs.h"
#include "bt_app_api.h"
#define DIS_SUCCESS GATT_SUCCESS #define DIS_SUCCESS GATT_SUCCESS
#define DIS_ILLEGAL_PARAM GATT_ILLEGAL_PARAMETER #define DIS_ILLEGAL_PARAM GATT_ILLEGAL_PARAMETER

65
components/bt/bluedroid/profiles/std/include/hid_le_prf.h
View file

@ -19,6 +19,7 @@
#include "bt_types.h" #include "bt_types.h"
#include "bta_api.h" #include "bta_api.h"
#include "gatt_api.h" #include "gatt_api.h"
#include "bt_app_api.h"
/// Maximal number of HIDS that can be added in the DB /// Maximal number of HIDS that can be added in the DB
#ifndef USE_ONE_HIDS_INSTANCE #ifndef USE_ONE_HIDS_INSTANCE
@ -195,76 +196,76 @@ enum
typedef struct typedef struct
{ {
/// Service Features /// Service Features
UINT8 svc_features; uint8_t svc_features;
/// Number of Report Char. instances to add in the database /// Number of Report Char. instances to add in the database
UINT8 report_nb; uint8_t report_nb;
/// Report Char. Configuration /// Report Char. Configuration
UINT8 report_char_cfg[HIDD_LE_NB_REPORT_INST_MAX]; uint8_t report_char_cfg[HIDD_LE_NB_REPORT_INST_MAX];
}tHIDD_FEATURE; }hidd_feature_t;
typedef struct typedef struct
{ {
BOOLEAN in_use; BOOLEAN in_use;
BOOLEAN congest; BOOLEAN congest;
UINT16 conn_id; uint16_t conn_id;
BOOLEAN connected; BOOLEAN connected;
BD_ADDR remote_bda; BD_ADDR remote_bda;
UINT32 trans_id; uint32_t trans_id;
UINT8 cur_srvc_id; uint8_t cur_srvc_id;
}tHIDD_CLCB; }hidd_clcb_t;
// HID report mapping table // HID report mapping table
typedef struct typedef struct
{ {
UINT16 handle; // Handle of report characteristic uint16_t handle; // Handle of report characteristic
UINT16 cccdHandle; // Handle of CCCD for report characteristic uint16_t cccdHandle; // Handle of CCCD for report characteristic
UINT8 id; // Report ID uint8_t id; // Report ID
UINT8 type; // Report type uint8_t type; // Report type
UINT8 mode; // Protocol mode (report or boot) uint8_t mode; // Protocol mode (report or boot)
} hidRptMap_t; } hidRptMap_t;
typedef struct typedef struct
{ {
/// hidd profile id /// hidd profile id
UINT8 app_id; uint8_t app_id;
/// Notified handle /// Notified handle
UINT16 ntf_handle; uint16_t ntf_handle;
///Attribute handle Table ///Attribute handle Table
UINT16 att_tbl[HIDD_LE_CHAR_MAX]; uint16_t att_tbl[HIDD_LE_CHAR_MAX];
/// Supported Features /// Supported Features
tHIDD_FEATURE hidd_feature[HIDD_LE_NB_HIDS_INST_MAX]; hidd_feature_t hidd_feature[HIDD_LE_NB_HIDS_INST_MAX];
/// Current Protocol Mode /// Current Protocol Mode
UINT8 proto_mode[HIDD_LE_NB_HIDS_INST_MAX]; uint8_t proto_mode[HIDD_LE_NB_HIDS_INST_MAX];
/// Number of HIDS added in the database /// Number of HIDS added in the database
UINT8 hids_nb; uint8_t hids_nb;
UINT8 pending_evt; uint8_t pending_evt;
UINT16 pending_hal; uint16_t pending_hal;
}tHIDD_INST; }hidd_inst_t;
/* service engine control block */ /* service engine control block */
typedef struct typedef struct
{ {
tHIDD_CLCB hidd_clcb; /* connection link*/ hidd_clcb_t hidd_clcb; /* connection link*/
tGATT_IF gatt_if; esp_gatt_if_t gatt_if;
BOOLEAN enabled; BOOLEAN enabled;
BOOLEAN is_primery; BOOLEAN is_primery;
tHIDD_INST hidd_inst; hidd_inst_t hidd_inst;
UINT8 inst_id; uint8_t inst_id;
}tHIDD_LE_ENV; }hidd_le_env_t;
extern tHIDD_LE_ENV hidd_le_env; extern hidd_le_env_t hidd_le_env;
void hidd_le_CreateService(BOOLEAN is_primary); void hidd_le_create_service(BOOLEAN is_primary);
void Hidd_Rsp (UINT32 trans_id, UINT16 conn_id, UINT8 app_id, void hidd_rsp (uint32_t trans_id, uint16_t conn_id, uint8_t app_id,
tGATT_STATUS status, UINT8 event, tGATTS_DATA *p_rsp); esp_gatt_status_t status, uint8_t event, tGATTS_DATA *p_rsp);
void hidd_read_attr_value(tGATTS_DATA *p_data, UINT32 trans_id); void hidd_read_attr_value(tGATTS_DATA *p_data, uint32_t trans_id);
tGATT_STATUS hidd_le_init (void); tGATT_STATUS hidd_le_init (void);

47
components/bt/bluedroid/profiles/std/include/prf_defs.h
View file

@ -19,6 +19,7 @@
#include "bta_gatts_int.h" #include "bta_gatts_int.h"
#include "bta_gatt_api.h" #include "bta_gatt_api.h"
#include "bt_types.h" #include "bt_types.h"
#include "bt_app_defs.h"
#define ATT_HANDLE_LEN 0x0002 #define ATT_HANDLE_LEN 0x0002
@ -26,59 +27,69 @@
#define ATT_UUID_128_LEN 0x0010 #define ATT_UUID_128_LEN 0x0010
#define ATT_UUID_32_LEN 0x0004 #define ATT_UUID_32_LEN 0x0004
#define WX_AIRSYNC_CFG 0 #define WX_AIRSYNC_CFG FALSE
#define BUT_PROFILE_CFG 0 #define BUT_PROFILE_CFG TRUE
#define HIDD_LE_PROFILE_CFG 1 #define HIDD_LE_PROFILE_CFG FALSE
/* /*
* Type Definition * Type Definition
**************************************************************************************** ****************************************************************************************
*/ */
/* Define the header of each buffer used in the profile stack.
*/
typedef struct
{
uint16_t event;
uint16_t len;
uint8_t data[];
} prf_hdr_evt_t;
/// Characteristic Value Descriptor /// Characteristic Value Descriptor
typedef struct typedef struct
{ {
///characteristic uuid ///characteristic uuid
tBT_UUID *char_uuid; esp_bt_uuid_t *char_uuid;
///the permition of the characteristic ///the permition of the characteristic
tBTA_GATT_PERM perm; esp_gatt_perm_t perm;
/// the properties of the characteristic /// the properties of the characteristic
tBTA_GATT_CHAR_PROP prop; esp_gatt_char_prop_t prop;
}tCHAR_DESC; }char_desc_t;
/// UUID - 128-bit type /// UUID - 128-bit type
typedef struct typedef struct
{ {
/// 128-bit UUID /// 128-bit UUID
UINT8 uuid[ATT_UUID_128_LEN]; uint8_t uuid[ATT_UUID_128_LEN];
}tUUID_128; }uuid_128_t;
/// UUID - 32-bit type /// UUID - 32-bit type
typedef struct typedef struct
{ {
/// 32-bit UUID /// 32-bit UUID
UINT8 uuid[ATT_UUID_32_LEN]; uint8_t uuid[ATT_UUID_32_LEN];
}tUUID_32; }uuid_32_t;
/// include service entry element /// include service entry element
typedef struct typedef struct
{ {
/// start handle value of included service /// start handle value of included service
UINT16 start_hdl; uint16_t start_hdl;
/// end handle value of included service /// end handle value of included service
UINT16 end_hdl; uint16_t end_hdl;
/// attribute value UUID /// attribute value UUID
UINT16 uuid; uint16_t uuid;
}tSVC_INCL_DESC; }incl_svc_desc;
/// Service Changed type definition /// Service Changed type definition
typedef struct typedef struct
{ {
/// Service start handle which changed /// Service start handle which changed
UINT16 start_hdl; uint16_t start_hdl;
/// Service end handle which changed /// Service end handle which changed
UINT16 end_hdl; uint16_t end_hdl;
}tSVC_CHANG; }svc_chang_type_t;

14
components/bt/bluedroid/stack/btm/btm_ble.c
View file

@ -453,7 +453,7 @@ void BTM_BleConfirmReply (BD_ADDR bd_addr, UINT8 res)
} }
p_dev_rec->sec_flags |= BTM_SEC_LE_AUTHENTICATED; p_dev_rec->sec_flags |= BTM_SEC_LE_AUTHENTICATED;
BTM_TRACE_DEBUG ("%s", __func__); BTM_TRACE_DEBUG ("%s\n", __func__);
SMP_ConfirmReply(bd_addr, res_smp); SMP_ConfirmReply(bd_addr, res_smp);
} }
@ -1620,12 +1620,12 @@ UINT8 btm_ble_io_capabilities_req(tBTM_SEC_DEV_REC *p_dev_rec, tBTM_LE_IO_REQ *p
p_data->resp_keys = 0; p_data->resp_keys = 0;
} }
BTM_TRACE_DEBUG ("btm_ble_io_capabilities_req 3: auth_req:%d", p_data->auth_req); BTM_TRACE_DEBUG ("btm_ble_io_capabilities_req 3: auth_req:%d\n", p_data->auth_req);
BTM_TRACE_DEBUG ("btm_ble_io_capabilities_req 4: i_keys=0x%x r_keys=0x%x", BTM_TRACE_DEBUG ("btm_ble_io_capabilities_req 4: i_keys=0x%x r_keys=0x%x\n",
p_data->init_keys, p_data->init_keys,
p_data->resp_keys); p_data->resp_keys);
BTM_TRACE_DEBUG ("btm_ble_io_capabilities_req 5: p_data->io_cap = %d auth_req:%d", BTM_TRACE_DEBUG ("btm_ble_io_capabilities_req 5: p_data->io_cap = %d auth_req:%d\n",
p_data->io_cap, p_data->auth_req); p_data->io_cap, p_data->auth_req);
/* remove MITM protection requirement if IO cap does not allow it */ /* remove MITM protection requirement if IO cap does not allow it */
@ -1644,7 +1644,7 @@ UINT8 btm_ble_io_capabilities_req(tBTM_SEC_DEV_REC *p_dev_rec, tBTM_LE_IO_REQ *p
p_data->resp_keys &= ~SMP_SEC_KEY_TYPE_LK; p_data->resp_keys &= ~SMP_SEC_KEY_TYPE_LK;
} }
BTM_TRACE_DEBUG ("btm_ble_io_capabilities_req 6: IO_CAP:%d oob_data:%d auth_req:0x%02x", BTM_TRACE_DEBUG ("btm_ble_io_capabilities_req 6: IO_CAP:%d oob_data:%d auth_req:0x%02x\n",
p_data->io_cap, p_data->oob_data, p_data->auth_req); p_data->io_cap, p_data->oob_data, p_data->auth_req);
} }
return callback_rc; return callback_rc;
@ -1663,7 +1663,7 @@ UINT8 btm_ble_io_capabilities_req(tBTM_SEC_DEV_REC *p_dev_rec, tBTM_LE_IO_REQ *p
UINT8 btm_ble_br_keys_req(tBTM_SEC_DEV_REC *p_dev_rec, tBTM_LE_IO_REQ *p_data) UINT8 btm_ble_br_keys_req(tBTM_SEC_DEV_REC *p_dev_rec, tBTM_LE_IO_REQ *p_data)
{ {
UINT8 callback_rc = BTM_SUCCESS; UINT8 callback_rc = BTM_SUCCESS;
BTM_TRACE_DEBUG ("%s", __func__); BTM_TRACE_DEBUG ("%s\n", __func__);
if (btm_cb.api.p_le_callback) if (btm_cb.api.p_le_callback)
{ {
/* the callback function implementation may change the IO capability... */ /* the callback function implementation may change the IO capability... */
@ -1705,7 +1705,7 @@ static void btm_ble_resolve_random_addr_on_conn_cmpl(void * p_rec, void *p_data)
handle = HCID_GET_HANDLE (handle); handle = HCID_GET_HANDLE (handle);
BTM_TRACE_EVENT ("%s", __func__); BTM_TRACE_EVENT ("%s\n", __func__);
if (match_rec) if (match_rec)
{ {

4
components/bt/bluedroid/stack/btm/btm_ble_bgconn.c
View file

@ -120,7 +120,7 @@ void btm_update_scanner_filter_policy(tBTM_BLE_SFP scan_policy)
UINT32 scan_interval = !p_inq->scan_interval ? BTM_BLE_GAP_DISC_SCAN_INT : p_inq->scan_interval; UINT32 scan_interval = !p_inq->scan_interval ? BTM_BLE_GAP_DISC_SCAN_INT : p_inq->scan_interval;
UINT32 scan_window = !p_inq->scan_window ? BTM_BLE_GAP_DISC_SCAN_WIN : p_inq->scan_window; UINT32 scan_window = !p_inq->scan_window ? BTM_BLE_GAP_DISC_SCAN_WIN : p_inq->scan_window;
BTM_TRACE_EVENT ("%s", __func__); BTM_TRACE_EVENT ("%s\n", __func__);
p_inq->sfp = scan_policy; p_inq->sfp = scan_policy;
p_inq->scan_type = p_inq->scan_type == BTM_BLE_SCAN_MODE_NONE ? BTM_BLE_SCAN_MODE_ACTI : p_inq->scan_type; p_inq->scan_type = p_inq->scan_type == BTM_BLE_SCAN_MODE_NONE ? BTM_BLE_SCAN_MODE_ACTI : p_inq->scan_type;
@ -581,7 +581,7 @@ void btm_ble_initiate_select_conn(BD_ADDR bda)
*******************************************************************************/ *******************************************************************************/
BOOLEAN btm_ble_suspend_bg_conn(void) BOOLEAN btm_ble_suspend_bg_conn(void)
{ {
BTM_TRACE_EVENT ("%s", __func__); BTM_TRACE_EVENT ("%s\n", __func__);
if (btm_cb.ble_ctr_cb.bg_conn_type == BTM_BLE_CONN_AUTO) if (btm_cb.ble_ctr_cb.bg_conn_type == BTM_BLE_CONN_AUTO)
return btm_ble_start_auto_conn(FALSE); return btm_ble_start_auto_conn(FALSE);

142
components/bt/bluedroid/stack/btm/btm_ble_gap.c
View file

@ -256,7 +256,7 @@ void BTM_BleUpdateAdvFilterPolicy(tBTM_BLE_AFP adv_policy)
BD_ADDR p_addr_ptr= {0}; BD_ADDR p_addr_ptr= {0};
UINT8 adv_mode = p_cb->adv_mode; UINT8 adv_mode = p_cb->adv_mode;
BTM_TRACE_EVENT ("BTM_BleUpdateAdvFilterPolicy"); BTM_TRACE_EVENT ("BTM_BleUpdateAdvFilterPolicy\n");
if (!controller_get_interface()->supports_ble()) if (!controller_get_interface()->supports_ble())
return; return;
@ -351,7 +351,7 @@ tBTM_STATUS BTM_BleObserve(BOOLEAN start, UINT8 duration,
UINT32 scan_interval = !p_inq->scan_interval ? BTM_BLE_GAP_DISC_SCAN_INT : p_inq->scan_interval; UINT32 scan_interval = !p_inq->scan_interval ? BTM_BLE_GAP_DISC_SCAN_INT : p_inq->scan_interval;
UINT32 scan_window = !p_inq->scan_window ? BTM_BLE_GAP_DISC_SCAN_WIN : p_inq->scan_window; UINT32 scan_window = !p_inq->scan_window ? BTM_BLE_GAP_DISC_SCAN_WIN : p_inq->scan_window;
BTM_TRACE_EVENT ("%s : scan_type:%d, %d, %d", __func__, btm_cb.btm_inq_vars.scan_type, BTM_TRACE_EVENT ("%s : scan_type:%d, %d, %d\n", __func__, btm_cb.btm_inq_vars.scan_type,
p_inq->scan_interval, p_inq->scan_window); p_inq->scan_interval, p_inq->scan_window);
if (!controller_get_interface()->supports_ble()) if (!controller_get_interface()->supports_ble())
@ -659,7 +659,7 @@ BOOLEAN BTM_BleConfigPrivacy(BOOLEAN privacy_mode)
#if BLE_PRIVACY_SPT == TRUE #if BLE_PRIVACY_SPT == TRUE
tBTM_BLE_CB *p_cb = &btm_cb.ble_ctr_cb; tBTM_BLE_CB *p_cb = &btm_cb.ble_ctr_cb;
BTM_TRACE_EVENT ("%s", __func__); BTM_TRACE_EVENT ("%s\n", __func__);
/* if LE is not supported, return error */ /* if LE is not supported, return error */
if (!controller_get_interface()->supports_ble()) if (!controller_get_interface()->supports_ble())
@ -1051,7 +1051,7 @@ tBTM_STATUS BTM_BleSetAdvParams(UINT16 adv_int_min, UINT16 adv_int_max,
memcpy(&p_cb->direct_bda, p_dir_bda, sizeof(tBLE_BD_ADDR)); memcpy(&p_cb->direct_bda, p_dir_bda, sizeof(tBLE_BD_ADDR));
} }
BTM_TRACE_EVENT ("update params for an active adv"); BTM_TRACE_EVENT ("update params for an active adv\n");
btm_ble_stop_adv(); btm_ble_stop_adv();
@ -1074,6 +1074,70 @@ tBTM_STATUS BTM_BleSetAdvParams(UINT16 adv_int_min, UINT16 adv_int_max,
return status; return status;
} }
/*******************************************************************************
**
** Function BTM_BleSetAdvParamsStartAdv
**
** Description This function is called to set all of the advertising parameters.
**
** Parameters: None.
**
** Returns void
**
*******************************************************************************/
tBTM_STATUS BTM_BleSetAdvParamsStartAdv(UINT16 adv_int_min, UINT16 adv_int_max, UINT8 adv_type,
tBLE_ADDR_TYPE own_bda_type, tBLE_BD_ADDR *p_dir_bda,
tBTM_BLE_ADV_CHNL_MAP chnl_map, tBTM_BLE_AFP afp)
{
tBTM_LE_RANDOM_CB *p_addr_cb = &btm_cb.ble_ctr_cb.addr_mgnt_cb;
tBTM_BLE_INQ_CB *p_cb = &btm_cb.ble_ctr_cb.inq_var;
tBTM_STATUS status = BTM_SUCCESS;
BTM_TRACE_EVENT ("BTM_BleSetAdvParamsStartAdv\n");
if (!controller_get_interface()->supports_ble())
return BTM_ILLEGAL_VALUE;
if (!BTM_BLE_ISVALID_PARAM(adv_int_min, BTM_BLE_ADV_INT_MIN, BTM_BLE_ADV_INT_MAX) ||
!BTM_BLE_ISVALID_PARAM(adv_int_max, BTM_BLE_ADV_INT_MIN, BTM_BLE_ADV_INT_MAX))
{
return BTM_ILLEGAL_VALUE;
}
p_cb->adv_interval_min = adv_int_min;
p_cb->adv_interval_max = adv_int_max;
p_cb->adv_chnl_map = chnl_map;
p_addr_cb->own_addr_type = own_bda_type;
p_cb->evt_type = adv_type;
p_cb->adv_mode = BTM_BLE_ADV_ENABLE;
p_cb->afp = afp;
if (p_dir_bda)
{
memcpy(&p_cb->direct_bda, p_dir_bda, sizeof(tBLE_BD_ADDR));
}
BTM_TRACE_EVENT ("update params for an active adv\n");
btm_ble_stop_adv();
/* update adv params */
btsnd_hcic_ble_write_adv_params (adv_int_min,
adv_int_max,
adv_type,
own_bda_type,
p_dir_bda->type,
p_dir_bda->bda,
chnl_map,
p_cb->afp);
btm_ble_start_adv();
}
/******************************************************************************* /*******************************************************************************
** **
** Function BTM_BleReadAdvParams ** Function BTM_BleReadAdvParams
@ -1130,7 +1194,7 @@ void BTM_BleSetScanParams(tGATT_IF client_if, UINT32 scan_interval, UINT32 scan_
UINT32 max_scan_interval; UINT32 max_scan_interval;
UINT32 max_scan_window; UINT32 max_scan_window;
BTM_TRACE_EVENT ("%s", __func__); BTM_TRACE_EVENT ("%s\n", __func__);
if (!controller_get_interface()->supports_ble()) if (!controller_get_interface()->supports_ble())
return; return;
@ -1163,12 +1227,65 @@ void BTM_BleSetScanParams(tGATT_IF client_if, UINT32 scan_interval, UINT32 scan_
if (scan_setup_status_cback != NULL) if (scan_setup_status_cback != NULL)
scan_setup_status_cback(client_if, BTM_ILLEGAL_VALUE); scan_setup_status_cback(client_if, BTM_ILLEGAL_VALUE);
BTM_TRACE_ERROR("Illegal params: scan_interval = %d scan_window = %d", BTM_TRACE_ERROR("Illegal params: scan_interval = %d scan_window = %d\n",
scan_interval, scan_window); scan_interval, scan_window);
} }
} }
void BTM_BleSetScanFilterParams(tGATT_IF client_if, UINT32 scan_interval, UINT32 scan_window,
tBLE_SCAN_MODE scan_mode, UINT8 addr_type_own, tBTM_BLE_SFP scan_filter_policy,
tBLE_SCAN_PARAM_SETUP_CBACK scan_setup_status_cback)
{
tBTM_BLE_INQ_CB *p_cb = &btm_cb.ble_ctr_cb.inq_var;
UINT32 max_scan_interval;
UINT32 max_scan_window;
BTM_TRACE_EVENT ("%s\n", __func__);
if (!controller_get_interface()->supports_ble())
return;
/* If not supporting extended scan support, use the older range for checking */
if (btm_cb.cmn_ble_vsc_cb.extended_scan_support == 0)
{
max_scan_interval = BTM_BLE_SCAN_INT_MAX;
max_scan_window = BTM_BLE_SCAN_WIN_MAX;
}
else
{
/* If supporting extended scan support, use the new extended range for checking */
max_scan_interval = BTM_BLE_EXT_SCAN_INT_MAX;
max_scan_window = BTM_BLE_EXT_SCAN_WIN_MAX;
}
if (BTM_BLE_ISVALID_PARAM(scan_interval, BTM_BLE_SCAN_INT_MIN, max_scan_interval) &&
BTM_BLE_ISVALID_PARAM(scan_window, BTM_BLE_SCAN_WIN_MIN, max_scan_window) &&
(scan_mode == BTM_BLE_SCAN_MODE_ACTI || scan_mode == BTM_BLE_SCAN_MODE_PASS))
{
p_cb->scan_type = scan_mode;
p_cb->scan_interval = scan_interval;
p_cb->scan_window = scan_window;
p_cb->sfp = scan_filter_policy;
btsnd_hcic_ble_set_scan_params(p_cb->scan_type, (UINT16)scan_interval,
(UINT16)scan_window,
addr_type_own,
scan_filter_policy);
if (scan_setup_status_cback != NULL)
scan_setup_status_cback(client_if, BTM_SUCCESS);
}
else
{
if (scan_setup_status_cback != NULL)
scan_setup_status_cback(client_if, BTM_ILLEGAL_VALUE);
BTM_TRACE_ERROR("Illegal params: scan_interval = %d scan_window = %d\n",
scan_interval, scan_window);
}
}
/******************************************************************************* /*******************************************************************************
** **
** Function BTM_BleWriteScanRsp ** Function BTM_BleWriteScanRsp
@ -1333,7 +1450,7 @@ UINT8 *BTM_CheckAdvData( UINT8 *p_adv, UINT8 type, UINT8 *p_length)
*******************************************************************************/ *******************************************************************************/
UINT16 BTM_BleReadDiscoverability() UINT16 BTM_BleReadDiscoverability()
{ {
BTM_TRACE_API("%s", __FUNCTION__); BTM_TRACE_API("%s\n", __FUNCTION__);
return (btm_cb.ble_ctr_cb.inq_var.discoverable_mode); return (btm_cb.ble_ctr_cb.inq_var.discoverable_mode);
} }
@ -1350,7 +1467,7 @@ UINT16 BTM_BleReadDiscoverability()
*******************************************************************************/ *******************************************************************************/
UINT16 BTM_BleReadConnectability() UINT16 BTM_BleReadConnectability()
{ {
BTM_TRACE_API ("%s", __FUNCTION__); BTM_TRACE_API ("%s\n", __FUNCTION__);
return (btm_cb.ble_ctr_cb.inq_var.connectable_mode); return (btm_cb.ble_ctr_cb.inq_var.connectable_mode);
} }
@ -1782,7 +1899,7 @@ tBTM_STATUS btm_ble_set_discoverability(UINT16 combined_mode)
own_addr_type = p_addr_cb->own_addr_type; own_addr_type = p_addr_cb->own_addr_type;
UINT16 adv_int_min, adv_int_max; UINT16 adv_int_min, adv_int_max;
BTM_TRACE_EVENT ("%s mode=0x%0x combined_mode=0x%x", __FUNCTION__, mode, combined_mode); BTM_TRACE_EVENT ("%s mode=0x%0x combined_mode=0x%x\n", __FUNCTION__, mode, combined_mode);
/*** Check mode parameter ***/ /*** Check mode parameter ***/
if (mode > BTM_BLE_MAX_DISCOVERABLE) if (mode > BTM_BLE_MAX_DISCOVERABLE)
@ -1800,7 +1917,7 @@ tBTM_STATUS btm_ble_set_discoverability(UINT16 combined_mode)
btu_stop_timer(&p_cb->fast_adv_timer); btu_stop_timer(&p_cb->fast_adv_timer);
/* update adv params if start advertising */ /* update adv params if start advertising */
BTM_TRACE_EVENT ("evt_type=0x%x p-cb->evt_type=0x%x ", evt_type, p_cb->evt_type); BTM_TRACE_EVENT ("evt_type=0x%x p-cb->evt_type=0x%x\n ", evt_type, p_cb->evt_type);
if (new_mode == BTM_BLE_ADV_ENABLE) if (new_mode == BTM_BLE_ADV_ENABLE)
{ {
@ -1888,7 +2005,7 @@ tBTM_STATUS btm_ble_set_connectability(UINT16 combined_mode)
own_addr_type = p_addr_cb->own_addr_type; own_addr_type = p_addr_cb->own_addr_type;
UINT16 adv_int_min, adv_int_max; UINT16 adv_int_min, adv_int_max;
BTM_TRACE_EVENT ("%s mode=0x%0x combined_mode=0x%x", __FUNCTION__, mode, combined_mode); BTM_TRACE_EVENT ("%s mode=0x%0x combined_mode=0x%x\n", __FUNCTION__, mode, combined_mode);
/*** Check mode parameter ***/ /*** Check mode parameter ***/
if (mode > BTM_BLE_MAX_CONNECTABLE) if (mode > BTM_BLE_MAX_CONNECTABLE)
@ -3064,7 +3181,7 @@ tBTM_STATUS btm_ble_start_adv(void)
{ {
tBTM_BLE_INQ_CB *p_cb = &btm_cb.ble_ctr_cb.inq_var; tBTM_BLE_INQ_CB *p_cb = &btm_cb.ble_ctr_cb.inq_var;
tBTM_STATUS rt = BTM_NO_RESOURCES; tBTM_STATUS rt = BTM_NO_RESOURCES;
BTM_TRACE_EVENT ("btm_ble_start_adv\n");
if (!btm_ble_adv_states_operation (btm_ble_topology_check, p_cb->evt_type)) if (!btm_ble_adv_states_operation (btm_ble_topology_check, p_cb->evt_type))
return BTM_WRONG_MODE; return BTM_WRONG_MODE;
@ -3086,6 +3203,7 @@ tBTM_STATUS btm_ble_start_adv(void)
p_cb->adv_mode = BTM_BLE_ADV_ENABLE; p_cb->adv_mode = BTM_BLE_ADV_ENABLE;
btm_ble_adv_states_operation(btm_ble_set_topology_mask, p_cb->evt_type); btm_ble_adv_states_operation(btm_ble_set_topology_mask, p_cb->evt_type);
rt = BTM_SUCCESS; rt = BTM_SUCCESS;
BTM_TRACE_EVENT ("BTM_SUCCESS\n");
} }
else else
{ {

14
components/bt/bluedroid/stack/btm/btm_ble_privacy.c
View file

@ -760,14 +760,14 @@ BOOLEAN btm_ble_resolving_list_load_dev(tBTM_SEC_DEV_REC *p_dev_rec)
BOOLEAN rt = FALSE; BOOLEAN rt = FALSE;
UINT8 rl_mask = btm_cb.ble_ctr_cb.rl_state; UINT8 rl_mask = btm_cb.ble_ctr_cb.rl_state;
BTM_TRACE_DEBUG("%s btm_cb.ble_ctr_cb.privacy_mode = %d", __func__, BTM_TRACE_DEBUG("%s btm_cb.ble_ctr_cb.privacy_mode = %d\n", __func__,
btm_cb.ble_ctr_cb.privacy_mode); btm_cb.ble_ctr_cb.privacy_mode);
/* if controller does not support RPA offloading or privacy 1.2, skip */ /* if controller does not support RPA offloading or privacy 1.2, skip */
if (controller_get_interface()->get_ble_resolving_list_max_size() == 0) if (controller_get_interface()->get_ble_resolving_list_max_size() == 0)
return FALSE; return FALSE;
BTM_TRACE_DEBUG("%s btm_cb.ble_ctr_cb.privacy_mode = %d", BTM_TRACE_DEBUG("%s btm_cb.ble_ctr_cb.privacy_mode = %d\n",
__func__, btm_cb.ble_ctr_cb.privacy_mode); __func__, btm_cb.ble_ctr_cb.privacy_mode);
/* only add RPA enabled device into resolving list */ /* only add RPA enabled device into resolving list */
@ -801,7 +801,7 @@ BOOLEAN btm_ble_resolving_list_load_dev(tBTM_SEC_DEV_REC *p_dev_rec)
p_dev_rec->ble.static_addr_type = p_dev_rec->ble.ble_addr_type; p_dev_rec->ble.static_addr_type = p_dev_rec->ble.ble_addr_type;
} }
BTM_TRACE_DEBUG("%s:adding device to controller resolving list", __func__); BTM_TRACE_DEBUG("%s:adding device to controller resolving list\n", __func__);
// use identical IRK for now // use identical IRK for now
rt = btsnd_hcic_ble_add_device_resolving_list(p_dev_rec->ble.static_addr_type, rt = btsnd_hcic_ble_add_device_resolving_list(p_dev_rec->ble.static_addr_type,
p_dev_rec->ble.static_addr, peer_irk, local_irk); p_dev_rec->ble.static_addr, peer_irk, local_irk);
@ -837,13 +837,13 @@ BOOLEAN btm_ble_resolving_list_load_dev(tBTM_SEC_DEV_REC *p_dev_rec)
} }
else else
{ {
BTM_TRACE_ERROR("Device already in Resolving list"); BTM_TRACE_ERROR("Device already in Resolving list\n");
rt = TRUE; rt = TRUE;
} }
} }
else else
{ {
BTM_TRACE_DEBUG("Device not a RPA enabled device"); BTM_TRACE_DEBUG("Device not a RPA enabled device\n");
} }
return rt; return rt;
} }
@ -863,7 +863,7 @@ void btm_ble_resolving_list_remove_dev(tBTM_SEC_DEV_REC *p_dev_rec)
{ {
UINT8 rl_mask = btm_cb.ble_ctr_cb.rl_state; UINT8 rl_mask = btm_cb.ble_ctr_cb.rl_state;
BTM_TRACE_EVENT ("%s", __func__); BTM_TRACE_EVENT ("%s\n", __func__);
if (rl_mask) if (rl_mask)
{ {
if (!btm_ble_disable_resolving_list (rl_mask, FALSE)) if (!btm_ble_disable_resolving_list (rl_mask, FALSE))
@ -879,7 +879,7 @@ void btm_ble_resolving_list_remove_dev(tBTM_SEC_DEV_REC *p_dev_rec)
} }
else else
{ {
BTM_TRACE_DEBUG("Device not in resolving list"); BTM_TRACE_DEBUG("Device not in resolving list\n");
} }
/* if resolving list has been turned on, re-enable it */ /* if resolving list has been turned on, re-enable it */

13
components/bt/bluedroid/stack/btm/btm_sec.c
View file

@ -2731,11 +2731,11 @@ tBTM_STATUS btm_sec_mx_access_request (BD_ADDR bd_addr, UINT16 psm, BOOLEAN is_o
void btm_sec_conn_req (UINT8 *bda, UINT8 *dc) void btm_sec_conn_req (UINT8 *bda, UINT8 *dc)
{ {
tBTM_SEC_DEV_REC *p_dev_rec = btm_find_dev (bda); tBTM_SEC_DEV_REC *p_dev_rec = btm_find_dev (bda);
BTM_TRACE_ERROR ("%s\n",__func__);
/* Some device may request a connection before we are done with the HCI_Reset sequence */ /* Some device may request a connection before we are done with the HCI_Reset sequence */
if (!controller_get_interface()->get_is_ready()) if (!controller_get_interface()->get_is_ready())
{ {
BTM_TRACE_EVENT ("Security Manager: connect request when device not ready\n"); BTM_TRACE_ERROR ("Security Manager: connect request when device not ready\n");
btsnd_hcic_reject_conn (bda, HCI_ERR_HOST_REJECT_DEVICE); btsnd_hcic_reject_conn (bda, HCI_ERR_HOST_REJECT_DEVICE);
return; return;
} }
@ -2747,7 +2747,7 @@ void btm_sec_conn_req (UINT8 *bda, UINT8 *dc)
{ {
if (!p_dev_rec || !(p_dev_rec->sec_flags & BTM_SEC_LINK_KEY_AUTHED)) if (!p_dev_rec || !(p_dev_rec->sec_flags & BTM_SEC_LINK_KEY_AUTHED))
{ {
BTM_TRACE_EVENT ("Security Manager: connect request from non-paired device\n"); BTM_TRACE_ERROR ("Security Manager: connect request from non-paired device\n");
btsnd_hcic_reject_conn (bda, HCI_ERR_HOST_REJECT_DEVICE); btsnd_hcic_reject_conn (bda, HCI_ERR_HOST_REJECT_DEVICE);
return; return;
} }
@ -2759,7 +2759,7 @@ void btm_sec_conn_req (UINT8 *bda, UINT8 *dc)
{ {
if (!p_dev_rec) if (!p_dev_rec)
{ {
BTM_TRACE_EVENT ("Security Manager: connect request from not paired device\n"); BTM_TRACE_ERROR ("Security Manager: connect request from not paired device\n");
btsnd_hcic_reject_conn (bda, HCI_ERR_HOST_REJECT_DEVICE); btsnd_hcic_reject_conn (bda, HCI_ERR_HOST_REJECT_DEVICE);
return; return;
} }
@ -2770,7 +2770,7 @@ void btm_sec_conn_req (UINT8 *bda, UINT8 *dc)
&&(btm_cb.pairing_flags & BTM_PAIR_FLAGS_WE_STARTED_DD) &&(btm_cb.pairing_flags & BTM_PAIR_FLAGS_WE_STARTED_DD)
&&(!memcmp (btm_cb.pairing_bda, bda, BD_ADDR_LEN))) &&(!memcmp (btm_cb.pairing_bda, bda, BD_ADDR_LEN)))
{ {
BTM_TRACE_EVENT ("Security Manager: reject connect request from bonding device\n"); BTM_TRACE_ERROR ("Security Manager: reject connect request from bonding device\n");
/* incoming connection from bonding device is rejected */ /* incoming connection from bonding device is rejected */
btm_cb.pairing_flags |= BTM_PAIR_FLAGS_REJECTED_CONNECT; btm_cb.pairing_flags |= BTM_PAIR_FLAGS_REJECTED_CONNECT;
@ -4426,7 +4426,8 @@ void btm_sec_connected (UINT8 *bda, UINT16 handle, UINT8 status, UINT8 enc_mode)
UINT8 bit_shift = 0; UINT8 bit_shift = 0;
btm_acl_resubmit_page(); btm_acl_resubmit_page();
BTM_TRACE_ERROR ("%s\n",__func__);
/* Commenting out trace due to obf/compilation problems. /* Commenting out trace due to obf/compilation problems.
*/ */
#if (BT_USE_TRACES == TRUE) #if (BT_USE_TRACES == TRUE)

2
components/bt/bluedroid/stack/btu/btu_hcif.c
View file

@ -1196,7 +1196,7 @@ static void btu_hcif_command_status_evt(uint8_t status, BT_HDR *command, void *c
*******************************************************************************/ *******************************************************************************/
static void btu_hcif_hardware_error_evt (UINT8 *p) static void btu_hcif_hardware_error_evt (UINT8 *p)
{ {
HCI_TRACE_ERROR("Ctlr H/w error event - code:0x%x", *p); HCI_TRACE_ERROR("Ctlr H/w error event - code:0x%x\n", *p);
/* If anyone wants device status notifications, give him one. */ /* If anyone wants device status notifications, give him one. */
btm_report_device_status (BTM_DEV_STATUS_DOWN); btm_report_device_status (BTM_DEV_STATUS_DOWN);

8
components/bt/bluedroid/stack/gap/gap_ble.c
View file

@ -464,13 +464,13 @@ void GAP_BleAttrDBUpdate(UINT16 attr_uuid, tGAP_BLE_ATTR_VALUE *p_value)
tGAP_ATTR *p_db_attr = gap_cb.gatt_attr; tGAP_ATTR *p_db_attr = gap_cb.gatt_attr;
UINT8 i = 0; UINT8 i = 0;
GAP_TRACE_EVENT("GAP_BleAttrDBUpdate attr_uuid=0x%04x", attr_uuid); GAP_TRACE_EVENT("GAP_BleAttrDBUpdate attr_uuid=0x%04x\n", attr_uuid);
for (i = 0; i < GAP_MAX_CHAR_NUM; i ++, p_db_attr ++) for (i = 0; i < GAP_MAX_CHAR_NUM; i ++, p_db_attr ++)
{ {
if (p_db_attr->uuid == attr_uuid) if (p_db_attr->uuid == attr_uuid)
{ {
GAP_TRACE_EVENT("Found attr_uuid=0x%04x", attr_uuid); GAP_TRACE_EVENT("Found attr_uuid=0x%04x\n", attr_uuid);
switch (attr_uuid) switch (attr_uuid)
{ {
@ -630,7 +630,7 @@ static void gap_ble_c_cmpl_cback (UINT16 conn_id, tGATTC_OPTYPE op, tGATT_STATUS
op_type = p_clcb->cl_op_uuid; op_type = p_clcb->cl_op_uuid;
GAP_TRACE_EVENT ("gap_ble_c_cmpl_cback() - op_code: 0x%02x status: 0x%02x read_type: 0x%04x", op, status, op_type); GAP_TRACE_EVENT ("gap_ble_c_cmpl_cback() - op_code: 0x%02x status: 0x%02x read_type: 0x%04x\n", op, status, op_type);
/* Currently we only issue read commands */ /* Currently we only issue read commands */
if (op != GATTC_OPTYPE_READ) if (op != GATTC_OPTYPE_READ)
return; return;
@ -660,7 +660,7 @@ static void gap_ble_c_cmpl_cback (UINT16 conn_id, tGATTC_OPTYPE op, tGATT_STATUS
break; break;
case GATT_UUID_GAP_DEVICE_NAME: case GATT_UUID_GAP_DEVICE_NAME:
GAP_TRACE_EVENT ("GATT_UUID_GAP_DEVICE_NAME"); GAP_TRACE_EVENT ("GATT_UUID_GAP_DEVICE_NAME\n");
len = (UINT16)strlen((char *)pp); len = (UINT16)strlen((char *)pp);
if (len > GAP_CHAR_DEV_NAME_SIZE) if (len > GAP_CHAR_DEV_NAME_SIZE)
len = GAP_CHAR_DEV_NAME_SIZE; len = GAP_CHAR_DEV_NAME_SIZE;

6
components/bt/bluedroid/stack/gatt/gatt_api.c
View file

@ -680,7 +680,7 @@ tGATT_STATUS GATTS_HandleValueNotification (UINT16 conn_id, UINT16 attr_handle,
if ( (p_reg == NULL) || (p_tcb == NULL)) if ( (p_reg == NULL) || (p_tcb == NULL))
{ {
GATT_TRACE_ERROR ("GATTS_HandleValueNotification Unknown conn_id: %u ", conn_id); GATT_TRACE_ERROR ("GATTS_HandleValueNotification Unknown conn_id: %u \n", conn_id);
return(tGATT_STATUS) GATT_INVALID_CONN_ID; return(tGATT_STATUS) GATT_INVALID_CONN_ID;
} }
@ -689,7 +689,7 @@ tGATT_STATUS GATTS_HandleValueNotification (UINT16 conn_id, UINT16 attr_handle,
notif.handle = attr_handle; notif.handle = attr_handle;
notif.len = val_len; notif.len = val_len;
memcpy (notif.value, p_val, val_len); memcpy (notif.value, p_val, val_len);
notif.auth_req = GATT_AUTH_REQ_NONE;; notif.auth_req = GATT_AUTH_REQ_NONE;
if ((p_buf = attp_build_sr_msg (p_tcb, GATT_HANDLE_VALUE_NOTIF, (tGATT_SR_MSG *)&notif)) if ((p_buf = attp_build_sr_msg (p_tcb, GATT_HANDLE_VALUE_NOTIF, (tGATT_SR_MSG *)&notif))
!= NULL) != NULL)
@ -1582,7 +1582,7 @@ BOOLEAN GATT_GetConnIdIfConnected(tGATT_IF gatt_if, BD_ADDR bd_addr, UINT16 *p_c
status = TRUE; status = TRUE;
} }
GATT_TRACE_API ("GATT_GetConnIdIfConnected status=%d", status); GATT_TRACE_API ("GATT_GetConnIdIfConnected status=%d\n", status);
return status; return status;
} }

4
components/bt/bluedroid/stack/gatt/gatt_sr.c
View file

@ -919,7 +919,7 @@ static void gatts_process_mtu_req (tGATT_TCB *p_tcb, UINT16 len, UINT8 *p_data)
} }
else if (len < GATT_MTU_REQ_MIN_LEN) else if (len < GATT_MTU_REQ_MIN_LEN)
{ {
GATT_TRACE_ERROR("invalid MTU request PDU received."); GATT_TRACE_ERROR("invalid MTU request PDU received.\n");
gatt_send_error_rsp (p_tcb, GATT_INVALID_PDU, GATT_REQ_MTU, 0, FALSE); gatt_send_error_rsp (p_tcb, GATT_INVALID_PDU, GATT_REQ_MTU, 0, FALSE);
} }
else else
@ -933,7 +933,7 @@ static void gatts_process_mtu_req (tGATT_TCB *p_tcb, UINT16 len, UINT8 *p_data)
else else
p_tcb->payload_size = mtu; p_tcb->payload_size = mtu;
GATT_TRACE_ERROR("MTU request PDU with MTU size %d", p_tcb->payload_size); GATT_TRACE_ERROR("MTU request PDU with MTU size %d\n", p_tcb->payload_size);
l2cble_set_fixed_channel_tx_data_length(p_tcb->peer_bda, L2CAP_ATT_CID, p_tcb->payload_size); l2cble_set_fixed_channel_tx_data_length(p_tcb->peer_bda, L2CAP_ATT_CID, p_tcb->payload_size);

42
components/bt/bluedroid/stack/include/btm_ble_api.h
View file

@ -941,6 +941,24 @@ BOOLEAN BTM_SecAddBleKey (BD_ADDR bd_addr, tBTM_LE_KEY_VALUE *p_le_key,
tBTM_STATUS BTM_BleSetAdvParams(UINT16 adv_int_min, UINT16 adv_int_max, tBTM_STATUS BTM_BleSetAdvParams(UINT16 adv_int_min, UINT16 adv_int_max,
tBLE_BD_ADDR *p_dir_bda, tBTM_BLE_ADV_CHNL_MAP chnl_map); tBLE_BD_ADDR *p_dir_bda, tBTM_BLE_ADV_CHNL_MAP chnl_map);
/*******************************************************************************
**
** Function BTM_BleSetAdvParamsStartAdv
**
** Description This function is called to set all of the advertising parameters.
**
** Parameters: None.
**
** Returns void
**
*******************************************************************************/
tBTM_STATUS BTM_BleSetAdvParamsStartAdv(UINT16 adv_int_min, UINT16 adv_int_max, UINT8 adv_type,
tBLE_ADDR_TYPE own_bda_type, tBLE_BD_ADDR *p_dir_bda,
tBTM_BLE_ADV_CHNL_MAP chnl_map, tBTM_BLE_AFP afp);
/******************************************************************************* /*******************************************************************************
** **
** Function BTM_BleWriteAdvData ** Function BTM_BleWriteAdvData
@ -1011,6 +1029,30 @@ void BTM_BleSetScanParams(tGATT_IF client_if, UINT32 scan_interval,
UINT32 scan_window, tBLE_SCAN_MODE scan_type, UINT32 scan_window, tBLE_SCAN_MODE scan_type,
tBLE_SCAN_PARAM_SETUP_CBACK scan_setup_status_cback); tBLE_SCAN_PARAM_SETUP_CBACK scan_setup_status_cback);
/*******************************************************************************
**
** Function BTM_BleSetScanFilterParams
**
** Description This function is called to set Scan Filter & parameters.
**
** Parameters client_if - Client IF value
** scan_interval - Scan interval
** scan_window - Scan window
** scan_type - Scan type
** addr_type_own - owner address type
** scan_filter_policy - scan filter policy
** scan_setup_status_cback - Scan setup status callback
**
** Returns void
**
*******************************************************************************/
void BTM_BleSetScanFilterParams(tGATT_IF client_if, UINT32 scan_interval, UINT32 scan_window,
tBLE_SCAN_MODE scan_mode, UINT8 addr_type_own, tBTM_BLE_SFP scan_filter_policy,
tBLE_SCAN_PARAM_SETUP_CBACK scan_setup_status_cback);
/******************************************************************************* /*******************************************************************************
** **
** Function BTM_BleGetVendorCapabilities ** Function BTM_BleGetVendorCapabilities

1
components/bt/bluedroid/stack/include/l2cdefs.h
View file

@ -38,6 +38,7 @@
#define L2CAP_CMD_AMP_MOVE_RSP 0x0F #define L2CAP_CMD_AMP_MOVE_RSP 0x0F
#define L2CAP_CMD_AMP_MOVE_CFM 0x10 #define L2CAP_CMD_AMP_MOVE_CFM 0x10
#define L2CAP_CMD_AMP_MOVE_CFM_RSP 0x11 #define L2CAP_CMD_AMP_MOVE_CFM_RSP 0x11
#define L2CAP_CMD_BLE_UPDATE_REQ 0x12 #define L2CAP_CMD_BLE_UPDATE_REQ 0x12
#define L2CAP_CMD_BLE_UPDATE_RSP 0x13 #define L2CAP_CMD_BLE_UPDATE_RSP 0x13

26
components/bt/bluedroid/stack/l2cap/l2c_link.c
View file

@ -134,7 +134,7 @@ BOOLEAN l2c_link_hci_conn_req (BD_ADDR bd_addr)
} }
else else
{ {
L2CAP_TRACE_ERROR("L2CAP got conn_req while connected (state:%d). Reject it", L2CAP_TRACE_ERROR("L2CAP got conn_req while connected (state:%d). Reject it\n",
p_lcb->link_state); p_lcb->link_state);
/* Reject the connection with ACL Connection Already exist reason */ /* Reject the connection with ACL Connection Already exist reason */
//counter_add("l2cap.conn.reject.exists", 1); //counter_add("l2cap.conn.reject.exists", 1);
@ -172,13 +172,13 @@ BOOLEAN l2c_link_hci_conn_comp (UINT8 status, UINT16 handle, BD_ADDR p_bda)
/* If we don't have one, this is an error */ /* If we don't have one, this is an error */
if (!p_lcb) if (!p_lcb)
{ {
L2CAP_TRACE_WARNING ("L2CAP got conn_comp for unknown BD_ADDR"); L2CAP_TRACE_WARNING ("L2CAP got conn_comp for unknown BD_ADDR\n");
return (FALSE); return (FALSE);
} }
if (p_lcb->link_state != LST_CONNECTING) if (p_lcb->link_state != LST_CONNECTING)
{ {
L2CAP_TRACE_ERROR ("L2CAP got conn_comp in bad state: %d status: 0x%d", p_lcb->link_state, status); L2CAP_TRACE_ERROR ("L2CAP got conn_comp in bad state: %d status: 0x%d\n", p_lcb->link_state, status);
if (status != HCI_SUCCESS) if (status != HCI_SUCCESS)
l2c_link_hci_disc_comp (p_lcb->handle, status); l2c_link_hci_disc_comp (p_lcb->handle, status);
@ -314,7 +314,7 @@ void l2c_link_sec_comp (BD_ADDR p_bda, tBT_TRANSPORT transport, void *p_ref_data
/* If we don't have one, this is an error */ /* If we don't have one, this is an error */
if (!p_lcb) if (!p_lcb)
{ {
L2CAP_TRACE_WARNING ("L2CAP got sec_comp for unknown BD_ADDR"); L2CAP_TRACE_WARNING ("L2CAP got sec_comp for unknown BD_ADDR\n");
return; return;
} }
@ -774,7 +774,7 @@ void l2c_link_adjust_allocation (void)
qq = qq_remainder = 1; qq = qq_remainder = 1;
} }
L2CAP_TRACE_EVENT ("l2c_link_adjust_allocation num_hipri: %u num_lowpri: %u low_quota: %u round_robin_quota: %u qq: %u", L2CAP_TRACE_EVENT ("l2c_link_adjust_allocation num_hipri: %u num_lowpri: %u low_quota: %u round_robin_quota: %u qq: %u\n",
num_hipri_links, num_lowpri_links, low_quota, num_hipri_links, num_lowpri_links, low_quota,
l2cb.round_robin_quota, qq); l2cb.round_robin_quota, qq);
@ -803,10 +803,10 @@ void l2c_link_adjust_allocation (void)
} }
} }
L2CAP_TRACE_EVENT ("l2c_link_adjust_allocation LCB %d Priority: %d XmitQuota: %d", L2CAP_TRACE_EVENT ("l2c_link_adjust_allocation LCB %d Priority: %d XmitQuota: %d\n",
yy, p_lcb->acl_priority, p_lcb->link_xmit_quota); yy, p_lcb->acl_priority, p_lcb->link_xmit_quota);
L2CAP_TRACE_EVENT (" SentNotAcked: %d RRUnacked: %d", L2CAP_TRACE_EVENT (" SentNotAcked: %d RRUnacked: %d\n",
p_lcb->sent_not_acked, l2cb.round_robin_unacked); p_lcb->sent_not_acked, l2cb.round_robin_unacked);
/* There is a special case where we have readjusted the link quotas and */ /* There is a special case where we have readjusted the link quotas and */
@ -1081,7 +1081,7 @@ BOOLEAN l2c_link_check_power_mode (tL2C_LCB *p_lcb)
{ {
if ( mode == BTM_PM_STS_PENDING ) if ( mode == BTM_PM_STS_PENDING )
{ {
L2CAP_TRACE_DEBUG ("LCB(0x%x) is in PM pending state", p_lcb->handle); L2CAP_TRACE_DEBUG ("LCB(0x%x) is in PM pending state\n", p_lcb->handle);
return TRUE; return TRUE;
} }
@ -1510,7 +1510,7 @@ void l2c_link_process_num_completed_pkts (UINT8 *p)
#if (BLE_INCLUDED == TRUE) #if (BLE_INCLUDED == TRUE)
if (p_lcb->transport == BT_TRANSPORT_LE) if (p_lcb->transport == BT_TRANSPORT_LE)
{ {
L2CAP_TRACE_DEBUG ("TotalWin=%d,LinkUnack(0x%x)=%d,RRCheck=%d,RRUnack=%d", L2CAP_TRACE_DEBUG ("TotalWin=%d,LinkUnack(0x%x)=%d,RRCheck=%d,RRUnack=%d\n",
l2cb.controller_le_xmit_window, l2cb.controller_le_xmit_window,
p_lcb->handle, p_lcb->sent_not_acked, p_lcb->handle, p_lcb->sent_not_acked,
l2cb.ble_check_round_robin, l2cb.ble_round_robin_unacked); l2cb.ble_check_round_robin, l2cb.ble_round_robin_unacked);
@ -1518,7 +1518,7 @@ void l2c_link_process_num_completed_pkts (UINT8 *p)
else else
#endif #endif
{ {
L2CAP_TRACE_DEBUG ("TotalWin=%d,LinkUnack(0x%x)=%d,RRCheck=%d,RRUnack=%d", L2CAP_TRACE_DEBUG ("TotalWin=%d,LinkUnack(0x%x)=%d,RRCheck=%d,RRUnack=%d\n",
l2cb.controller_xmit_window, l2cb.controller_xmit_window,
p_lcb->handle, p_lcb->sent_not_acked, p_lcb->handle, p_lcb->sent_not_acked,
l2cb.check_round_robin, l2cb.round_robin_unacked); l2cb.check_round_robin, l2cb.round_robin_unacked);
@ -1528,13 +1528,13 @@ void l2c_link_process_num_completed_pkts (UINT8 *p)
else else
{ {
#if (BLE_INCLUDED == TRUE) #if (BLE_INCLUDED == TRUE)
L2CAP_TRACE_DEBUG ("TotalWin=%d LE_Win: %d, Handle=0x%x, RRCheck=%d, RRUnack=%d", L2CAP_TRACE_DEBUG ("TotalWin=%d LE_Win: %d, Handle=0x%x, RRCheck=%d, RRUnack=%d\n",
l2cb.controller_xmit_window, l2cb.controller_xmit_window,
l2cb.controller_le_xmit_window, l2cb.controller_le_xmit_window,
handle, handle,
l2cb.ble_check_round_robin, l2cb.ble_round_robin_unacked); l2cb.ble_check_round_robin, l2cb.ble_round_robin_unacked);
#else #else
L2CAP_TRACE_DEBUG ("TotalWin=%d Handle=0x%x RRCheck=%d RRUnack=%d", L2CAP_TRACE_DEBUG ("TotalWin=%d Handle=0x%x RRCheck=%d RRUnack=%d\n",
l2cb.controller_xmit_window, l2cb.controller_xmit_window,
handle, handle,
l2cb.check_round_robin, l2cb.round_robin_unacked); l2cb.check_round_robin, l2cb.round_robin_unacked);
@ -1572,7 +1572,7 @@ void l2c_link_segments_xmitted (BT_HDR *p_msg)
/* Find the LCB based on the handle */ /* Find the LCB based on the handle */
if ((p_lcb = l2cu_find_lcb_by_handle (handle)) == NULL) if ((p_lcb = l2cu_find_lcb_by_handle (handle)) == NULL)
{ {
L2CAP_TRACE_WARNING ("L2CAP - rcvd segment complete, unknown handle: %d", handle); L2CAP_TRACE_WARNING ("L2CAP - rcvd segment complete, unknown handle: %d\n", handle);
GKI_freebuf (p_msg); GKI_freebuf (p_msg);
return; return;
} }

12
components/bt/bluedroid/stack/l2cap/l2cap_client.c
View file

@ -268,7 +268,7 @@ static void config_completed_cb(uint16_t local_channel_id, tL2CAP_CFG_INFO *nego
case L2CAP_CFG_UNACCEPTABLE_PARAMS: case L2CAP_CFG_UNACCEPTABLE_PARAMS:
// TODO: see if we can renegotiate parameters instead of dropping the connection. // TODO: see if we can renegotiate parameters instead of dropping the connection.
LOG_WARN("%s dropping L2CAP connection due to unacceptable config parameters.", __func__); LOG_WARN("%s dropping L2CAP connection due to unacceptable config parameters.\n", __func__);
l2cap_client_disconnect(client); l2cap_client_disconnect(client);
break; break;
@ -281,7 +281,7 @@ static void config_completed_cb(uint16_t local_channel_id, tL2CAP_CFG_INFO *nego
// Failure, no further parameter negotiation possible. // Failure, no further parameter negotiation possible.
default: default:
LOG_WARN("%s L2CAP parameter negotiation failed with error code %d.", __func__, negotiated_parameters->result); LOG_WARN("%s L2CAP parameter negotiation failed with error code %d.\n", __func__, negotiated_parameters->result);
l2cap_client_disconnect(client); l2cap_client_disconnect(client);
break; break;
} }
@ -290,7 +290,7 @@ static void config_completed_cb(uint16_t local_channel_id, tL2CAP_CFG_INFO *nego
static void disconnect_request_cb(uint16_t local_channel_id, bool ack_required) { static void disconnect_request_cb(uint16_t local_channel_id, bool ack_required) {
l2cap_client_t *client = find(local_channel_id); l2cap_client_t *client = find(local_channel_id);
if (!client) { if (!client) {
LOG_ERROR("%s unable to find L2CAP client with LCID 0x%04x.", __func__, local_channel_id); LOG_ERROR("%s unable to find L2CAP client with LCID 0x%04x.\n", __func__, local_channel_id);
return; return;
} }
@ -309,7 +309,7 @@ static void disconnect_completed_cb(uint16_t local_channel_id, UNUSED_ATTR uint1
l2cap_client_t *client = find(local_channel_id); l2cap_client_t *client = find(local_channel_id);
if (!client) { if (!client) {
LOG_ERROR("%s unable to find L2CAP client with LCID 0x%04x.", __func__, local_channel_id); LOG_ERROR("%s unable to find L2CAP client with LCID 0x%04x.\n", __func__, local_channel_id);
return; return;
} }
@ -324,7 +324,7 @@ static void congestion_cb(uint16_t local_channel_id, bool is_congested) {
l2cap_client_t *client = find(local_channel_id); l2cap_client_t *client = find(local_channel_id);
if (!client) { if (!client) {
LOG_ERROR("%s unable to find L2CAP client matching LCID 0x%04x.", __func__, local_channel_id); LOG_ERROR("%s unable to find L2CAP client matching LCID 0x%04x.\n", __func__, local_channel_id);
return; return;
} }
@ -345,7 +345,7 @@ static void read_ready_cb(uint16_t local_channel_id, BT_HDR *packet) {
l2cap_client_t *client = find(local_channel_id); l2cap_client_t *client = find(local_channel_id);
if (!client) { if (!client) {
LOG_ERROR("%s unable to find L2CAP client matching LCID 0x%04x.", __func__, local_channel_id); LOG_ERROR("%s unable to find L2CAP client matching LCID 0x%04x.\n", __func__, local_channel_id);
return; return;
} }

2
components/bt/bluedroid/stack/smp/smp_l2c.c
View file

@ -296,7 +296,7 @@ static void smp_br_data_received(UINT16 channel, BD_ADDR bd_addr, BT_HDR *p_buf)
tSMP_CB *p_cb = &smp_cb; tSMP_CB *p_cb = &smp_cb;
UINT8 *p = (UINT8 *)(p_buf + 1) + p_buf->offset; UINT8 *p = (UINT8 *)(p_buf + 1) + p_buf->offset;
UINT8 cmd ; UINT8 cmd ;
SMP_TRACE_EVENT ("SMDBG l2c %s", __func__); SMP_TRACE_EVENT ("SMDBG l2c %s\n", __func__);
STREAM_TO_UINT8(cmd, p); STREAM_TO_UINT8(cmd, p);

1236
components/bt/bluedroid/stack_api/bt_app_api.c Normal file
View file

File diff suppressed because it is too large Load diff

0
examples/06_bluedroid_demos/components/bluedroid_demos/app_core/bt_app_sec.c → components/bt/bluedroid/stack_api/bt_app_sec.c
View file

924
components/bt/bluedroid/stack_api/include/bt_app_api.h Normal file
View file

@ -0,0 +1,924 @@
/**
****************************************************************************************
*
* @file bt_app_api.h
*
* @brief Application entry point
*
* Copyright (C) Espressif 2016
* Created by Yulong at 2016/10/13
*
*
****************************************************************************************
*/
#include "bt_types.h"
#include "bt_app_defs.h"
#include "bta_gatt_api.h"
#include "bt_prf_sys.h"
/*******************************************************************************
**
** @function esp_ble_config_adv_data
**
** @brief This function is called to override the BTA default ADV parameters.
**
** @param[in] adv_data: Pointer to User defined ADV data structure. This
** memory space can not be freed until p_adv_data_cback
** is received.
** @param[in|out] adv_data_cback: set adv data complete callback.
**
** @return None
**
*******************************************************************************/
void esp_ble_config_adv_data (esp_ble_adv_data_cfg_t *adv_data,
esp_ble_set_adv_data_cmpl_cb_t *adv_data_cback);
/*******************************************************************************
**
** @function esp_ble_set_scan_params
**
** @brief This function is called to set scan parameters
**
** @param[in] esp_ble_scan_params: Pointer to User defined scan_params data structure. This
** memory space can not be freed until scan_param_setup_cback
** @param[in] client_if: Client interface ID
** @param[in|out] scan_param_setup_status_cback - Set scan param status callback
**
** @return None
**
*******************************************************************************/
void esp_ble_set_scan_params (esp_ble_scan_params *scan_params, esp_gattc_if_t client_if,
esp_scan_param_setup_cb_t scan_param_setup_cback);
/*******************************************************************************
**
** @function esp_ble_start_scanning
**
** @brief This procedure keep the device scanning the peer device whith advertising on the air
**
** @param[in] duration: Keeping the scaning time, the unit is second.
** @param[in|out] results_cb: The scanning function callback when the peer device has been scan
** which advertising on the air
**
** @return None
**
*******************************************************************************/
void esp_ble_start_scanning (UINT8 duration, esp_dm_search_cb_t *results_cb);
/*******************************************************************************
**
** @function esp_ble_start_advertising
**
** @brief This function is called to start advertising.
**
** @param[in] esp_ble_adv_params_all_t: ointer to User defined adv_params data structure.
**
** @return None
**
*******************************************************************************/
void esp_ble_start_advertising (esp_ble_adv_params_all_t *ble_adv_params);
/*******************************************************************************
**
** @function esp_ble_stop_advertising
**
** @brief This function is called to stop advertising.
**
** @param None
**
** @return None
**
*******************************************************************************/
void esp_ble_stop_advertising (void);
/*******************************************************************************
**
** @function esp_ble_update_conn_params
**
** @brief Update connection parameters, can only be used when connection is up.
**
** @param[in] bd_addr - BD address of the peer
** @param[in] min_int - minimum connection interval, [0x0004~ 0x4000]
** @param[in] max_int - maximum connection interval, [0x0004~ 0x4000]
** @param[in] latency - slave latency [0 ~ 500]
** @param[in] timeout - supervision timeout [0x000a ~ 0xc80]
**
** @return None
**
*******************************************************************************/
void esp_ble_update_conn_params (BD_ADDR bd_addr, uint16_t min_int,
uint16_t max_int, uint16_t latency, uint16_t timeout);
/*******************************************************************************
**
** @function esp_ble_set_pkt_data_len
**
** @brief This function is to set maximum LE data packet size
**
** @return None
**
**
*******************************************************************************/
void esp_ble_set_pkt_data_len (BD_ADDR remote_device, uint16_t tx_data_length);
/*******************************************************************************
**
** @function esp_ble_set_rand_addr
**
** @brief This function set the random address for the appliction
**
** @param[in] rand_addr: the random address whith should be setting
**
** @return None
**
**
*******************************************************************************/
void esp_ble_set_rand_addr (BD_ADDR rand_addr);
/*******************************************************************************
**
** @function esp_ble_config_local_privacy
**
** @brief Enable/disable privacy on the local device
**
** @param[in] privacy_enable - enable/disabe privacy on remote device.
**
** @return None
**
*******************************************************************************/
void esp_ble_config_local_privacy (BOOLEAN privacy_enable);
/*******************************************************************************
** @function esp_gattc_disable
** @brief This function is called by application to disable GATTC module
**
** @param NULL
**
** @return None.
**
*******************************************************************************/
void esp_gattc_disable(void);
/*******************************************************************************
**
** @function esp_ble_gattc_app_register
**
** @brief This function is called to register application callbacks
** with GATTC module.
**
** @param[in] app_uuid - applicaiton UUID
** @param[in] client_cb - pointer to the application callback function.
**
** @return None
**
*******************************************************************************/
void esp_ble_gattc_app_register(esp_bt_uuid_t *app_uuid, esp_gattc_cb_t *client_cb);
/*******************************************************************************
**
** @function esp_ble_gattc_app_unregister
**
** @brief This function is called to unregister an application
** from GATTC module.
**
** @param[in] client_if - client interface identifier.
**
** @return None
**
*******************************************************************************/
void esp_ble_gattc_app_unregister(esp_gattc_if_t client_if);
/*******************************************************************************
**
** @function esp_ble_gattc_conn
**
** @brief Open a direct connection or add a background auto connection
** bd address
**
** @param[in] client_if: server interface.
** @param[in] remote_bda: remote device BD address.
** @param[in] is_direct: direct connection or background auto connection
**
** @return None
**
*******************************************************************************/
void esp_ble_gattc_conn(esp_gattc_if_t client_if, BD_ADDR remote_bda, BOOLEAN is_direct);
/*******************************************************************************
**
** @function esp_ble_gattc_cancel_conn
**
** @brief Cancel a direct open connection or remove a background auto connection
** bd address
**
** @param[in] client_if: server interface.
** @param[in] remote_bda: remote device BD address.
** @param[in] is_direct: direct connection or background auto connection
**
** @return None
**
*******************************************************************************/
void esp_ble_gattc_cancel_conn (esp_gattc_if_t client_if, BD_ADDR remote_bda, BOOLEAN is_direct);
/*******************************************************************************
**
** @function esp_ble_gattc_close
**
** @brief Close a connection to a GATT server.
**
** @param[in] conn_id: connectino ID to be closed.
**
** @return None
**
*******************************************************************************/
void esp_ble_gattc_close (uint16_t conn_id);
/*******************************************************************************
**
** @function esp_ble_gattc_config_mtu
**
** @brief Configure the MTU size in the GATT channel. This can be done
** only once per connection.
**
** @param[in] conn_id: connection ID.
** mtu: desired MTU size to use.
**
** @return Command status code:
** - @ref ESP_GATT_OK: If request succeeds
** - @ref ESP_GATT_ILLEGAL_PARAMETER: If the mtu value invalid
**
*******************************************************************************/
esp_gatt_status_t esp_ble_gattc_config_mtu (uint16_t conn_id, uint16_t mtu);
/*******************************************************************************
**
** @function esp_ble_gattc_svc_search_req
**
** @brief This function is called to request a GATT service discovery
** on a GATT server. This function report service search result
** by a callback event, and followed by a service search complete
** event.
**
** @param[in] conn_id: connection ID.
** @param[in] srvc_uuid: a UUID of the service application is interested in.
** If Null, discover for all services.
**
** @return None
**
*******************************************************************************/
void esp_ble_gattc_svc_search_req (uint16_t conn_id, esp_bt_uuid_t *srvc_uuid);
/****************************************************************************************************
**
** @function esp_ble_gattc_get_first_char
**
** @brief This function is called to find the first characteristic of the
** service on the given server.
**
** @param[in] conn_id: connection ID which identify the server.
** @param[in] srvc_id: the service ID of which the characteristic is belonged to.
** @param[in] char_uuid_cond: Characteristic UUID, if NULL find the first available
** characteristic.
** @param[in] char_result: output parameter which will store the GATT
** characteristic ID.
** @param[in] property: output parameter to carry the characteristic property.
**
** @return Command status code:
** - @ref ESP_GATT_OK: If request succeeds
** - @ref ESP_GATT_ILLEGAL_PARAMETER: If the srvc_id or char_result parameter is NULL.
**
*****************************************************************************************************/
esp_gatt_status_t esp_ble_gattc_get_first_char (uint16_t conn_id, esp_gatt_srvc_id_t *srvc_id,
esp_bt_uuid_t *char_uuid_cond,
esp_gattc_char_id_t *char_result,
esp_gatt_char_prop_t *property);
/*******************************************************************************
**
** @function esp_ble_gattc_get_first_char_descr
**
** @brief This function is called to find the first characteristic descriptor of the
** characteristic on the given server.
**
** @param[in] conn_id: connection ID which identify the server.
** @param[in] char_id: the characteristic ID of which the descriptor is belonged to.
** @param[in] descr_uuid_cond: Characteristic Descr UUID, if NULL find the first available
** characteristic.
** @param[in] descr_result: output parameter which will store the GATT
** characteristic descriptor ID.
**
** @return Command status code:
** - @ref ESP_GATT_OK: If request succeeds
** - @ref ESP_GATT_ILLEGAL_PARAMETER: If the char_id or descr_result parameter is NULL.
**
*******************************************************************************/
esp_gatt_status_t esp_ble_gattc_get_first_char_descr (uint16_t conn_id, esp_gattc_char_id_t *char_id,
esp_bt_uuid_t *descr_uuid_cond,
esp_gattc_char_descr_id_t *descr_result);
/*******************************************************************************
**
** @function esp_ble_gattc_get_next_inclu_srvc
**
** @brief This function is called to find the next included service of the
** service on the given server.
**
** @param[in] conn_id: connection ID which identify the server.
** @param[in] start_id: start the search from the next record
** after the one identified by p_start_id.
** @param[in] uuid_cond: Included service UUID, if NULL find the first available
** included service.
** @param[in] result: output parameter which will store the GATT ID
** of the included service found.
**
** @return Command status code:
** - @ref ESP_GATT_OK: If request succeeds
** - @ref ESP_GATT_ILLEGAL_PARAMETER: If the p_char_id or p_descr_result parameter is NULL.
*******************************************************************************/
esp_gatt_status_t esp_ble_gattc_get_next_inclu_srvc (uint16_t conn_id,
esp_gattc_incl_srvc_id_t *start_id,
esp_bt_uuid_t *uuid_cond,
esp_gattc_incl_srvc_id_t *result);
/*******************************************************************************
**
** @function esp_ble_gattc_get_next_char
**
** @brief This function is called to find the next characteristic of the
** service on the given server.
**
** @param[in] conn_id: connection ID which identify the server.
** @param[in] start_char_id: start the characteristic search from the next record
** after the one identified by char_id.
** @param[in] char_uuid_cond: Characteristic UUID, if NULL find the first available
** characteristic.
** @param[in] char_result: output parameter which will store the GATT
** characteristic ID.
** @param[in] property: output parameter to carry the characteristic property.
**
** @return Command status code:
** - @ref ESP_GATT_OK: If request succeeds
** - @ref ESP_GATT_ILLEGAL_PARAMETER: If the start_char_id or char_result parameter is NULL.
**
*******************************************************************************/
esp_gatt_status_t esp_ble_gattc_get_next_char (uint16_t conn_id,
esp_gattc_char_id_t *start_char_id,
esp_bt_uuid_t *char_uuid_cond,
esp_gattc_char_id_t *char_result,
esp_gatt_char_prop_t *property);
/*******************************************************************************
**
** @function esp_ble_gattc_get_next_char_descr
**
** @brief This function is called to find the next characteristic descriptor
** of the characterisctic.
**
** @param[in] conn_id: connection ID which identify the server.
** @param[in] start_descr_id: start the descriptor search from the next record
** after the one identified by p_start_descr_id.
** @param[in] descr_uuid_cond: Characteristic descriptor UUID, if NULL find
** the first available characteristic descriptor.
** @param[in] descr_result: output parameter which will store the GATT
** characteristic descriptor ID.
**
** @return Command status code:
** - @ref ESP_GATT_OK: If request succeeds
** - @ref ESP_GATT_ILLEGAL_PARAMETER: If the start_descr_id or descr_result parameter is NULL.
**
*******************************************************************************/
esp_gatt_status_t esp_ble_gattc_get_next_char_descr (uint16_t conn_id,
esp_gattc_char_descr_id_t *start_descr_id,
esp_bt_uuid_t *descr_uuid_cond,
esp_gattc_char_descr_id_t *descr_result);
/*******************************************************************************
**
** @function esp_ble_gattc_get_first_inclu_srvc
**
** @brief This function is called to find the first included service of the
** service on the given server.
**
** @param[in] conn_id: connection ID which identify the server.
** @param[in] srvc_id: the service ID of which the characteristic is belonged to.
** @param[in] uuid_cond: Characteristic UUID, if NULL find the first available
** characteristic.
** @param[in] result: output parameter which will store the GATT ID
** of the included service found.
**
** @return Command status code:
** - @ref ESP_GATT_OK: If request succeeds
** - @ref ESP_GATT_ILLEGAL_PARAMETER: If the srvc_id or result parameter is NULL.
**
*******************************************************************************/
esp_gatt_status_t esp_ble_gattc_get_first_inclu_srvc (uint16_t conn_id, esp_gatt_srvc_id_t *srvc_id,
esp_bt_uuid_t *uuid_cond, esp_gattc_incl_srvc_id_t *result);
/*******************************************************************************
**
** @function esp_ble_gattc_read_char
**
** @brief This function is called to read a service's characteristics of
** the given characteritisc ID.
**
** @param[in] conn_id - connectino ID.
** @param[in] char_id - characteritic ID to read.
**
** @return None
**
*******************************************************************************/
void esp_ble_gattc_read_char (uint16_t conn_id, esp_gattc_char_id_t *char_id,
esp_gatt_auth_req_t auth_req);
/*******************************************************************************
**
** @function esp_ble_gattc_read_char_descr
**
** @brief This function is called to read a characteristics descriptor.
**
** @param[in] conn_id - connection ID.
** @param[in] descr_id - characteritic descriptor ID to read.
**
** @return None
**
*******************************************************************************/
void esp_ble_gattc_read_char_descr (uint16_t conn_id,
esp_gattc_char_descr_id_t *descr_id,
esp_gatt_auth_req_t auth_req);
/*******************************************************************************
**
** @function esp_ble_gattc_read_multi
**
** @brief This function is called to read multiple characteristic or
** characteristic descriptors.
**
** @param[in] conn_id - connectino ID.
** @param[in] read_multi - pointer to the read multiple parameter.
**
** @return None
**
*******************************************************************************/
void esp_ble_gattc_read_multi (uint16_t conn_id, esp_gattc_multi_t *read_multi,
esp_gatt_auth_req_t auth_req);
/*******************************************************************************
**
** @function esp_ble_gattc_write_char_val
**
** @brief This function is called to write characteristic value.
**
** @param[in] conn_id - connection ID.
** @param[in] char_id - characteristic ID to write.
** @param[in] write_type - type of write.
** @param[in] len: length of the data to be written.
** @param[in] value - the value to be written.
**
** @return None
**
*******************************************************************************/
void esp_ble_gattc_write_char_val ( uint16_t conn_id,
esp_gattc_char_id_t *char_id,
esp_gattc_write_type_t write_type,
uint16_t len,
uint8_t *value,
esp_gatt_auth_req_t auth_req);
/*******************************************************************************
**
** @function esp_ble_gattc_write_char_descr
**
** @brief This function is called to write characteristic descriptor value.
**
** @param[in] conn_id - connection ID
** @param[in] char_descr_id - characteristic descriptor ID to write.
** @param[in] write_type - write type.
** @param[in] data - the value to be written.
**
** @return None
**
*******************************************************************************/
void esp_ble_gattc_write_char_descr (uint16_t conn_id,
esp_gattc_char_descr_id_t *char_descr_id,
esp_gattc_write_type_t write_type,
esp_gatt_unfmt_t *data,
esp_gatt_auth_req_t auth_req);
/*******************************************************************************
**
** @function esp_ble_gattc_prepa_write
**
** @brief This function is called to prepare write a characteristic value.
**
** @param[in] conn_id - connection ID.
** @param[in] char_id - GATT characteritic ID of the service.
** @param[in] offset - offset of the write value.
** @param[in] len: length of the data to be written.
** @param[in] value - the value to be written.
**
** @return None
**
*******************************************************************************/
void esp_ble_gattc_prepa_write (uint16_t conn_id, esp_gattc_char_id_t *char_id,
uint16_t offset, uint16_t len, uint8_t *value,
esp_gatt_auth_req_t auth_req);
/*******************************************************************************
**
** @function esp_ble_gattc_execu_write
**
** @brief This function is called to execute write a prepare write sequence.
**
** @param[in] conn_id - connection ID.
** @param[in] is_execute - execute or cancel.
**
** @return None
**
*******************************************************************************/
void esp_ble_gattc_execu_write (uint16_t conn_id, BOOLEAN is_execute);
/*******************************************************************************
**
** @function esp_ble_gattc_send_ind_cfm
**
** @brief This function is called to send handle value confirmation.
**
** @param[in] conn_id - connection ID.
** @param[in] char_id - characteristic ID to confirm.
**
** @return None
**
*******************************************************************************/
void esp_ble_gattc_send_ind_cfm (uint16_t conn_id, esp_gattc_char_id_t *char_id);
/*******************************************************************************
**
** @function esp_ble_gattc_register_ntf
**
** @brief This function is called to register for notification of a service.
**
** @param[in] client_if - client interface.
** @param[in] bda - target GATT server.
** @param[in] char_id - pointer to GATT characteristic ID.
**
** @return OK if registration succeed, otherwise failed.
**
*******************************************************************************/
esp_gatt_status_t esp_ble_gattc_register_ntf (esp_gattc_if_t client_if,
BD_ADDR bda,
esp_gattc_char_id_t *char_id);
/*******************************************************************************
**
** @function esp_ble_gattc_unregister_ntf
**
** @brief This function is called to de-register for notification of a service.
**
** @param[in] client_if - client interface.
** @param[in] bda - target GATT server.
** @param[in] char_id - pointer to GATT characteristic ID.
**
** @return OK if deregistration succeed, otherwise failed.
**
*******************************************************************************/
tBTA_GATT_STATUS esp_ble_gattc_unregister_ntf (esp_gattc_if_t client_if,
BD_ADDR bda,
esp_gattc_char_id_t *char_id);
/*******************************************************************************
**
** @function esp_ble_gatts_disale
**
** @brief This function is called to disable GATTS module
**
** @param[in] None.
**
** @return None
**
*******************************************************************************/
void esp_ble_gatts_disale(void);
/*******************************************************************************
**
** @function esp_ble_gatts_app_register
**
** @brief This function is called to register application callbacks
** with BTA GATTS module.
**
** @param[in] app_uuid - applicaiton UUID
** @param[in] cback - pointer to the application callback function.
**
** @return None
**
*******************************************************************************/
void esp_ble_gatts_app_register(esp_bt_uuid_t *app_uuid, esp_gatts_cb_t *cback);
/*******************************************************************************
**
** @function esp_ble_gatts_app_unregister
**
** @brief un-register with GATT Server.
**
** @param[in] server_if: service interface id.
**
** @return None
**
*******************************************************************************/
void esp_ble_gatts_app_unregister(esp_gatts_if_t server_if);
/*******************************************************************************
**
** @function esp_ble_gatts_create_srvc
**
** @brief Create a service. When service creation is done, a callback
** event BTA_GATTS_CREATE_SRVC_EVT is called to report status
** and service ID to the profile. The service ID obtained in
** the callback function needs to be used when adding included
** service and characteristics/descriptors into the service.
**
** @param[in] server_if: Profile ID this service is belonged to.
** @param[in] service_uuid: service UUID.
** @param[in] inst: instance ID number of this service.
** @param[in] num_handle: numble of handle requessted for this service.
** @param[in] is_primary: is this service a primary one or not.
**
** @return None
**
*******************************************************************************/
void esp_ble_gatts_create_srvc(esp_gatts_if_t server_if, esp_bt_uuid_t *service_uuid, uint8_t inst,
uint16_t num_handle, BOOLEAN is_primary);
/*******************************************************************************
**
** @function esp_ble_gatts_add_inclu_srvc
**
** @brief This function is called to add an included service. After included
** service is included, a callback event BTA_GATTS_ADD_INCL_SRVC_EVT
** is reported the included service ID.
**
** @param[in] service_id: service ID to which this included service is to
** be added.
** @param[in] included_service_id: the service ID to be included.
**
** @return None
**
*******************************************************************************/
void esp_ble_gatts_add_inclu_srvc (uint16_t service_id, uint16_t included_service_id);
/*******************************************************************************
**
** @function esp_ble_gatts_add_char
**
** @brief This function is called to add a characteristic into a service.
**
** @param[in] service_id: service ID to which this included service is to
** be added.
** @param[in] char_uuid : Characteristic UUID.
** @param[in] perm : Characteristic value declaration attribute permission.
** @param[in] property : Characteristic Properties
**
** @return None
**
*******************************************************************************/
void esp_ble_gatts_add_char (uint16_t service_id, esp_bt_uuid_t *char_uuid,
esp_gatt_perm_t perm, esp_gatt_char_prop_t property);
/*******************************************************************************
**
** @function esp_ble_gatts_add_char_descr
**
** @brief This function is called to add characteristic descriptor. When
** it's done, a callback event BTA_GATTS_ADD_DESCR_EVT is called
** to report the status and an ID number for this descriptor.
**
** @param[in] service_id: service ID to which this charatceristic descriptor is to
** be added.
** @param[in] perm: descriptor access permission.
** @param[in] descr_uuid: descriptor UUID.
**
** @return None
**
*******************************************************************************/
void esp_ble_gatts_add_char_descr (uint16_t service_id,
esp_gatt_perm_t perm,
esp_bt_uuid_t * descr_uuid);
/*******************************************************************************
**
** @function esp_ble_gatts_dele_srvc
**
** @brief This function is called to delete a service. When this is done,
** a callback event BTA_GATTS_DELETE_EVT is report with the status.
**
** @param[in] service_id: service_id to be deleted.
**
** @return None
**
*******************************************************************************/
void esp_ble_gatts_dele_srvc (uint16_t service_id);
/*******************************************************************************
**
** @function esp_ble_gatts_start_srvc
**
** @brief This function is called to start a service.
**
** @param[in] service_id: the service ID to be started.
** @param[in] sup_transport: supported trasnport.
**
** @return None
**
*******************************************************************************/
void esp_ble_gatts_start_srvc(uint16_t service_id);
/*******************************************************************************
**
** @function esp_ble_gatts_stop_srvc
**
** @brief This function is called to stop a service.
**
** @param[in] service_id - service to be topped.
**
** @return None
**
*******************************************************************************/
void esp_ble_gatts_stop_srvc(uint16_t service_id);
/*******************************************************************************
**
** @function esp_ble_gatts_hdl_val_indica
**
** @brief This function is called to read a characteristics descriptor.
**
** @param[in] bda - remote device bd address to indicate.
** @param[in] attr_id - attribute ID to indicate.
** @param[in] data_len - indicate data length.
** @param[in] data: data to indicate.
** @param[in] need_confirm - if this indication expects a confirmation or not.
**
** @return None
**
*******************************************************************************/
void esp_ble_gatts_hdl_val_indica (uint16_t conn_id, uint16_t attr_id, uint16_t data_len,
uint8_t *data, BOOLEAN need_confirm);
/*******************************************************************************
**
** @function esp_ble_gatts_send_rsp
**
** @brief This function is called to send a response to a request.
**
** @param[in] conn_id - connection identifier.
** @param[in] trans_id - transaction ID.
** @param[in] status - response status
** @param[in] msg - response data.
**
** @return None
**
*******************************************************************************/
void esp_ble_gatts_send_rsp (uint16_t conn_id, uint32_t trans_id,
esp_gatt_status_t status, esp_gatts_rsp_t *msg);
/*******************************************************************************
**
** @function esp_ble_gatts_conn
**
** @brief Open a direct open connection or add a background auto connection
** bd address
**
** @param[in] server_if: server interface.
** @param[in] remote_bda: remote device BD address.
** @param[in] is_direct: direct connection or background auto connection
**
** @return None
**
*******************************************************************************/
void esp_ble_gatts_conn (esp_gatts_if_t server_if, BD_ADDR remote_bda, BOOLEAN is_direct);
/*******************************************************************************
**
** @function esp_ble_gatts_cancel_conn
**
** @brief Cancel a direct open connection or remove a background auto connection
** bd address
**
** @param[in] server_if: server interface.
** @param[in] remote_bda: remote device BD address.
** @param[in] is_direct: direct connection or background auto connection
**
** @return None
**
*******************************************************************************/
void esp_ble_gatts_cancel_conn (esp_gatts_if_t server_if, BD_ADDR remote_bda, BOOLEAN is_direct);
/*******************************************************************************
**
** @function esp_ble_gatts_close
**
** @brief Close a connection a remote device.
**
** @param[in] conn_id: connectino ID to be closed.
**
** @return None
**
*******************************************************************************/
void esp_ble_gatts_close(uint16_t conn_id);
/*******************************************************************************
**
** @function esp_prf_app_register
**
** @brief This function is called to register application callbacks
** with BTA GATTS module.
**
** @param[in] prf_id - the profile identification
** @param[in] p_cback - pointer to the application callback function.
**
** @return None
**
*******************************************************************************/
void esp_prf_app_register(uint8_t prf_id, void *p_cback);

0
examples/06_bluedroid_demos/components/bluedroid_demos/include/bt_app_common.h → components/bt/bluedroid/stack_api/include/bt_app_common.h
View file

332
components/bt/bluedroid/stack_api/include/bt_app_defs.h Normal file
View file

@ -0,0 +1,332 @@
#ifndef _BT_APP_DEFS_H__
#define _BT_APP_DEFS_H__
#include "bta_api.h"
#include "btm_ble_api.h"
#include "bta_gatt_api.h"
#define ESP_BLE_CONN_PARAM_UNDEF 0xffff /* use this value when a specific value not to be overwritten */
#define ESP_BLE_ADV_CHNL_MAP (ESP_BLE_ADV_CHNL_37|ESP_BLE_ADV_CHNL_38|ESP_BLE_ADV_CHNL_39)
/* advertising channel map */
#define ESP_BLE_ADV_CHNL_37 (0x01 << 0)
#define ESP_BLE_ADV_CHNL_38 (0x01 << 1)
#define ESP_BLE_ADV_CHNL_39 (0x01 << 2)
typedef tBTA_GATT_STATUS esp_gatt_status_t;
typedef UINT16 gatt_size_t;
typedef tBT_UUID esp_bt_uuid_t;
typedef tBTA_GATT_ID esp_gatt_id_t;
typedef tBTA_BLE_AD_MASK esp_ble_ad_mask_t;
typedef tGATT_IF esp_gatt_if_t;
typedef tBTA_GATT_SRVC_ID esp_gatt_srvc_id_t;
typedef tBTA_GATTC_CHAR_ID esp_gattc_char_id_t;
typedef tBTA_GATTC_CHAR_DESCR_ID esp_gattc_char_descr_id_t;
typedef tBTA_GATTC_INCL_SVC_ID esp_gattc_incl_srvc_id_t;
typedef tBTA_GATT_AUTH_REQ esp_gatt_auth_req_t;
typedef tBTA_GATTC_MULTI esp_gattc_multi_t;
typedef tBTA_GATTC_WRITE_TYPE esp_gattc_write_type_t;
typedef tBTA_GATT_UNFMT esp_gatt_unfmt_t;
typedef tBTA_GATT_PERM esp_gatt_perm_t;
typedef tBTA_GATT_CHAR_PROP esp_gatt_char_prop_t;
typedef tBTA_GATTC esp_gattc_t;
typedef tBTA_GATTC_EVT esp_gattc_evt_t;
typedef tBTA_GATTC_IF esp_gattc_if_t;
/* Client callback function events */
#define ESP_GATTC_REG_EVT 0 /* GATT client is registered. */
#define ESP_GATTC_DEREG_EVT 1 /* GATT client deregistered event */
#define ESP_GATTC_OPEN_EVT 2 /* GATTC open request status event */
#define ESP_GATTC_READ_CHAR_EVT 3 /* GATT read characteristic event */
#define ESP_GATTC_WRITE_CHAR_EVT 4 /* GATT write characteristic or char descriptor event */
#define ESP_GATTC_CLOSE_EVT 5 /* GATTC close request status event */
#define ESP_GATTC_SEARCH_CMPL_EVT 6 /* GATT discovery complete event */
#define ESP_GATTC_SEARCH_RES_EVT 7 /* GATT discovery result event */
#define ESP_GATTC_READ_DESCR_EVT 8 /* GATT read characterisitc descriptor event */
#define ESP_GATTC_WRITE_DESCR_EVT 9 /* GATT write characteristic descriptor event */
#define ESP_GATTC_NOTIF_EVT 10 /* GATT attribute notification event */
#define ESP_GATTC_PREP_WRITE_EVT 11 /* GATT prepare write event */
#define ESP_GATTC_EXEC_EVT 12 /* execute write complete event */
#define ESP_GATTC_ACL_EVT 13 /* ACL up event */
#define ESP_GATTC_CANCEL_OPEN_EVT 14 /* cancel open event */
#define ESP_GATTC_SRVC_CHG_EVT 15 /* service change event */
#define ESP_GATTC_ENC_CMPL_CB_EVT 17 /* encryption complete callback event */
#define ESP_GATTC_CFG_MTU_EVT 18 /* configure MTU complete event */
#define ESP_GATTC_ADV_DATA_EVT 19 /* ADV data event */
#define ESP_GATTC_MULT_ADV_ENB_EVT 20 /* Enable Multi ADV event */
#define ESP_GATTC_MULT_ADV_UPD_EVT 21 /* Update parameter event */
#define ESP_GATTC_MULT_ADV_DATA_EVT 22 /* Multi ADV data event */
#define ESP_GATTC_MULT_ADV_DIS_EVT 23 /* Disable Multi ADV event */
#define ESP_GATTC_CONGEST_EVT 24 /* Congestion event */
#define ESP_GATTC_BTH_SCAN_ENB_EVT 25 /* Enable batch scan event */
#define ESP_GATTC_BTH_SCAN_CFG_EVT 26 /* Config storage event */
#define ESP_GATTC_BTH_SCAN_RD_EVT 27 /* Batch scan reports read event */
#define ESP_GATTC_BTH_SCAN_THR_EVT 28 /* Batch scan threshold event */
#define ESP_GATTC_BTH_SCAN_PARAM_EVT 29 /* Batch scan param event */
#define ESP_GATTC_BTH_SCAN_DIS_EVT 30 /* Disable batch scan event */
#define ESP_GATTC_SCAN_FLT_CFG_EVT 31 /* Scan filter config event */
#define ESP_GATTC_SCAN_FLT_PARAM_EVT 32 /* Param filter event */
#define ESP_GATTC_SCAN_FLT_STATUS_EVT 33 /* Filter status event */
#define ESP_GATTC_ADV_VSC_EVT 34 /* ADV VSC event */
/* GATT Server Data Structure */
/* Server callback function events */
#define ESP_GATTS_REG_EVT 0
#define ESP_GATTS_READ_EVT GATTS_REQ_TYPE_READ /* 1 */
#define ESP_GATTS_WRITE_EVT GATTS_REQ_TYPE_WRITE /* 2 */
#define ESP_GATTS_EXEC_WRITE_EVT GATTS_REQ_TYPE_WRITE_EXEC /* 3 */
#define ESP_GATTS_MTU_EVT GATTS_REQ_TYPE_MTU /* 4 */
#define ESP_GATTS_CFM_EVT GATTS_REQ_TYPE_CONF /* 5 */
#define ESP_GATTS_DEREG_EVT 6
#define ESP_GATTS_CREATE_EVT 7
#define ESP_GATTS_ADD_INCL_SRVC_EVT 8
#define ESP_GATTS_ADD_CHAR_EVT 9
#define ESP_GATTS_ADD_CHAR_DESCR_EVT 10
#define ESP_GATTS_DELELTE_EVT 11
#define ESP_GATTS_START_EVT 12
#define ESP_GATTS_STOP_EVT 13
#define ESP_GATTS_CONNECT_EVT 14
#define ESP_GATTS_DISCONNECT_EVT 15
#define ESP_GATTS_OPEN_EVT 16
#define ESP_GATTS_CANCEL_OPEN_EVT 17
#define ESP_GATTS_CLOSE_EVT 18
#define ESP_GATTS_CONGEST_EVT 20
/* Attribute permissions
*/
#define ESP_GATT_PERM_READ BTA_GATT_PERM_READ /* bit 0 - 0x0001 */
#define ESP_GATT_PERM_READ_ENCRYPTED BTA_GATT_PERM_READ_ENCRYPTED /* bit 1 - 0x0002 */
#define ESP_GATT_PERM_READ_ENC_MITM BTA_GATT_PERM_READ_ENC_MITM /* bit 2 - 0x0004 */
#define ESP_GATT_PERM_WRITE BTA_GATT_PERM_WRITE /* bit 4 - 0x0010 */
#define ESP_GATT_PERM_WRITE_ENCRYPTED BTA_GATT_PERM_WRITE_ENCRYPTED /* bit 5 - 0x0020 */
#define ESP_GATT_PERM_WRITE_ENC_MITM BTA_GATT_PERM_WRITE_ENC_MITM /* bit 6 - 0x0040 */
#define ESP_GATT_PERM_WRITE_SIGNED BTA_GATT_PERM_WRITE_SIGNED /* bit 7 - 0x0080 */
#define ESP_GATT_PERM_WRITE_SIGNED_MITM BTA_GATT_PERM_WRITE_SIGNED_MITM /* bit 8 - 0x0100 */
#define ESP_GATTS_INVALID_APP 0xff
#define ESP_GATTS_INVALID_IF 0
/* definition of characteristic properties */
#define ESP_GATT_CHAR_PROP_BIT_BROADCAST BTA_GATT_CHAR_PROP_BIT_BROADCAST /* 0x01 */
#define ESP_GATT_CHAR_PROP_BIT_READ BTA_GATT_CHAR_PROP_BIT_READ /* 0x02 */
#define ESP_GATT_CHAR_PROP_BIT_WRITE_NR BTA_GATT_CHAR_PROP_BIT_WRITE_NR /* 0x04 */
#define ESP_GATT_CHAR_PROP_BIT_WRITE BTA_GATT_CHAR_PROP_BIT_WRITE /* 0x08 */
#define ESP_GATT_CHAR_PROP_BIT_NOTIFY BTA_GATT_CHAR_PROP_BIT_NOTIFY /* 0x10 */
#define ESP_GATT_CHAR_PROP_BIT_INDICATE BTA_GATT_CHAR_PROP_BIT_INDICATE /* 0x20 */
#define ESP_GATT_CHAR_PROP_BIT_AUTH BTA_GATT_CHAR_PROP_BIT_AUTH /* 0x40 */
#define ESP_GATT_CHAR_PROP_BIT_EXT_PROP BTA_GATT_CHAR_PROP_BIT_EXT_PROP /* 0x80 */
typedef tBTA_GATTS_EVT esp_gatts_evt_t;
typedef tBTA_GATTS_IF esp_gatts_if_t;
/* attribute value */
typedef tBTA_GATT_VALUE esp_gatt_value_t;
/* attribute response data */
typedef tBTA_GATTS_RSP esp_gatts_rsp_t;
typedef tBTA_GATTS esp_gatts_t;
/* attribute request data from the client */
#define ESP_GATT_PREP_WRITE_CANCEL 0x00
#define ESP_GATT_PREP_WRITE_EXEC 0x01
typedef tBTA_GATT_EXEC_FLAG esp_gatt_exec_flag_t;
/* read request always based on UUID */
typedef tBTA_GATT_READ_REQ esp_gatt_read_req_t;
/* write request data */
typedef tBTA_GATT_WRITE_REQ esp_gatt_write_req_t;
/* callback data for server access request from client */
typedef tBTA_GATTS_REQ_DATA esp_gatts_req_data_t;
/* Search callback */
typedef tBTA_DM_SEARCH_CBACK esp_dm_search_cb_t;
typedef tBLE_SCAN_PARAM_SETUP_CBACK esp_scan_param_setup_cb_t;
typedef tBTA_SET_ADV_DATA_CMPL_CBACK esp_ble_set_adv_data_cmpl_cb_t;
/* GATTC enable callback function */
typedef void (esp_gattc_enb_cb_t)(esp_gatt_status_t status);
/* Client callback function */
typedef void (esp_gattc_cb_t)(esp_gattc_evt_t event, esp_gattc_t *cb_data);
/* GATTS enable callback function */
typedef void (esp_gatts_enb_cb_t)(esp_gatt_status_t status);
/* Server callback function */
typedef void (esp_gatts_cb_t)(esp_gatts_evt_t event, esp_gatts_t *cb_data);
/* Success code and error codes */
#define ESP_GATT_OK BTA_GATT_OK
#define ESP_GATT_INVALID_HANDLE BTA_GATT_INVALID_HANDLE /* 0x0001 */
#define ESP_GATT_READ_NOT_PERMIT BTA_GATT_READ_NOT_PERMIT /* 0x0002 */
#define ESP_GATT_WRITE_NOT_PERMIT BTA_GATT_WRITE_NOT_PERMIT /* 0x0003 */
#define ESP_GATT_INVALID_PDU BTA_GATT_INVALID_PDU /* 0x0004 */
#define ESP_GATT_INSUF_AUTHENTICATION BTA_GATT_INSUF_AUTHENTICATION /* 0x0005 */
#define ESP_GATT_REQ_NOT_SUPPORTED BTA_GATT_REQ_NOT_SUPPORTED /* 0x0006 */
#define ESP_GATT_INVALID_OFFSET BTA_GATT_INVALID_OFFSET /* 0x0007 */
#define ESP_GATT_INSUF_AUTHORIZATION BTA_GATT_INSUF_AUTHORIZATION /* 0x0008 */
#define ESP_GATT_PREPARE_Q_FULL BTA_GATT_PREPARE_Q_FULL /* 0x0009 */
#define ESP_GATT_NOT_FOUND BTA_GATT_NOT_FOUND /* 0x000a */
#define ESP_GATT_NOT_LONG BTA_GATT_NOT_LONG /* 0x000b */
#define ESP_GATT_INSUF_KEY_SIZE BTA_GATT_INSUF_KEY_SIZE /* 0x000c */
#define ESP_GATT_INVALID_ATTR_LEN BTA_GATT_INVALID_ATTR_LEN /* 0x000d */
#define ESP_GATT_ERR_UNLIKELY BTA_GATT_ERR_UNLIKELY /* 0x000e */
#define ESP_GATT_INSUF_ENCRYPTION BTA_GATT_INSUF_ENCRYPTION /* 0x000f */
#define ESP_GATT_UNSUPPORT_GRP_TYPE BTA_GATT_UNSUPPORT_GRP_TYPE /* 0x0010 */
#define ESP_GATT_INSUF_RESOURCE BTA_GATT_INSUF_RESOURCE /* 0x0011 */
#define ESP_GATT_NO_RESOURCES BTA_GATT_NO_RESOURCES /* 0x80 */
#define ESP_GATT_INTERNAL_ERROR BTA_GATT_INTERNAL_ERROR /* 0x81 */
#define ESP_GATT_WRONG_STATE BTA_GATT_WRONG_STATE /* 0x82 */
#define ESP_GATT_DB_FULL BTA_GATT_DB_FULL /* 0x83 */
#define ESP_GATT_BUSY BTA_GATT_BUSY /* 0x84 */
#define ESP_GATT_ERROR BTA_GATT_ERROR /* 0x85 */
#define ESP_GATT_CMD_STARTED BTA_GATT_CMD_STARTED /* 0x86 */
#define ESP_GATT_ILLEGAL_PARAMETER BTA_GATT_ILLEGAL_PARAMETER /* 0x87 */
#define ESP_GATT_PENDING BTA_GATT_PENDING /* 0x88 */
#define ESP_GATT_AUTH_FAIL BTA_GATT_AUTH_FAIL /* 0x89 */
#define ESP_GATT_MORE BTA_GATT_MORE /* 0x8a */
#define ESP_GATT_INVALID_CFG BTA_GATT_INVALID_CFG /* 0x8b */
#define ESP_GATT_SERVICE_STARTED BTA_GATT_SERVICE_STARTED /* 0x8c */
#define ESP_GATT_ENCRYPED_MITM BTA_GATT_ENCRYPED_MITM /* GATT_SUCCESS */
#define ESP_GATT_ENCRYPED_NO_MITM BTA_GATT_ENCRYPED_NO_MITM /* 0x8d */
#define ESP_GATT_NOT_ENCRYPTED BTA_GATT_NOT_ENCRYPTED /* 0x8e */
#define ESP_GATT_CONGESTED BTA_GATT_CONGESTED /* 0x8f */
#define ESP_GATT_DUP_REG BTA_GATT_DUP_REG /* 0x90 */
#define ESP_GATT_ALREADY_OPEN BTA_GATT_ALREADY_OPEN /* 0x91 */
#define ESP_GATT_CANCEL BTA_GATT_CANCEL /* 0x92 */
/* 0xE0 ~ 0xFC reserved for future use */
#define ESP_GATT_CCC_CFG_ERR BTA_GATT_CCC_CFG_ERR /* 0xFD Client Characteristic Configuration Descriptor Improperly Configured */
#define ESP_GATT_PRC_IN_PROGRESS BTA_GATT_PRC_IN_PROGRESS /* 0xFE Procedure Already in progress */
#define ESP_GATT_OUT_OF_RANGE BTA_GATT_OUT_OF_RANGE /* 0xFFAttribute value out of range */
#define API_BLE_ISVALID_PARAM(x, min, max) (((x) >= (min) && (x) <= (max)) || ((x) == ESP_BLE_CONN_PARAM_UNDEF))
enum
{
BLE_ADV_DATA_IDX,
BLE_SCAN_RSP_DATA_IDX,
ADV_SCAN_IDX_MAX
};
/// Advertising mode
enum api_adv_type
{
/// Mode in non-discoverable
API_NON_DISCOVERABLE,
/// Mode in general discoverable
API_GEN_DISCOVERABLE,
/// Mode in limited discoverable
API_LIM_DISCOVERABLE,
/// Broadcaster mode which is a non discoverable and non connectable mode.
API_BROADCASTER_MODE,
};
enum api_adv_filter
{
///Allow both scan and connection requests from anyone
ADV_ALLOW_SCAN_ANY_CON_ANY = 0x00,
///Allow both scan req from White List devices only and connection req from anyone
ADV_ALLOW_SCAN_WLST_CON_ANY,
///Allow both scan req from anyone and connection req from White List devices only
ADV_ALLOW_SCAN_ANY_CON_WLST,
///Allow scan and connection requests from White List devices only
ADV_ALLOW_SCAN_WLST_CON_WLST,
///Enumeration end value for advertising filter policy value check
ADV_ALLOW_SCAN_END
};
/// Own BD address source of the device
enum api_own_addr_src
{
/// Public Address
API_PUBLIC_ADDR,
/// Provided random address
API_PROVIDED_RND_ADDR,
/// Provided static random address
API_GEN_STATIC_RND_ADDR,
/// Generated resolvable private random address
API_GEN_RSLV_ADDR,
/// Generated non-resolvable private random address
API_GEN_NON_RSLV_ADDR,
/// Provided Reconnection address
API_PROVIDED_RECON_ADDR,
};
typedef struct
{
char *adv_name; //set the device name to be sent on the advertising
tBTA_BLE_ADV_DATA ble_adv_data;
}esp_ble_adv_data_cfg_t;
typedef struct
{
UINT16 adv_int_min;
UINT16 adv_int_max;
tBLE_BD_ADDR *p_dir_bda;
}esp_ble_adv_params_t;
typedef struct
{
UINT16 adv_int_min;
UINT16 adv_int_max;
UINT8 adv_type;
tBLE_ADDR_TYPE addr_type_own;
tBTM_BLE_ADV_CHNL_MAP channel_map;
tBTM_BLE_AFP adv_filter_policy;
tBLE_BD_ADDR *p_dir_bda;
}esp_ble_adv_params_all_t;
typedef struct
{
UINT8 scan_type;
UINT16 scan_intv;
UINT16 scan_win;
UINT8 addr_type_own;
UINT8 scan_fil_policy;
}esp_ble_scan_params;
extern void ble_config_adv_data(esp_ble_adv_data_cfg_t *adv_data,
tBTA_SET_ADV_DATA_CMPL_CBACK *p_adv_data_cback);
extern void ble_set_scan_rsp(esp_ble_adv_data_cfg_t *scan_rsp_data,
tBTA_SET_ADV_DATA_CMPL_CBACK *p_scan_rsp_data_cback);
#endif ///_BT_APP_DEFS_H__

0
examples/06_bluedroid_demos/components/bluedroid_demos/include/bt_app_sec.h → components/bt/bluedroid/stack_api/include/bt_app_sec.h
View file

37
examples/06_bluedroid_demos/components/bluedroid_demos/app_client_profiles/battery_c/battery_c.c
View file

@ -17,14 +17,15 @@
#include "btm_api.h" #include "btm_api.h"
#include "bt_types.h" #include "bt_types.h"
#include "gattc_profile.h" #include "gattc_profile.h"
#include "bt_app_api.h"
#define BT_BD_ADDR_STR "%02x:%02x:%02x:%02x:%02x:%02x" #define BT_BD_ADDR_STR "%02x:%02x:%02x:%02x:%02x:%02x"
#define BT_BD_ADDR_HEX(addr) addr[0], addr[1], addr[2], addr[3], addr[4], addr[5] #define BT_BD_ADDR_HEX(addr) addr[0], addr[1], addr[2], addr[3], addr[4], addr[5]
tBTA_GATTC_IF client_if; esp_gattc_if_t client_if;
tBT_UUID bas_uuid = {LEN_UUID_16, {UUID_SERVCLASS_BATTERY}}; esp_bt_uuid_t bas_uuid = {LEN_UUID_16, {UUID_SERVCLASS_BATTERY}};
uint16_t get_uuid16(tBT_UUID* p_uuid) uint16_t get_uuid16(esp_bt_uuid_t* p_uuid)
{ {
if(p_uuid->len == LEN_UUID_16) if(p_uuid->len == LEN_UUID_16)
{ {
@ -52,17 +53,17 @@ void bta_le_fill_16bits_gatt_id(UINT8 inst_id, UINT16 uuid, tBTA_GATT_ID* p_outp
} }
/*fill a service ID structure with a 16 bits service UUID*/ /*fill a service ID structure with a 16 bits service UUID*/
void bta_le_fill_16bits_srvc_id(bool is_pri, UINT8 inst_id, UINT16 srvc_uuid, tBTA_GATT_SRVC_ID* p_output) void bta_le_fill_16bits_srvc_id(bool is_pri, UINT8 inst_id, UINT16 srvc_uuid, esp_gatt_srvc_id_t* p_output)
{ {
memset((void *)p_output, 0, sizeof(tBTA_GATT_SRVC_ID)); memset((void *)p_output, 0, sizeof(esp_gatt_srvc_id_t));
p_output->is_primary = is_pri; p_output->is_primary = is_pri;
bta_le_fill_16bits_gatt_id(inst_id, srvc_uuid, &p_output->id); bta_le_fill_16bits_gatt_id(inst_id, srvc_uuid, &p_output->id);
} }
/*fill a char ID structure with a 16 bits char UUID*/ /*fill a char ID structure with a 16 bits char UUID*/
void bta_le_fill_16bits_char_id(UINT8 inst_id, UINT16 char_uuid, tBTA_GATT_ID* p_output) void bta_le_fill_16bits_char_id(UINT8 inst_id, UINT16 char_uuid, esp_gatt_id_t* p_output)
{ {
memset((void *)p_output, 0, sizeof(tBTA_GATT_ID)); memset((void *)p_output, 0, sizeof(esp_gatt_id_t));
bta_le_fill_16bits_gatt_id(inst_id, char_uuid, p_output); bta_le_fill_16bits_gatt_id(inst_id, char_uuid, p_output);
} }
@ -71,13 +72,13 @@ void bta_le_fill_16bits_char_id(UINT8 inst_id, UINT16 char_uuid, tBTA_GATT_ID* p
** **
** Description battery service register callback function ** Description battery service register callback function
*******************************************************************************/ *******************************************************************************/
static void bas_gattc_callback(tBTA_GATTC_EVT event, tBTA_GATTC* p_data) static void bas_gattc_callback(esp_gattc_evt_t event, esp_gattc_t* p_data)
{ {
switch (event) switch (event)
{ {
case BTA_GATTC_REG_EVT: case ESP_GATTC_REG_EVT:
{ {
tBTA_GATT_STATUS status = p_data->reg_oper.status; esp_gatt_status_t status = p_data->reg_oper.status;
client_if = p_data->reg_oper.client_if; client_if = p_data->reg_oper.client_if;
LOG_ERROR("BAS register completed: event=%d, status=%d, client_if=%d\n", LOG_ERROR("BAS register completed: event=%d, status=%d, client_if=%d\n",
event, status, client_if); event, status, client_if);
@ -86,7 +87,7 @@ static void bas_gattc_callback(tBTA_GATTC_EVT event, tBTA_GATTC* p_data)
break; break;
/*connect callback*/ /*connect callback*/
case BTA_GATTC_OPEN_EVT: case ESP_GATTC_OPEN_EVT:
{ {
LOG_ERROR("\n%s:device is connected "BT_BD_ADDR_STR", client_if=%d, status=%d, connect_id=%d\n", LOG_ERROR("\n%s:device is connected "BT_BD_ADDR_STR", client_if=%d, status=%d, connect_id=%d\n",
@ -101,12 +102,12 @@ static void bas_gattc_callback(tBTA_GATTC_EVT event, tBTA_GATTC* p_data)
int conn_id = p_data->open.conn_id; int conn_id = p_data->open.conn_id;
/*discover service*/ /*discover service*/
BTA_GATTC_ServiceSearchRequest(conn_id, NULL); esp_ble_gattc_svc_search_req(conn_id, NULL);
} }
break; break;
case BTA_GATTC_SEARCH_RES_EVT: case ESP_GATTC_SEARCH_RES_EVT:
{ {
// tBTA_GATTC_SRVC_RES service_result; // tBTA_GATTC_SRVC_RES service_result;
LOG_ERROR("find the service,uuid=0x%x, is_primary=%d\n", LOG_ERROR("find the service,uuid=0x%x, is_primary=%d\n",
@ -115,7 +116,7 @@ static void bas_gattc_callback(tBTA_GATTC_EVT event, tBTA_GATTC* p_data)
} }
break; break;
case BTA_GATTC_SEARCH_CMPL_EVT: case ESP_GATTC_SEARCH_CMPL_EVT:
{ {
LOG_ERROR("search service complete, conn_id=%d,status=%d\n", p_data->search_cmpl.conn_id, LOG_ERROR("search service complete, conn_id=%d,status=%d\n", p_data->search_cmpl.conn_id,
p_data->search_cmpl.status); p_data->search_cmpl.status);
@ -127,7 +128,7 @@ static void bas_gattc_callback(tBTA_GATTC_EVT event, tBTA_GATTC* p_data)
tBTA_GATTC_CHAR_ID out_char_id; tBTA_GATTC_CHAR_ID out_char_id;
tGATT_CHAR_PROP out_char_prop; tGATT_CHAR_PROP out_char_prop;
bta_le_fill_16bits_srvc_id(TRUE, 0, UUID_SERVCLASS_BATTERY, &battery_srvc_id); bta_le_fill_16bits_srvc_id(TRUE, 0, UUID_SERVCLASS_BATTERY, &battery_srvc_id);
status = BTA_GATTC_GetFirstChar(p_data->search_cmpl.conn_id, &battery_srvc_id, NULL, status = esp_ble_gattc_get_first_char(p_data->search_cmpl.conn_id, &battery_srvc_id, NULL,
&out_char_id, &out_char_prop); &out_char_id, &out_char_prop);
if(status == 0) if(status == 0)
{ {
@ -139,13 +140,13 @@ static void bas_gattc_callback(tBTA_GATTC_EVT event, tBTA_GATTC* p_data)
bta_le_fill_16bits_srvc_id(TRUE, 0, UUID_SERVCLASS_BATTERY, &battery_char_id.srvc_id); bta_le_fill_16bits_srvc_id(TRUE, 0, UUID_SERVCLASS_BATTERY, &battery_char_id.srvc_id);
bta_le_fill_16bits_char_id(0, GATT_UUID_BATTERY_LEVEL, &battery_char_id.char_id); bta_le_fill_16bits_char_id(0, GATT_UUID_BATTERY_LEVEL, &battery_char_id.char_id);
BTA_GATTC_ReadCharacteristic(p_data->search_cmpl.conn_id, &battery_char_id, esp_ble_gattc_read_char(p_data->search_cmpl.conn_id, &battery_char_id,
BTA_GATT_AUTH_REQ_NONE); BTA_GATT_AUTH_REQ_NONE);
} }
} }
break; break;
case BTA_GATTC_READ_CHAR_EVT: case ESP_GATTC_READ_CHAR_EVT:
{ {
LOG_ERROR("\nread characteristic:connect_id=%d, status=%d\n", LOG_ERROR("\nread characteristic:connect_id=%d, status=%d\n",
@ -179,7 +180,7 @@ static void bas_gattc_callback(tBTA_GATTC_EVT event, tBTA_GATTC* p_data)
****************************************************************/ ****************************************************************/
void bac_register(void) void bac_register(void)
{ {
BTA_GATTC_AppRegister(&bas_uuid, bas_gattc_callback); esp_ble_gattc_app_register(&bas_uuid, bas_gattc_callback);
} }

4
examples/06_bluedroid_demos/components/bluedroid_demos/app_core/bt_app.c
View file

@ -29,7 +29,7 @@
** Returns None ** Returns None
** **
*******************************************************************************/ *******************************************************************************/
void ESP_AppBleConfigadvData(tESP_BLE_ADV_DATA *adv_data, void ble_config_adv_data(esp_ble_adv_data_cfg_t *adv_data,
tBTA_SET_ADV_DATA_CMPL_CBACK *p_adv_data_cback) tBTA_SET_ADV_DATA_CMPL_CBACK *p_adv_data_cback)
{ {
tBTA_BLE_AD_MASK data_mask = 0; tBTA_BLE_AD_MASK data_mask = 0;
@ -112,7 +112,7 @@
** Returns None ** Returns None
** **
*******************************************************************************/ *******************************************************************************/
void ESP_AppBleSetScanRsp(tESP_BLE_ADV_DATA *scan_rsp_data, void ble_set_scan_rsp(esp_ble_adv_data_cfg_t *scan_rsp_data,
tBTA_SET_ADV_DATA_CMPL_CBACK *p_scan_rsp_data_cback) tBTA_SET_ADV_DATA_CMPL_CBACK *p_scan_rsp_data_cback)
{ {
tBTA_BLE_AD_MASK data_mask = 0; tBTA_BLE_AD_MASK data_mask = 0;

12
examples/06_bluedroid_demos/components/bluedroid_demos/app_core/bt_app_core.c
View file

@ -68,13 +68,13 @@ static void bt_app_task_handler(void *arg)
fixed_queue_process(bt_app_general_alarm_queue); fixed_queue_process(bt_app_general_alarm_queue);
} }
#if (BUT_PROFILE_CFG) #if (BUT_PROFILE_CFG)
else if(e->sig == BUTTON_PRESS_EVT){ // else if(e->sig == BUTTON_PRESS_EVT){
LOG_ERROR("button_press_event come in,button_value=%x\n",e->par); // LOG_ERROR("button_press_event come in,button_value=%x\n",e->par);
button_msg[1] = e->par; // button_msg[1] = e->par;
button_msg_notify(2,button_msg); // button_msg_notify(2,button_msg);
} //}
#endif ///BUT_PROFILE_CFG #endif ///BUT_PROFILE_CFG
} }
@ -253,7 +253,7 @@ static void bt_app_dm_upstreams_evt(UINT16 event, char *p_param)
/*set connectable,discoverable, pairable and paired only modes of local device*/ /*set connectable,discoverable, pairable and paired only modes of local device*/
tBTA_DM_DISC disc_mode = BTA_DM_BLE_GENERAL_DISCOVERABLE; tBTA_DM_DISC disc_mode = BTA_DM_BLE_GENERAL_DISCOVERABLE;
tBTA_DM_CONN conn_mode = BTA_DM_BLE_CONNECTABLE; tBTA_DM_CONN conn_mode = BTA_DM_BLE_CONNECTABLE;
BTA_DmSetVisibility(disc_mode, conn_mode, (UINT8)BTA_DM_NON_PAIRABLE, (UINT8)BTA_DM_CONN_ALL); //BTA_DmSetVisibility(disc_mode, conn_mode, (UINT8)BTA_DM_NON_PAIRABLE, (UINT8)BTA_DM_CONN_ALL);
#if (defined(BLE_INCLUDED) && (BLE_INCLUDED == TRUE)) #if (defined(BLE_INCLUDED) && (BLE_INCLUDED == TRUE))
/* Enable local privacy */ /* Enable local privacy */

120
examples/06_bluedroid_demos/components/bluedroid_demos/app_profiles/app_sample_button/app_button.c
View file

@ -15,7 +15,13 @@
******************************************************************************* *******************************************************************************
********* *********
*/ */
#if 0
#include "prf_defs.h"
#if (BUT_PROFILE_CFG)
#include <stdint.h> #include <stdint.h>
#include <string.h> #include <string.h>
#include <stdbool.h> #include <stdbool.h>
@ -33,6 +39,118 @@
#include "allocator.h" #include "allocator.h"
#include "button_pro.h" #include "button_pro.h"
#include "app_button_int.h"
static const tBT_PRF_SYS_REG but_prf_reg =
{
ble_but_prf_hdl_event,
ble_but_prf_disable
};
/*******************************************************************************
**
** Function ble_but_prf_hdl_event
**
** Description button profile main event handling function.
**
**
** Returns BOOLEAN
**
*******************************************************************************/
BOOLEAN ble_but_prf_hdl_event(prf_hdr_evt_t *msg_data)
{
LOG_ERROR("###################ble_but_prf_hdl_event#####################################\n");
UINT16 connid = 0;
switch(msg_data->event)
{
case BLE_BUT_CREATE_DB_REQ_EVT:
Button_CreateService();
break;
case BLE_BUT_VAL_SEND_CFM_EVT:
break;
case BLE_BUT_SET_CHAR_VAL_REQ_EVT:
button_msg_notify(msg_data->len,msg_data->data);
break;
case BLE_BUT_ENABLE_REQ_EVT:
button_init(NULL);
break;
case BLE_BUT_DISABLE_IND_EVT:
button_disable(connid);
break;
case BLE_BUT_CHAR_WRITE_IND_EVT:
break;
case BLE_BUT_ERROR_IND_EVT:
break;
default:
break;
}
}
/*******************************************************************************
**
** Function ble_but_prf_disable
**
** Description This function is called to disable the button profile modlue
**
** Parameters None.
**
** Returns None
**
*******************************************************************************/
void ble_but_prf_disable(void)
{
prf_hdr_evt_t *p_buf;
LOG_ERROR("ble_but_prf_disable\n");
if (bt_prf_sys_is_register(PRF_ID_BUT_LE) == FALSE)
{
APPL_TRACE_WARNING("button profile Module not enabled/already disabled\n");
return;
}
if ((p_buf = (prf_hdr_evt_t *) GKI_getbuf(sizeof(prf_hdr_evt_t))) != NULL)
{
p_buf->event = BLE_BUT_DISABLE_IND_EVT;
bta_sys_sendmsg(p_buf);
}
bta_sys_deregister(PRF_ID_BUT_LE);
}
void ble_but_prf_enable(void)
{
bt_prf_sys_register(PRF_ID_BUT_LE,&but_prf_reg);
}
void ble_but_create_svc(void)
{
prf_hdr_evt_t *p_msg;
LOG_ERROR("ble_but_create_svc\n"); //todo
if ((p_msg = (prf_hdr_evt_t *) GKI_getbuf(sizeof(prf_hdr_evt_t))) != NULL)
{
memset(p_msg, 0, sizeof(prf_hdr_evt_t));
p_msg->event = BLE_BUT_ENABLE_REQ_EVT;
bt_prf_sys_sendmsg(p_msg);
}
}
#endif ///BUT_PROFILE_CFG
#if 0
#define GPIO_INUM 8 #define GPIO_INUM 8
#define TABLE_ELEMENT_CNT(table) ((sizeof(table))/(sizeof(table[0]))); #define TABLE_ELEMENT_CNT(table) ((sizeof(table))/(sizeof(table[0])));
app_key_env key_press; app_key_env key_press;

59
examples/06_bluedroid_demos/components/bluedroid_demos/app_project/SampleServerProject.c
View file

@ -30,9 +30,11 @@
#include "wx_airsync_prf.h" #include "wx_airsync_prf.h"
#include "button_pro.h" #include "button_pro.h"
#include "app_button.h"
#include "hid_le_prf.h" #include "hid_le_prf.h"
#include "bt_app_api.h"
// //
#include "hcimsgs.h" #include "hcimsgs.h"
@ -78,9 +80,30 @@ UINT8 wechat_manu[] = {0x00,0x00,0x18,0xfe,0x34,0x6a,0x86,0x2e};
tBTA_BLE_MANU p_ijiazu_manu = {sizeof(ijiazu_manu),ijiazu_manu}; /* manufacturer data */ tBTA_BLE_MANU p_ijiazu_manu = {sizeof(ijiazu_manu),ijiazu_manu}; /* manufacturer data */
tBTA_BLE_MANU p_wechat_manu = {sizeof(wechat_manu),wechat_manu}; tBTA_BLE_MANU p_wechat_manu = {sizeof(wechat_manu),wechat_manu};
tBLE_BD_ADDR p_peer_bda = {
.type = API_PUBLIC_ADDR,
.bda = {0}
};
esp_ble_adv_params_all_t adv_params =
{
.adv_int_min = BTM_BLE_ADV_INT_MIN + 0x100,
.adv_int_max = BTM_BLE_ADV_INT_MIN + 0x100,
.adv_type = API_NON_DISCOVERABLE,
.addr_type_own = API_PUBLIC_ADDR,
.channel_map = ESP_BLE_ADV_CHNL_MAP,
.adv_filter_policy = ADV_ALLOW_SCAN_ANY_CON_ANY,
.p_dir_bda = &p_peer_bda
};
BD_ADDR rand_ijiazu_addr = {0x00,0x02,0x5B,0x00,0x32,0x55}; BD_ADDR rand_ijiazu_addr = {0x00,0x02,0x5B,0x00,0x32,0x55};
tESP_BLE_ADV_DATA ijiazu_adv_data[ADV_SCAN_IDX_MAX] = esp_ble_adv_data_cfg_t ijiazu_adv_data[ADV_SCAN_IDX_MAX] =
{ {
[BLE_ADV_DATA_IDX] = { [BLE_ADV_DATA_IDX] = {
.adv_name = "Espressif_007", .adv_name = "Espressif_007",
@ -121,7 +144,7 @@ tESP_BLE_ADV_DATA ijiazu_adv_data[ADV_SCAN_IDX_MAX] =
} }
}; };
tESP_BLE_ADV_DATA wechat_adv_data[ADV_SCAN_IDX_MAX] = esp_ble_adv_data_cfg_t wechat_adv_data[ADV_SCAN_IDX_MAX] =
{ {
[BLE_ADV_DATA_IDX] = { [BLE_ADV_DATA_IDX] = {
.adv_name = NULL, .adv_name = NULL,
@ -163,7 +186,7 @@ tESP_BLE_ADV_DATA wechat_adv_data[ADV_SCAN_IDX_MAX] =
}; };
#if (BUT_PROFILE_CFG) #if (BUT_PROFILE_CFG)
static void SimpleDataCallBack(UINT8 app_id, UINT8 event, UINT8 len, UINT8 *p_data); static void SimpleDataCallBack(uint8_t app_id, uint8_t event, uint16_t len, uint8_t *p_data);
#endif #endif
int uuidType(unsigned char* p_uuid) int uuidType(unsigned char* p_uuid)
@ -222,6 +245,8 @@ void btif_to_bta_uuid(tBT_UUID *p_dest, bt_uuid_t *p_src)
break; break;
} }
} }
/*set advertising config callback*/ /*set advertising config callback*/
static void bta_gatts_set_adv_data_cback(tBTA_STATUS call_status) static void bta_gatts_set_adv_data_cback(tBTA_STATUS call_status)
{ {
@ -233,13 +258,14 @@ static void bta_gatts_set_adv_data_cback(tBTA_STATUS call_status)
DIS_ATTR_IEEE_DATA_BIT | DIS_ATTR_PNP_ID_BIT; DIS_ATTR_IEEE_DATA_BIT | DIS_ATTR_PNP_ID_BIT;
DIS_SrInit(dis_attr_mask); DIS_SrInit(dis_attr_mask);
*/ */
//ble_but_create_svc();
/*instantiate a battery service*/ /*instantiate a battery service*/
//bas_register(); bas_register();
/*instantiate the driver for button profile*/ /*instantiate the driver for button profile*/
//app_button_init(); //app_button_init();
#if (BUT_PROFILE_CFG) #if (BUT_PROFILE_CFG)
/*instantiate a button service*/ /*instantiate a button service*/
button_init(SimpleDataCallBack); //button_init(SimpleDataCallBack);
#endif ///BUT_PROFILE_CFG #endif ///BUT_PROFILE_CFG
#if (HIDD_LE_PROFILE_CFG) #if (HIDD_LE_PROFILE_CFG)
@ -250,6 +276,8 @@ static void bta_gatts_set_adv_data_cback(tBTA_STATUS call_status)
#if (WX_AIRSYNC_CFG) #if (WX_AIRSYNC_CFG)
AirSync_Init(NULL); AirSync_Init(NULL);
#endif ///WX_AIRSYNC_CFG #endif ///WX_AIRSYNC_CFG
esp_ble_start_advertising(&adv_params);
//API_Ble_AppStartAdvertising(&adv_params);
/*start advetising*/ /*start advetising*/
// BTA_GATTS_Listen(server_if, true, NULL); // BTA_GATTS_Listen(server_if, true, NULL);
} }
@ -268,16 +296,16 @@ void bta_gatts_callback(tBTA_GATTS_EVT event, tBTA_GATTS* p_data)
LOG_ERROR("set advertising parameters\n"); LOG_ERROR("set advertising parameters\n");
//set the advertising data to the btm layer //set the advertising data to the btm layer
ESP_AppBleConfigadvData(&wechat_adv_data[BLE_ADV_DATA_IDX], esp_ble_config_adv_data(&wechat_adv_data[BLE_ADV_DATA_IDX],
bta_gatts_set_adv_data_cback); bta_gatts_set_adv_data_cback);
//set the adversting data to the btm layer
ESP_AppBleSetScanRsp(&wechat_adv_data[BLE_SCAN_RSP_DATA_IDX],NULL);
} }
break; break;
/*connect callback*/ /*connect callback*/
case BTA_GATTS_CONNECT_EVT: case BTA_GATTS_CONNECT_EVT:
{ {
///Stop the advertising when the connection is establish
esp_ble_stop_advertising();
LOG_ERROR("\ndevice is connected "BT_BD_ADDR_STR", server_if=%d,reason=0x%x,connect_id=%d\n", LOG_ERROR("\ndevice is connected "BT_BD_ADDR_STR", server_if=%d,reason=0x%x,connect_id=%d\n",
BT_BD_ADDR_HEX(p_data->conn.remote_bda), p_data->conn.server_if, BT_BD_ADDR_HEX(p_data->conn.remote_bda), p_data->conn.server_if,
p_data->conn.reason, p_data->conn.conn_id); p_data->conn.reason, p_data->conn.conn_id);
@ -286,7 +314,11 @@ void bta_gatts_callback(tBTA_GATTS_EVT event, tBTA_GATTS* p_data)
LOG_ERROR("is_connected=%d\n",is_connected); LOG_ERROR("is_connected=%d\n",is_connected);
} }
break; break;
case BTA_GATTS_DISCONNECT_EVT:
///start the advertising again when lose the connection
esp_ble_start_advertising(&adv_params);
break;
default: default:
LOG_ERROR("unsettled event: %d\n", event); LOG_ERROR("unsettled event: %d\n", event);
} }
@ -294,7 +326,7 @@ void bta_gatts_callback(tBTA_GATTS_EVT event, tBTA_GATTS* p_data)
} }
#if (BUT_PROFILE_CFG) #if (BUT_PROFILE_CFG)
static void SimpleDataCallBack(UINT8 app_id, UINT8 event, UINT8 len, UINT8 *p_data) static void SimpleDataCallBack(uint8_t app_id, uint8_t event, uint16_t len, uint8_t *p_data)
{ {
LOG_ERROR("the event value is:%x\n",event); LOG_ERROR("the event value is:%x\n",event);
switch(event) switch(event)
@ -321,7 +353,10 @@ static void ble_server_appRegister(void)
btif_to_bta_uuid(&t_uuid, &uuid); btif_to_bta_uuid(&t_uuid, &uuid);
LOG_ERROR("register gatts application\n"); LOG_ERROR("register gatts application\n");
BTA_GATTS_AppRegister(&t_uuid, bta_gatts_callback); esp_ble_gatts_app_register(&t_uuid, bta_gatts_callback);
bt_prf_sys_init();
ble_but_prf_enable();
} }
void gatts_server_test(void) void gatts_server_test(void)

3
examples/06_bluedroid_demos/components/bluedroid_demos/include/app_button.h
View file

@ -57,6 +57,9 @@ extern app_key_env key_press;
uint8_t check_sum(uint8_t *check_array,uint8_t len); uint8_t check_sum(uint8_t *check_array,uint8_t len);
void ble_but_prf_enable(void);
void ble_but_create_svc(void);

131
examples/06_bluedroid_demos/components/bluedroid_demos/include/app_button_int.h Normal file
View file

@ -0,0 +1,131 @@
/**
*******************************************************************************
*********
*
* @file app_button_int.h
*
* @brief button Service Application entry point
*
* Copyright (C) ESPRESSSIF 2016
* Created by Yulong at 2016/10/17
*
*******************************************************************************
**********/
#include "prf_defs.h"
#include "bt_prf_sys.h"
#include "bt_types.h"
#if (BUT_PROFILE_CFG)
/// Messages for Device Information Service Server
enum
{
///Add a BUTTON instance into the database
BLE_BUT_CREATE_DB_REQ_EVT = BT_PRF_SYS_EVT_START(PRF_ID_BUT_LE),
///Send key value confirm to APP so stable values can be erased
///if correctly sent.
BLE_BUT_VAL_SEND_CFM_EVT,
///Set the value of an attribute
BLE_BUT_SET_CHAR_VAL_REQ_EVT,
///Start the button notify Service Task - at connection
BLE_BUT_ENABLE_REQ_EVT,
/// Inform the application that the profile service role task has been disabled after a disconnection
BLE_BUT_DISABLE_IND_EVT,
/// Inform the application that the profile service has been reiceivd the charateristic write commamd from Client
BLE_BUT_CHAR_WRITE_IND_EVT,
///Error indication to Host
BLE_BUT_ERROR_IND_EVT,
};
/// Parameters of the @ref KEY_CREATE_DB_REQ message
typedef struct
{
///Database configuration
uint16_t features;
}tBUT_CRT_DB_REQ;
/// Parameters of the @ref KEY_CREATE_DB_CFM message
typedef struct
{
///Status
uint8_t status;
}tBUT_CRT_DB_CFM;
///Parameters of the @ref key_CFG_INDNTF_IND message
typedef struct
{
///Connection handle
uint16_t conhdl;
///Stop/notify/indicate value to configure into the peer characteristic
uint16_t cfg_val;
/// characteristics
uint8_t char_code;
}tBUT_CFG_NTF_IND;
/// Parameters of the @ref KEY_SET_CHAR_VAL_REQ message - shall be dynamically allocated
typedef struct
{
/// Characteristic Code
//uint8_t char_code;
uint8_t conhdl;
uint8_t key_val_len;
uint8_t key_val[2];
}tBUT_SND_CHAR_VAL_REQ;
/// Parameters of the @ref KEY_ENABLE_REQ message
typedef struct
{
///Connection handle
uint16_t conhdl;
/// security level: b0= nothing, b1=unauthenticated, b2=authenticated, b3=authorized; b1 or b2 and b3 can go together
uint8_t sec_lvl;
///Type of connection
uint8_t con_type;
}tBUT_ENABLE_REQ;
///Parameters of the @ref KEY_VAL_SEND_CFM message
typedef struct
{
///Connection handle
uint16_t conhdl;
///Status
uint8_t status;
}tBUT_VAL_SND_CFM;
/// Parameters of the @ref KEY_DISABLE_IND message
typedef struct
{
///Connection handle
uint16_t conhdl;
}tBUT_DISABLE_IND;
typedef union
{
uint16_t conhdl;
tBUT_CRT_DB_REQ but_crt_db_req;
tBUT_CRT_DB_CFM but_crt_db_cfm;
tBUT_CFG_NTF_IND but_cfg_ntf_ind;
tBUT_SND_CHAR_VAL_REQ but_snd_char_val_req;
tBUT_ENABLE_REQ but_enable_req;
tBUT_VAL_SND_CFM but_val_snd_cfm;
tBUT_DISABLE_IND but_disable_ind;
}tBUT_PRF_MSG;
BOOLEAN ble_but_prf_hdl_event(prf_hdr_evt_t *msg_data);
void ble_but_prf_disable(void);
#endif ///BUT_PROFILE_CFG

2
examples/06_bluedroid_demos/components/bluedroid_demos/include/app_wechat_util.h
View file

@ -2,7 +2,7 @@
#define __APP_WECHAT_UTIL_H__ #define __APP_WECHAT_UTIL_H__
#include "prf_defs.h" #include "prf_defs.h"
if (WX_AIRSYNC_CFG) #if (WX_AIRSYNC_CFG)
#include <stdint.h> #include <stdint.h>
#include <string.h> #include <string.h>

18
examples/06_bluedroid_demos/components/bluedroid_demos/include/bt_app_api.h
View file

@ -1,18 +0,0 @@
/**
****************************************************************************************
*
* @file bt_app_api.h
*
* @brief Application entry point
*
* Copyright (C) Espressif 2016
* Created by Yulong at 2016/10/13
*
*
****************************************************************************************
*/

23
examples/06_bluedroid_demos/components/bluedroid_demos/include/bt_app_defs.h
View file

@ -1,23 +0,0 @@
#include "bta_api.h"
#include "btm_ble_api.h"
enum
{
BLE_ADV_DATA_IDX,
BLE_SCAN_RSP_DATA_IDX,
ADV_SCAN_IDX_MAX
};
typedef struct
{
char *adv_name; //set the device name to be sent on the advertising
tBTA_BLE_ADV_DATA ble_adv_data;
}tESP_BLE_ADV_DATA;
extern void ESP_AppBleConfigadvData(tESP_BLE_ADV_DATA *adv_data,
tBTA_SET_ADV_DATA_CMPL_CBACK *p_adv_data_cback);
extern void ESP_AppBleSetScanRsp(tESP_BLE_ADV_DATA *scan_rsp_data,
tBTA_SET_ADV_DATA_CMPL_CBACK *p_scan_rsp_data_cback);

2
examples/06_bluedroid_demos/main/demo_main.c
View file

@ -15,7 +15,7 @@ void pingTask(void *pvParameters)
{ {
while (1) { while (1) {
vTaskDelay(1000 / portTICK_PERIOD_MS); vTaskDelay(1000 / portTICK_PERIOD_MS);
printf("ping\n"); //printf("ping\n");
} }
} }