2016-11-15 12:56:15 +00:00
// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
# include <string.h>
2017-08-17 13:13:45 +00:00
# include "allocator.h"
2016-11-18 10:00:47 +00:00
# include "bt_types.h"
2017-04-13 14:14:28 +00:00
# include "bt_defs.h"
2016-11-15 12:56:15 +00:00
# include "bta_api.h"
2017-04-13 14:14:28 +00:00
# include "bta_dm_co.h"
2016-11-15 12:56:15 +00:00
# include "btc_task.h"
# include "btc_manage.h"
# include "btc_gap_ble.h"
2016-11-21 14:38:00 +00:00
# include "btc_gatt_util.h"
2016-11-15 12:56:15 +00:00
# include "esp_bt_defs.h"
# include "esp_gap_ble_api.h"
2017-08-09 08:46:49 +00:00
# include "btc_ble_storage.h"
2016-11-15 12:56:15 +00:00
static tBTA_BLE_ADV_DATA gl_bta_adv_data ;
static tBTA_BLE_ADV_DATA gl_bta_scan_rsp_data ;
2017-01-11 06:08:16 +00:00
static inline void btc_gap_ble_cb_to_app ( esp_gap_ble_cb_event_t event , esp_ble_gap_cb_param_t * param )
{
esp_gap_ble_cb_t btc_gap_ble_cb = ( esp_gap_ble_cb_t ) btc_profile_cb_get ( BTC_PID_GAP_BLE ) ;
if ( btc_gap_ble_cb ) {
2017-01-19 03:49:59 +00:00
btc_gap_ble_cb ( event , param ) ;
2017-01-11 06:08:16 +00:00
}
}
2016-11-15 12:56:15 +00:00
2016-11-24 18:10:15 +00:00
static void btc_gap_adv_point_cleanup ( void * * buf )
2016-11-15 12:56:15 +00:00
{
2016-11-24 18:10:15 +00:00
if ( NULL = = * buf ) {
return ;
}
2017-08-17 13:13:45 +00:00
osi_free ( * buf ) ;
2016-11-24 18:10:15 +00:00
* buf = NULL ;
2016-11-15 12:56:15 +00:00
}
static void btc_cleanup_adv_data ( tBTA_BLE_ADV_DATA * bta_adv_data )
{
2016-11-24 18:10:15 +00:00
if ( bta_adv_data = = NULL ) {
return ;
}
2016-11-15 12:56:15 +00:00
// Manufacturer data cleanup
2016-11-24 18:10:15 +00:00
if ( bta_adv_data - > p_manu ! = NULL ) {
btc_gap_adv_point_cleanup ( ( void * * ) & bta_adv_data - > p_manu - > p_val ) ;
btc_gap_adv_point_cleanup ( ( void * * ) & bta_adv_data - > p_manu ) ;
2016-11-15 12:56:15 +00:00
}
// Proprietary data cleanup
2016-11-24 18:10:15 +00:00
if ( bta_adv_data - > p_proprietary ! = NULL ) {
2016-11-15 12:56:15 +00:00
int i = 0 ;
tBTA_BLE_PROP_ELEM * p_elem = bta_adv_data - > p_proprietary - > p_elem ;
while ( i + + ! = bta_adv_data - > p_proprietary - > num_elem
2016-11-24 18:10:15 +00:00
& & p_elem ) {
btc_gap_adv_point_cleanup ( ( void * * ) & p_elem - > p_val ) ;
2016-11-15 12:56:15 +00:00
+ + p_elem ;
}
2016-11-24 18:10:15 +00:00
btc_gap_adv_point_cleanup ( ( void * * ) & bta_adv_data - > p_proprietary - > p_elem ) ;
btc_gap_adv_point_cleanup ( ( void * * ) & bta_adv_data - > p_proprietary ) ;
2016-11-15 12:56:15 +00:00
}
// Service list cleanup
2016-11-24 18:10:15 +00:00
if ( bta_adv_data - > p_services ! = NULL ) {
btc_gap_adv_point_cleanup ( ( void * * ) & bta_adv_data - > p_services - > p_uuid ) ;
btc_gap_adv_point_cleanup ( ( void * * ) & bta_adv_data - > p_services ) ;
2016-11-15 12:56:15 +00:00
}
// Service data cleanup
2016-11-24 18:10:15 +00:00
if ( bta_adv_data - > p_service_data ! = NULL ) {
btc_gap_adv_point_cleanup ( ( void * * ) & bta_adv_data - > p_service_data - > p_val ) ;
btc_gap_adv_point_cleanup ( ( void * * ) & bta_adv_data - > p_service_data ) ;
2016-11-15 12:56:15 +00:00
}
2016-11-24 18:10:15 +00:00
btc_gap_adv_point_cleanup ( ( void * * ) & bta_adv_data - > p_services_128b ) ;
2016-11-15 12:56:15 +00:00
2016-11-24 18:10:15 +00:00
if ( bta_adv_data - > p_service_32b ! = NULL ) {
btc_gap_adv_point_cleanup ( ( void * * ) & bta_adv_data - > p_service_32b - > p_uuid ) ;
btc_gap_adv_point_cleanup ( ( void * * ) & bta_adv_data - > p_service_32b ) ;
2016-11-15 12:56:15 +00:00
}
2016-11-24 18:10:15 +00:00
if ( bta_adv_data - > p_sol_services ! = NULL ) {
btc_gap_adv_point_cleanup ( ( void * * ) & bta_adv_data - > p_sol_services - > p_uuid ) ;
btc_gap_adv_point_cleanup ( ( void * * ) & bta_adv_data - > p_sol_services ) ;
2016-11-15 12:56:15 +00:00
}
2016-11-24 18:10:15 +00:00
if ( bta_adv_data - > p_sol_service_32b ! = NULL ) {
btc_gap_adv_point_cleanup ( ( void * * ) & bta_adv_data - > p_sol_service_32b - > p_uuid ) ;
btc_gap_adv_point_cleanup ( ( void * * ) & bta_adv_data - > p_sol_service_32b ) ;
2016-11-15 12:56:15 +00:00
}
2016-11-24 18:10:15 +00:00
btc_gap_adv_point_cleanup ( ( void * * ) & bta_adv_data - > p_sol_service_128b ) ;
2016-11-15 12:56:15 +00:00
}
2017-06-02 05:09:23 +00:00
static esp_bt_status_t btc_hci_to_esp_status ( uint8_t hci_status )
{
esp_bt_status_t esp_status = ESP_BT_STATUS_FAIL ;
switch ( hci_status ) {
case HCI_SUCCESS :
esp_status = ESP_BT_STATUS_SUCCESS ;
break ;
case HCI_ERR_HOST_TIMEOUT :
esp_status = ESP_BT_STATUS_TIMEOUT ;
break ;
case HCI_ERR_ILLEGAL_COMMAND :
esp_status = ESP_BT_STATUS_PENDING ;
break ;
case HCI_ERR_UNACCEPT_CONN_INTERVAL :
esp_status = ESP_BT_STATUS_UNACCEPT_CONN_INTERVAL ;
break ;
case HCI_ERR_PARAM_OUT_OF_RANGE :
esp_status = ESP_BT_STATUS_PARAM_OUT_OF_RANGE ;
break ;
2017-08-24 12:46:03 +00:00
case HCI_ERR_ILLEGAL_PARAMETER_FMT :
esp_status = ESP_BT_STATUS_ERR_ILLEGAL_PARAMETER_FMT ;
break ;
2017-06-02 05:09:23 +00:00
default :
esp_status = ESP_BT_STATUS_FAIL ;
break ;
}
return esp_status ;
}
2017-06-14 13:19:48 +00:00
static esp_bt_status_t btc_btm_status_to_esp_status ( uint8_t btm_status )
{
esp_bt_status_t esp_status = ESP_BT_STATUS_FAIL ;
switch ( btm_status ) {
case BTM_SUCCESS :
esp_status = ESP_BT_STATUS_SUCCESS ;
break ;
case BTM_PEER_LE_DATA_LEN_UNSUPPORTED :
esp_status = ESP_BT_STATUS_PEER_LE_DATA_LEN_UNSUPPORTED ;
break ;
case BTM_CONTROL_LE_DATA_LEN_UNSUPPORTED :
esp_status = ESP_BT_STATUS_CONTROL_LE_DATA_LEN_UNSUPPORTED ;
break ;
2017-07-19 06:50:40 +00:00
case BTM_SET_PRIVACY_SUCCESS :
esp_status = ESP_BT_STATUS_SUCCESS ;
break ;
case BTM_SET_PRIVACY_FAIL :
esp_status = ESP_BT_STATUS_FAIL ;
break ;
2017-06-14 13:19:48 +00:00
default :
esp_status = ESP_BT_STATUS_FAIL ;
break ;
}
return esp_status ;
}
2016-11-15 12:56:15 +00:00
static void btc_to_bta_adv_data ( esp_ble_adv_data_t * p_adv_data , tBTA_BLE_ADV_DATA * bta_adv_data , uint32_t * data_mask )
{
2016-11-24 18:10:15 +00:00
uint32_t mask ;
2016-11-15 12:56:15 +00:00
2016-11-24 18:10:15 +00:00
btc_cleanup_adv_data ( bta_adv_data ) ;
2016-11-15 12:56:15 +00:00
memset ( bta_adv_data , 0 , sizeof ( tBTA_BLE_ADV_DATA ) ) ;
mask = 0 ;
2016-11-24 18:10:15 +00:00
if ( p_adv_data - > flag ! = 0 ) {
mask = BTM_BLE_AD_BIT_FLAGS ;
2016-12-23 07:57:44 +00:00
bta_adv_data - > flag = p_adv_data - > flag ;
2016-11-16 11:50:44 +00:00
}
2016-11-15 12:56:15 +00:00
2016-11-17 16:30:35 +00:00
if ( p_adv_data - > include_name ) {
2016-11-15 12:56:15 +00:00
mask | = BTM_BLE_AD_BIT_DEV_NAME ;
2016-11-24 18:10:15 +00:00
}
2016-11-15 12:56:15 +00:00
2016-11-18 14:10:35 +00:00
if ( p_adv_data - > include_txpower ) {
2016-11-15 12:56:15 +00:00
mask | = BTM_BLE_AD_BIT_TX_PWR ;
2016-11-24 18:10:15 +00:00
}
2016-11-15 12:56:15 +00:00
if ( p_adv_data - > min_interval > 0 & & p_adv_data - > max_interval > 0 & &
2016-11-24 18:10:15 +00:00
p_adv_data - > max_interval > = p_adv_data - > min_interval ) {
2016-11-15 12:56:15 +00:00
mask | = BTM_BLE_AD_BIT_INT_RANGE ;
bta_adv_data - > int_range . low = p_adv_data - > min_interval ;
bta_adv_data - > int_range . hi = p_adv_data - > max_interval ;
}
2016-11-24 18:10:15 +00:00
if ( p_adv_data - > include_txpower ) {
//TODO
2016-11-15 12:56:15 +00:00
}
2016-11-24 18:10:15 +00:00
if ( p_adv_data - > appearance ! = 0 ) {
2016-11-15 12:56:15 +00:00
mask | = BTM_BLE_AD_BIT_APPEARANCE ;
bta_adv_data - > appearance = p_adv_data - > appearance ;
}
2016-11-24 18:10:15 +00:00
if ( p_adv_data - > manufacturer_len > 0 & & p_adv_data - > p_manufacturer_data ! = NULL ) {
2017-08-17 13:13:45 +00:00
bta_adv_data - > p_manu = osi_malloc ( sizeof ( tBTA_BLE_MANU ) ) ;
2016-11-24 18:10:15 +00:00
if ( bta_adv_data - > p_manu ! = NULL ) {
2017-08-17 13:13:45 +00:00
bta_adv_data - > p_manu - > p_val = osi_malloc ( p_adv_data - > manufacturer_len ) ;
2016-11-24 18:10:15 +00:00
if ( bta_adv_data - > p_manu - > p_val ! = NULL ) {
mask | = BTM_BLE_AD_BIT_MANU ;
bta_adv_data - > p_manu - > len = p_adv_data - > manufacturer_len ;
memcpy ( bta_adv_data - > p_manu - > p_val , p_adv_data - > p_manufacturer_data , p_adv_data - > manufacturer_len ) ;
2016-11-15 12:56:15 +00:00
}
2016-11-24 18:10:15 +00:00
}
2016-11-15 12:56:15 +00:00
}
tBTA_BLE_PROP_ELEM * p_elem_service_data = NULL ;
2016-11-24 18:10:15 +00:00
if ( p_adv_data - > service_data_len > 0 & & p_adv_data - > p_service_data ! = NULL ) {
2017-08-17 13:13:45 +00:00
p_elem_service_data = osi_malloc ( sizeof ( tBTA_BLE_PROP_ELEM ) ) ;
2016-11-24 18:10:15 +00:00
if ( p_elem_service_data ! = NULL ) {
2017-08-17 13:13:45 +00:00
p_elem_service_data - > p_val = osi_malloc ( p_adv_data - > service_data_len ) ;
2016-11-24 18:10:15 +00:00
if ( p_elem_service_data - > p_val ! = NULL ) {
p_elem_service_data - > adv_type = BTM_BLE_AD_TYPE_SERVICE_DATA ;
p_elem_service_data - > len = p_adv_data - > service_data_len ;
memcpy ( p_elem_service_data - > p_val , p_adv_data - > p_service_data ,
p_adv_data - > service_data_len ) ;
} else {
2017-08-17 13:13:45 +00:00
osi_free ( p_elem_service_data ) ;
2016-11-24 18:10:15 +00:00
p_elem_service_data = NULL ;
}
}
}
if ( NULL ! = p_elem_service_data ) {
2017-08-17 13:13:45 +00:00
bta_adv_data - > p_proprietary = osi_malloc ( sizeof ( tBTA_BLE_PROPRIETARY ) ) ;
2016-11-24 18:10:15 +00:00
if ( NULL ! = bta_adv_data - > p_proprietary ) {
2016-11-15 12:56:15 +00:00
tBTA_BLE_PROP_ELEM * p_elem = NULL ;
tBTA_BLE_PROPRIETARY * p_prop = bta_adv_data - > p_proprietary ;
p_prop - > num_elem = 0 ;
mask | = BTM_BLE_AD_BIT_PROPRIETARY ;
p_prop - > num_elem = 1 ;
2017-08-17 13:13:45 +00:00
p_prop - > p_elem = osi_malloc ( sizeof ( tBTA_BLE_PROP_ELEM ) * p_prop - > num_elem ) ;
2016-11-15 12:56:15 +00:00
p_elem = p_prop - > p_elem ;
2016-11-24 18:10:15 +00:00
if ( NULL ! = p_elem ) {
2016-11-15 12:56:15 +00:00
memcpy ( p_elem + + , p_elem_service_data , sizeof ( tBTA_BLE_PROP_ELEM ) ) ;
2016-11-24 18:10:15 +00:00
}
2017-08-17 13:13:45 +00:00
osi_free ( p_elem_service_data ) ;
2016-11-15 12:56:15 +00:00
}
}
2016-11-24 18:10:15 +00:00
if ( p_adv_data - > service_uuid_len & & p_adv_data - > p_service_uuid ) {
2016-11-15 12:56:15 +00:00
UINT16 * p_uuid_out16 = NULL ;
UINT32 * p_uuid_out32 = NULL ;
2016-11-24 18:10:15 +00:00
for ( int position = 0 ; position < p_adv_data - > service_uuid_len ; position + = LEN_UUID_128 ) {
tBT_UUID bt_uuid ;
btc128_to_bta_uuid ( & bt_uuid , p_adv_data - > p_service_uuid + position ) ;
switch ( bt_uuid . len ) {
case ( LEN_UUID_16 ) : {
if ( NULL = = bta_adv_data - > p_services ) {
2017-08-17 13:13:45 +00:00
bta_adv_data - > p_services = osi_malloc ( sizeof ( tBTA_BLE_SERVICE ) ) ;
2016-11-24 18:10:15 +00:00
bta_adv_data - > p_services - > list_cmpl = FALSE ;
bta_adv_data - > p_services - > num_service = 0 ;
2017-08-17 13:13:45 +00:00
bta_adv_data - > p_services - > p_uuid = osi_malloc ( p_adv_data - > service_uuid_len / LEN_UUID_128 * LEN_UUID_16 ) ;
2016-11-24 18:10:15 +00:00
p_uuid_out16 = bta_adv_data - > p_services - > p_uuid ;
2016-11-15 12:56:15 +00:00
}
2016-11-24 18:10:15 +00:00
if ( NULL ! = bta_adv_data - > p_services - > p_uuid ) {
2016-12-28 04:02:43 +00:00
LOG_DEBUG ( " %s - In 16-UUID_data " , __FUNCTION__ ) ;
2016-11-24 18:10:15 +00:00
mask | = BTM_BLE_AD_BIT_SERVICE ;
+ + bta_adv_data - > p_services - > num_service ;
* p_uuid_out16 + + = bt_uuid . uu . uuid16 ;
2016-11-15 12:56:15 +00:00
}
2016-11-24 18:10:15 +00:00
break ;
}
2016-11-15 12:56:15 +00:00
2016-11-24 18:10:15 +00:00
case ( LEN_UUID_32 ) : {
if ( NULL = = bta_adv_data - > p_service_32b ) {
bta_adv_data - > p_service_32b =
2017-08-17 13:13:45 +00:00
osi_malloc ( sizeof ( tBTA_BLE_32SERVICE ) ) ;
2016-11-24 18:10:15 +00:00
bta_adv_data - > p_service_32b - > list_cmpl = FALSE ;
bta_adv_data - > p_service_32b - > num_service = 0 ;
bta_adv_data - > p_service_32b - > p_uuid =
2017-08-17 13:13:45 +00:00
osi_malloc ( p_adv_data - > service_uuid_len / LEN_UUID_128 * LEN_UUID_32 ) ;
2016-11-24 18:10:15 +00:00
p_uuid_out32 = bta_adv_data - > p_service_32b - > p_uuid ;
2016-11-15 12:56:15 +00:00
}
2016-11-24 18:10:15 +00:00
if ( NULL ! = bta_adv_data - > p_service_32b - > p_uuid ) {
2016-12-28 04:02:43 +00:00
LOG_DEBUG ( " %s - In 32-UUID_data " , __FUNCTION__ ) ;
2016-11-24 18:10:15 +00:00
mask | = BTM_BLE_AD_BIT_SERVICE_32 ;
+ + bta_adv_data - > p_service_32b - > num_service ;
* p_uuid_out32 + + = bt_uuid . uu . uuid32 ;
}
break ;
}
case ( LEN_UUID_128 ) : {
/* Currently, only one 128-bit UUID is supported */
if ( NULL = = bta_adv_data - > p_services_128b ) {
bta_adv_data - > p_services_128b =
2017-08-17 13:13:45 +00:00
osi_malloc ( sizeof ( tBTA_BLE_128SERVICE ) ) ;
2016-11-24 18:10:15 +00:00
if ( NULL ! = bta_adv_data - > p_services_128b ) {
2017-06-19 22:34:36 +00:00
LOG_DEBUG ( " %s - In 128-UUID_data " , __FUNCTION__ ) ;
2016-11-24 18:10:15 +00:00
mask | = BTM_BLE_AD_BIT_SERVICE_128 ;
memcpy ( bta_adv_data - > p_services_128b - > uuid128 ,
bt_uuid . uu . uuid128 , LEN_UUID_128 ) ;
LOG_DEBUG ( " %x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x " , bt_uuid . uu . uuid128 [ 0 ] ,
bt_uuid . uu . uuid128 [ 1 ] , bt_uuid . uu . uuid128 [ 2 ] , bt_uuid . uu . uuid128 [ 3 ] ,
bt_uuid . uu . uuid128 [ 4 ] , bt_uuid . uu . uuid128 [ 5 ] , bt_uuid . uu . uuid128 [ 6 ] ,
bt_uuid . uu . uuid128 [ 7 ] , bt_uuid . uu . uuid128 [ 8 ] , bt_uuid . uu . uuid128 [ 9 ] ,
bt_uuid . uu . uuid128 [ 10 ] , bt_uuid . uu . uuid128 [ 11 ] , bt_uuid . uu . uuid128 [ 12 ] ,
bt_uuid . uu . uuid128 [ 13 ] , bt_uuid . uu . uuid128 [ 14 ] , bt_uuid . uu . uuid128 [ 15 ] ) ;
bta_adv_data - > p_services_128b - > list_cmpl = TRUE ;
}
}
break ;
}
default :
break ;
}
2016-11-15 12:56:15 +00:00
}
}
2016-11-24 18:10:15 +00:00
* data_mask = mask ;
2016-11-15 12:56:15 +00:00
}
static void btc_adv_data_callback ( tBTA_STATUS status )
{
2016-11-24 18:10:15 +00:00
esp_ble_gap_cb_param_t param ;
bt_status_t ret ;
btc_msg_t msg ;
2016-11-15 12:56:15 +00:00
2016-11-24 18:10:15 +00:00
msg . sig = BTC_SIG_API_CB ;
msg . pid = BTC_PID_GAP_BLE ;
msg . act = ESP_GAP_BLE_ADV_DATA_SET_COMPLETE_EVT ;
param . adv_data_cmpl . status = status ;
2016-11-15 12:56:15 +00:00
2016-11-24 18:10:15 +00:00
ret = btc_transfer_context ( & msg , & param ,
sizeof ( esp_ble_gap_cb_param_t ) , NULL ) ;
2016-11-15 12:56:15 +00:00
2016-11-24 18:10:15 +00:00
if ( ret ! = BT_STATUS_SUCCESS ) {
LOG_ERROR ( " %s btc_transfer_context failed \n " , __func__ ) ;
}
2016-11-15 12:56:15 +00:00
}
2016-11-16 11:50:44 +00:00
static void btc_scan_rsp_data_callback ( tBTA_STATUS status )
2016-11-15 12:56:15 +00:00
{
2016-11-24 18:10:15 +00:00
esp_ble_gap_cb_param_t param ;
bt_status_t ret ;
btc_msg_t msg ;
2016-11-15 12:56:15 +00:00
2016-11-24 18:10:15 +00:00
msg . sig = BTC_SIG_API_CB ;
msg . pid = BTC_PID_GAP_BLE ;
msg . act = ESP_GAP_BLE_SCAN_RSP_DATA_SET_COMPLETE_EVT ;
2016-12-07 06:11:40 +00:00
param . scan_rsp_data_cmpl . status = status ;
2016-11-15 12:56:15 +00:00
2016-11-24 18:10:15 +00:00
ret = btc_transfer_context ( & msg , & param ,
sizeof ( esp_ble_gap_cb_param_t ) , NULL ) ;
2016-11-15 12:56:15 +00:00
2016-11-24 18:10:15 +00:00
if ( ret ! = BT_STATUS_SUCCESS ) {
LOG_ERROR ( " %s btc_transfer_context failed \n " , __func__ ) ;
}
2016-11-15 12:56:15 +00:00
}
2017-01-19 03:49:59 +00:00
static void btc_adv_data_raw_callback ( tBTA_STATUS status )
{
esp_ble_gap_cb_param_t param ;
bt_status_t ret ;
btc_msg_t msg ;
msg . sig = BTC_SIG_API_CB ;
msg . pid = BTC_PID_GAP_BLE ;
msg . act = ESP_GAP_BLE_ADV_DATA_RAW_SET_COMPLETE_EVT ;
param . adv_data_raw_cmpl . status = status ;
ret = btc_transfer_context ( & msg , & param ,
sizeof ( esp_ble_gap_cb_param_t ) , NULL ) ;
if ( ret ! = BT_STATUS_SUCCESS ) {
LOG_ERROR ( " %s btc_transfer_context failed \n " , __func__ ) ;
}
}
static void btc_scan_rsp_data_raw_callback ( tBTA_STATUS status )
{
esp_ble_gap_cb_param_t param ;
bt_status_t ret ;
btc_msg_t msg ;
msg . sig = BTC_SIG_API_CB ;
msg . pid = BTC_PID_GAP_BLE ;
msg . act = ESP_GAP_BLE_SCAN_RSP_DATA_RAW_SET_COMPLETE_EVT ;
param . scan_rsp_data_raw_cmpl . status = status ;
ret = btc_transfer_context ( & msg , & param ,
sizeof ( esp_ble_gap_cb_param_t ) , NULL ) ;
if ( ret ! = BT_STATUS_SUCCESS ) {
LOG_ERROR ( " %s btc_transfer_context failed \n " , __func__ ) ;
}
}
2016-11-16 11:50:44 +00:00
static void btc_ble_set_adv_data ( esp_ble_adv_data_t * adv_data ,
2016-11-24 18:10:15 +00:00
tBTA_SET_ADV_DATA_CMPL_CBACK p_adv_data_cback )
2016-11-15 12:56:15 +00:00
{
2016-11-24 18:10:15 +00:00
tBTA_BLE_AD_MASK data_mask = 0 ;
2016-11-15 12:56:15 +00:00
2016-11-24 18:10:15 +00:00
if ( ! adv_data - > set_scan_rsp ) {
2016-12-07 06:11:40 +00:00
btc_to_bta_adv_data ( adv_data , & gl_bta_adv_data , & data_mask ) ;
2016-11-24 18:10:15 +00:00
BTA_DmBleSetAdvConfig ( data_mask , & gl_bta_adv_data , p_adv_data_cback ) ;
} else {
2016-12-07 06:11:40 +00:00
btc_to_bta_adv_data ( adv_data , & gl_bta_scan_rsp_data , & data_mask ) ;
BTA_DmBleSetScanRsp ( data_mask , & gl_bta_scan_rsp_data , p_adv_data_cback ) ;
2016-11-24 18:10:15 +00:00
}
2016-11-16 11:50:44 +00:00
}
2017-01-19 03:49:59 +00:00
static void btc_ble_set_adv_data_raw ( uint8_t * raw_adv , uint32_t raw_adv_len ,
tBTA_SET_ADV_DATA_CMPL_CBACK p_adv_data_cback )
{
BTA_DmBleSetAdvConfigRaw ( raw_adv , raw_adv_len , p_adv_data_cback ) ;
}
static void btc_ble_set_scan_rsp_data_raw ( uint8_t * raw_scan_rsp , uint32_t raw_scan_rsp_len ,
tBTA_SET_ADV_DATA_CMPL_CBACK p_scan_rsp_data_cback )
{
BTA_DmBleSetScanRspRaw ( raw_scan_rsp , raw_scan_rsp_len , p_scan_rsp_data_cback ) ;
}
2017-02-23 09:32:46 +00:00
static void btc_start_adv_callback ( tBTA_STATUS status )
{
esp_ble_gap_cb_param_t param ;
bt_status_t ret ;
btc_msg_t msg ;
msg . sig = BTC_SIG_API_CB ;
msg . pid = BTC_PID_GAP_BLE ;
msg . act = ESP_GAP_BLE_ADV_START_COMPLETE_EVT ;
param . adv_start_cmpl . status = status ;
ret = btc_transfer_context ( & msg , & param ,
sizeof ( esp_ble_gap_cb_param_t ) , NULL ) ;
if ( ret ! = BT_STATUS_SUCCESS ) {
LOG_ERROR ( " %s btc_transfer_context failed \n " , __func__ ) ;
}
}
2017-03-29 08:51:21 +00:00
static void btc_stop_adv_callback ( tBTA_STATUS status )
{
esp_ble_gap_cb_param_t param ;
bt_status_t ret ;
btc_msg_t msg ;
msg . sig = BTC_SIG_API_CB ;
msg . pid = BTC_PID_GAP_BLE ;
msg . act = ESP_GAP_BLE_ADV_STOP_COMPLETE_EVT ;
param . adv_stop_cmpl . status = status ;
ret = btc_transfer_context ( & msg , & param ,
sizeof ( esp_ble_gap_cb_param_t ) , NULL ) ;
if ( ret ! = BT_STATUS_SUCCESS ) {
LOG_ERROR ( " %s btc_transfer_context failed \n " , __func__ ) ;
}
}
2017-02-23 09:32:46 +00:00
static void btc_ble_start_advertising ( esp_ble_adv_params_t * ble_adv_params , tBTA_START_ADV_CMPL_CBACK start_adv_cback )
2016-11-15 12:56:15 +00:00
{
2016-11-24 18:10:15 +00:00
tBLE_BD_ADDR peer_addr ;
2016-11-29 06:38:58 +00:00
if ( ! BLE_ISVALID_PARAM ( ble_adv_params - > adv_int_min , BTM_BLE_ADV_INT_MIN , BTM_BLE_ADV_INT_MAX ) | |
! BLE_ISVALID_PARAM ( ble_adv_params - > adv_int_max , BTM_BLE_ADV_INT_MIN , BTM_BLE_ADV_INT_MAX ) ) {
2016-11-24 18:10:15 +00:00
LOG_ERROR ( " Invalid advertisting interval parameters. \n " ) ;
return ;
}
if ( ( ble_adv_params - > adv_type < ADV_TYPE_IND ) & &
( ble_adv_params - > adv_type > ADV_TYPE_DIRECT_IND_LOW ) ) {
LOG_ERROR ( " Invalid advertisting type parameters. \n " ) ;
return ;
}
if ( ( ble_adv_params - > adv_filter_policy < ADV_FILTER_ALLOW_SCAN_ANY_CON_ANY ) & &
( ble_adv_params - > adv_filter_policy > ADV_FILTER_ALLOW_SCAN_WLST_CON_WLST ) ) {
LOG_ERROR ( " Invalid advertisting type parameters. \n " ) ;
return ;
}
LOG_DEBUG ( " API_Ble_AppStartAdvertising \n " ) ;
memcpy ( peer_addr . bda , ble_adv_params - > peer_addr , ESP_BD_ADDR_LEN ) ;
peer_addr . type = ble_adv_params - > peer_addr_type ;
BTA_DmSetBleAdvParamsAll ( ble_adv_params - > adv_int_min ,
ble_adv_params - > adv_int_max ,
ble_adv_params - > adv_type ,
ble_adv_params - > own_addr_type ,
ble_adv_params - > channel_map ,
ble_adv_params - > adv_filter_policy ,
2017-02-23 09:32:46 +00:00
& peer_addr ,
start_adv_cback ) ;
2016-11-15 12:56:15 +00:00
}
static void btc_scan_params_callback ( tGATT_IF gatt_if , tBTM_STATUS status )
{
2016-11-24 18:10:15 +00:00
esp_ble_gap_cb_param_t param ;
bt_status_t ret ;
btc_msg_t msg ;
2016-11-15 12:56:15 +00:00
2016-11-24 18:10:15 +00:00
msg . sig = BTC_SIG_API_CB ;
msg . pid = BTC_PID_GAP_BLE ;
msg . act = ESP_GAP_BLE_SCAN_PARAM_SET_COMPLETE_EVT ;
param . scan_param_cmpl . status = status ;
2016-11-15 12:56:15 +00:00
2016-11-24 18:10:15 +00:00
ret = btc_transfer_context ( & msg , & param ,
sizeof ( esp_ble_gap_cb_param_t ) , NULL ) ;
2016-11-15 12:56:15 +00:00
2016-11-24 18:10:15 +00:00
if ( ret ! = BT_STATUS_SUCCESS ) {
LOG_ERROR ( " %s btc_transfer_context failed \n " , __func__ ) ;
}
2016-11-15 12:56:15 +00:00
}
2016-12-07 06:11:40 +00:00
static void btc_ble_set_scan_params ( esp_ble_scan_params_t * scan_params , tBLE_SCAN_PARAM_SETUP_CBACK scan_param_setup_cback )
2016-11-15 12:56:15 +00:00
{
2016-11-29 06:38:58 +00:00
if ( BLE_ISVALID_PARAM ( scan_params - > scan_interval , BTM_BLE_SCAN_INT_MIN , BTM_BLE_SCAN_INT_MAX ) & &
2017-05-05 08:31:24 +00:00
BLE_ISVALID_PARAM ( scan_params - > scan_window , BTM_BLE_SCAN_WIN_MIN , BTM_BLE_SCAN_WIN_MAX ) & &
BLE_ISVALID_PARAM ( scan_params - > own_addr_type , BLE_ADDR_TYPE_PUBLIC , BLE_ADDR_TYPE_RPA_RANDOM ) & &
BLE_ISVALID_PARAM ( scan_params - > scan_filter_policy , BLE_SCAN_FILTER_ALLOW_ALL , BLE_SCAN_FILTER_ALLOW_WLIST_PRA_DIR ) & &
( scan_params - > scan_type = = BTM_BLE_SCAN_MODE_ACTI | | scan_params - > scan_type = = BTM_BLE_SCAN_MODE_PASS ) ) {
2016-12-07 06:11:40 +00:00
BTA_DmSetBleScanFilterParams ( ESP_DEFAULT_GATT_IF , /*client_if*/
2016-11-24 18:10:15 +00:00
scan_params - > scan_interval ,
scan_params - > scan_window ,
scan_params - > scan_type ,
scan_params - > own_addr_type ,
scan_params - > scan_filter_policy ,
scan_param_setup_cback ) ;
2016-12-07 06:11:40 +00:00
} else {
btc_scan_params_callback ( ESP_DEFAULT_GATT_IF , BTM_ILLEGAL_VALUE ) ;
}
2016-11-15 12:56:15 +00:00
}
static void btc_search_callback ( tBTA_DM_SEARCH_EVT event , tBTA_DM_SEARCH * p_data )
{
2016-11-24 18:10:15 +00:00
esp_ble_gap_cb_param_t param ;
btc_msg_t msg ;
msg . sig = BTC_SIG_API_CB ;
msg . pid = BTC_PID_GAP_BLE ;
msg . act = ESP_GAP_BLE_SCAN_RESULT_EVT ;
param . scan_rst . search_evt = event ;
2016-11-15 12:56:15 +00:00
switch ( event ) {
2016-11-24 18:10:15 +00:00
case BTA_DM_INQ_RES_EVT : {
bdcpy ( param . scan_rst . bda , p_data - > inq_res . bd_addr ) ;
param . scan_rst . dev_type = p_data - > inq_res . device_type ;
param . scan_rst . rssi = p_data - > inq_res . rssi ;
param . scan_rst . ble_addr_type = p_data - > inq_res . ble_addr_type ;
2016-12-01 12:16:09 +00:00
param . scan_rst . ble_evt_type = p_data - > inq_res . ble_evt_type ;
2016-11-24 18:10:15 +00:00
param . scan_rst . flag = p_data - > inq_res . flag ;
2017-04-11 06:20:20 +00:00
param . scan_rst . num_resps = 1 ;
param . scan_rst . adv_data_len = p_data - > inq_res . adv_data_len ;
param . scan_rst . scan_rsp_len = p_data - > inq_res . scan_rsp_len ;
2017-03-02 03:41:03 +00:00
memcpy ( param . scan_rst . ble_adv , p_data - > inq_res . p_eir , sizeof ( param . scan_rst . ble_adv ) ) ;
2016-11-24 18:10:15 +00:00
break ;
}
case BTA_DM_INQ_CMPL_EVT : {
param . scan_rst . num_resps = p_data - > inq_cmpl . num_resps ;
LOG_ERROR ( " %s BLE observe complete. Num Resp %d \n " , __FUNCTION__ , p_data - > inq_cmpl . num_resps ) ;
break ;
}
case BTA_DM_DISC_RES_EVT :
LOG_ERROR ( " BTA_DM_DISC_RES_EVT \n " ) ;
break ;
case BTA_DM_DISC_BLE_RES_EVT :
LOG_ERROR ( " BTA_DM_DISC_BLE_RES_EVT \n " ) ;
break ;
case BTA_DM_DISC_CMPL_EVT :
LOG_ERROR ( " BTA_DM_DISC_CMPL_EVT \n " ) ;
break ;
case BTA_DM_DI_DISC_CMPL_EVT :
LOG_ERROR ( " BTA_DM_DI_DISC_CMPL_EVT \n " ) ;
break ;
case BTA_DM_SEARCH_CANCEL_CMPL_EVT :
LOG_ERROR ( " BTA_DM_SEARCH_CANCEL_CMPL_EVT \n " ) ;
break ;
default :
LOG_ERROR ( " %s : Unknown event 0x%x \n " , __FUNCTION__ , event ) ;
2016-11-15 12:56:15 +00:00
return ;
}
btc_transfer_context ( & msg , & param , sizeof ( esp_ble_gap_cb_param_t ) , NULL ) ;
}
2017-02-23 09:32:46 +00:00
static void btc_start_scan_callback ( tBTA_STATUS status )
{
esp_ble_gap_cb_param_t param ;
bt_status_t ret ;
btc_msg_t msg ;
msg . sig = BTC_SIG_API_CB ;
msg . pid = BTC_PID_GAP_BLE ;
msg . act = ESP_GAP_BLE_SCAN_START_COMPLETE_EVT ;
param . scan_start_cmpl . status = status ;
2017-03-29 08:51:21 +00:00
ret = btc_transfer_context ( & msg , & param ,
sizeof ( esp_ble_gap_cb_param_t ) , NULL ) ;
if ( ret ! = BT_STATUS_SUCCESS ) {
LOG_ERROR ( " %s btc_transfer_context failed \n " , __func__ ) ;
}
}
static void btc_stop_scan_callback ( tBTA_STATUS status )
{
esp_ble_gap_cb_param_t param ;
bt_status_t ret ;
btc_msg_t msg ;
msg . sig = BTC_SIG_API_CB ;
msg . pid = BTC_PID_GAP_BLE ;
msg . act = ESP_GAP_BLE_SCAN_STOP_COMPLETE_EVT ;
param . scan_stop_cmpl . status = status ;
2016-11-15 12:56:15 +00:00
2017-02-23 09:32:46 +00:00
ret = btc_transfer_context ( & msg , & param ,
sizeof ( esp_ble_gap_cb_param_t ) , NULL ) ;
if ( ret ! = BT_STATUS_SUCCESS ) {
LOG_ERROR ( " %s btc_transfer_context failed \n " , __func__ ) ;
}
}
2017-08-24 12:46:03 +00:00
void btc_update_conn_param_callback ( UINT8 status , BD_ADDR bd_addr , tBTM_LE_UPDATE_CONN_PRAMS * update_conn_params )
2017-06-02 05:09:23 +00:00
{
esp_ble_gap_cb_param_t param ;
bt_status_t ret ;
btc_msg_t msg ;
msg . sig = BTC_SIG_API_CB ;
msg . pid = BTC_PID_GAP_BLE ;
msg . act = ESP_GAP_BLE_UPDATE_CONN_PARAMS_EVT ;
param . update_conn_params . status = btc_hci_to_esp_status ( status ) ;
param . update_conn_params . min_int = update_conn_params - > min_conn_int ;
param . update_conn_params . max_int = update_conn_params - > max_conn_int ;
param . update_conn_params . conn_int = update_conn_params - > conn_int ;
param . update_conn_params . latency = update_conn_params - > slave_latency ;
param . update_conn_params . timeout = update_conn_params - > supervision_tout ;
memcpy ( param . update_conn_params . bda , bd_addr , sizeof ( esp_bd_addr_t ) ) ;
ret = btc_transfer_context ( & msg , & param ,
sizeof ( esp_ble_gap_cb_param_t ) , NULL ) ;
if ( ret ! = BT_STATUS_SUCCESS ) {
LOG_ERROR ( " %s btc_transfer_context failed \n " , __func__ ) ;
}
}
2017-06-14 13:19:48 +00:00
static void btc_set_pkt_length_callback ( UINT8 status , tBTM_LE_SET_PKT_DATA_LENGTH_PARAMS * data_len_params )
{
esp_ble_gap_cb_param_t param ;
bt_status_t ret ;
btc_msg_t msg ;
msg . sig = BTC_SIG_API_CB ;
msg . pid = BTC_PID_GAP_BLE ;
msg . act = ESP_GAP_BLE_SET_PKT_LENGTH_COMPLETE_EVT ;
param . pkt_data_lenth_cmpl . status = btc_btm_status_to_esp_status ( status ) ;
param . pkt_data_lenth_cmpl . params . rx_len = data_len_params - > rx_len ;
param . pkt_data_lenth_cmpl . params . tx_len = data_len_params - > tx_len ;
ret = btc_transfer_context ( & msg , & param ,
sizeof ( esp_ble_gap_cb_param_t ) , NULL ) ;
if ( ret ! = BT_STATUS_SUCCESS ) {
LOG_ERROR ( " %s btc_transfer_context failed \n " , __func__ ) ;
}
}
2017-07-19 06:50:40 +00:00
static void btc_set_local_privacy_callback ( UINT8 status )
{
esp_ble_gap_cb_param_t param ;
bt_status_t ret ;
btc_msg_t msg ;
msg . sig = BTC_SIG_API_CB ;
msg . pid = BTC_PID_GAP_BLE ;
msg . act = ESP_GAP_BLE_SET_LOCAL_PRIVACY_COMPLETE_EVT ;
param . local_privacy_cmpl . status = btc_btm_status_to_esp_status ( status ) ;
ret = btc_transfer_context ( & msg , & param ,
sizeof ( esp_ble_gap_cb_param_t ) , NULL ) ;
if ( ret ! = BT_STATUS_SUCCESS ) {
LOG_ERROR ( " %s btc_transfer_context failed \n " , __func__ ) ;
}
}
2017-06-02 05:09:23 +00:00
2017-04-25 03:46:37 +00:00
# if (SMP_INCLUDED == TRUE)
2017-04-13 14:14:28 +00:00
static void btc_set_encryption_callback ( BD_ADDR bd_addr , tBTA_TRANSPORT transport , tBTA_STATUS enc_status )
{
UNUSED ( bd_addr ) ;
UNUSED ( transport ) ;
LOG_DEBUG ( " enc_status = %x \n " , enc_status ) ;
return ;
}
2017-04-25 03:46:37 +00:00
# endif ///SMP_INCLUDED == TRUE
2017-04-13 14:14:28 +00:00
2017-06-03 05:00:10 +00:00
static void btc_ble_start_scanning ( uint32_t duration ,
2017-02-23 09:32:46 +00:00
tBTA_DM_SEARCH_CBACK * results_cb ,
2017-03-29 08:51:21 +00:00
tBTA_START_STOP_SCAN_CMPL_CBACK * start_scan_cb )
2016-11-15 12:56:15 +00:00
{
2017-04-11 06:20:20 +00:00
if ( ( results_cb ! = NULL ) & & ( start_scan_cb ! = NULL ) ) {
2016-11-24 18:10:15 +00:00
///Start scan the device
2017-02-23 09:32:46 +00:00
BTA_DmBleObserve ( true , duration , results_cb , start_scan_cb ) ;
2016-11-24 18:10:15 +00:00
} else {
LOG_ERROR ( " The scan duration or p_results_cb invalid \n " ) ;
}
2016-11-15 12:56:15 +00:00
}
2017-03-29 08:51:21 +00:00
static void btc_ble_stop_scanning ( tBTA_START_STOP_SCAN_CMPL_CBACK * stop_scan_cb )
2016-11-19 14:56:36 +00:00
{
2016-11-24 18:10:15 +00:00
uint8_t duration = 0 ;
2017-03-29 08:51:21 +00:00
BTA_DmBleObserve ( false , duration , NULL , stop_scan_cb ) ;
2016-11-19 14:56:36 +00:00
}
2016-11-15 12:56:15 +00:00
2017-03-29 08:51:21 +00:00
static void btc_ble_stop_advertising ( tBTA_START_STOP_ADV_CMPL_CBACK * stop_adv_cb )
2016-11-15 12:56:15 +00:00
{
2016-11-24 18:10:15 +00:00
bool stop_adv = false ;
2017-03-29 08:51:21 +00:00
BTA_DmBleBroadcast ( stop_adv , stop_adv_cb ) ;
2016-11-15 12:56:15 +00:00
}
2016-11-24 18:10:15 +00:00
static void btc_ble_update_conn_params ( BD_ADDR bd_addr , uint16_t min_int ,
2017-08-24 12:46:03 +00:00
uint16_t max_int , uint16_t latency , uint16_t timeout )
2016-11-15 12:56:15 +00:00
{
2016-11-24 18:10:15 +00:00
if ( min_int > max_int ) {
min_int = max_int ;
}
2016-11-15 12:56:15 +00:00
2016-11-24 18:10:15 +00:00
if ( min_int < BTM_BLE_CONN_INT_MIN | | max_int > BTM_BLE_CONN_INT_MAX ) {
LOG_ERROR ( " Invalid interval value. \n " ) ;
}
2016-11-15 12:56:15 +00:00
2016-11-24 18:10:15 +00:00
BTA_DmBleUpdateConnectionParams ( bd_addr , min_int , max_int ,
2017-08-24 12:46:03 +00:00
latency , timeout ) ;
2016-11-15 12:56:15 +00:00
}
2017-06-14 13:19:48 +00:00
static void btc_ble_set_pkt_data_len ( BD_ADDR remote_device , uint16_t tx_data_length , tBTA_SET_PKT_DATA_LENGTH_CBACK * p_set_pkt_data_cback )
2016-11-15 12:56:15 +00:00
{
2016-11-24 18:10:15 +00:00
if ( tx_data_length > BTM_BLE_DATA_SIZE_MAX ) {
tx_data_length = BTM_BLE_DATA_SIZE_MAX ;
} else if ( tx_data_length < BTM_BLE_DATA_SIZE_MIN ) {
tx_data_length = BTM_BLE_DATA_SIZE_MIN ;
}
2016-11-15 12:56:15 +00:00
2017-06-14 13:19:48 +00:00
BTA_DmBleSetDataLength ( remote_device , tx_data_length , p_set_pkt_data_cback ) ;
2016-11-15 12:56:15 +00:00
}
static void btc_ble_set_rand_addr ( BD_ADDR rand_addr )
{
2017-05-19 09:23:00 +00:00
esp_ble_gap_cb_param_t param ;
bt_status_t ret ;
btc_msg_t msg ;
param . set_rand_addr_cmpl . status = ESP_BT_STATUS_SUCCESS ;
2016-11-24 18:10:15 +00:00
if ( rand_addr ! = NULL ) {
2017-08-20 09:52:57 +00:00
/*
A static address is a 48 - bit randomly generated address and shall meet the following requirements :
• The two most significant bits of the address shall be equal to 1
• All bits of the random part of the address shall not be equal to 1
• All bits of the random part of the address shall not be equal to 0
*/
BD_ADDR invalid_rand_addr_a , invalid_rand_addr_b ;
memset ( invalid_rand_addr_a , 0xff , sizeof ( BD_ADDR ) ) ;
memset ( invalid_rand_addr_b , 0x00 , sizeof ( BD_ADDR ) ) ;
invalid_rand_addr_b [ BD_ADDR_LEN - 1 ] = invalid_rand_addr_b [ BD_ADDR_LEN - 1 ] | BT_STATIC_RAND_ADDR_MASK ;
if ( ( rand_addr [ BD_ADDR_LEN - 1 ] & BT_STATIC_RAND_ADDR_MASK ) = = BT_STATIC_RAND_ADDR_MASK
& & memcmp ( invalid_rand_addr_a , rand_addr , BD_ADDR_LEN ) ! = 0
& & memcmp ( invalid_rand_addr_b , rand_addr , BD_ADDR_LEN ) ! = 0 ) {
2017-05-19 09:23:00 +00:00
BTA_DmSetRandAddress ( rand_addr ) ;
} else {
param . set_rand_addr_cmpl . status = ESP_BT_STATUS_INVALID_STATIC_RAND_ADDR ;
2017-08-20 09:52:57 +00:00
LOG_ERROR ( " Invalid random address, the high bit should be 0b11, the random part shall not be to 1 or 0 " ) ;
2017-05-19 09:23:00 +00:00
}
2016-11-24 18:10:15 +00:00
} else {
2017-05-19 09:23:00 +00:00
param . set_rand_addr_cmpl . status = ESP_BT_STATUS_INVALID_STATIC_RAND_ADDR ;
2017-08-20 09:52:57 +00:00
LOG_ERROR ( " Invalid random addressm, the address value is NULL " ) ;
2017-05-19 09:23:00 +00:00
}
msg . sig = BTC_SIG_API_CB ;
msg . pid = BTC_PID_GAP_BLE ;
msg . act = ESP_GAP_BLE_SET_STATIC_RAND_ADDR_EVT ;
ret = btc_transfer_context ( & msg , & param ,
sizeof ( esp_ble_gap_cb_param_t ) , NULL ) ;
if ( ret ! = BT_STATUS_SUCCESS ) {
LOG_ERROR ( " %s btc_transfer_context failed \n " , __func__ ) ;
2016-11-24 18:10:15 +00:00
}
2016-11-15 12:56:15 +00:00
}
2017-08-22 03:28:45 +00:00
# if (SMP_INCLUDED)
2017-08-09 08:46:49 +00:00
static void btc_ble_remove_bond_device ( esp_bt_status_t status )
{
int ret ;
esp_ble_gap_cb_param_t param ;
btc_msg_t msg ;
param . remove_bond_dev_cmpl . status = status ;
msg . sig = BTC_SIG_API_CB ;
msg . pid = BTC_PID_GAP_BLE ;
msg . act = ESP_GAP_BLE_REMOVE_BOND_DEV_COMPLETE_EVT ;
ret = btc_transfer_context ( & msg , & param ,
sizeof ( esp_ble_gap_cb_param_t ) , NULL ) ;
if ( ret ! = BT_STATUS_SUCCESS ) {
LOG_ERROR ( " %s btc_transfer_context failed " , __func__ ) ;
}
}
static void btc_ble_clear_bond_device ( void )
{
int ret ;
esp_ble_gap_cb_param_t param ;
btc_msg_t msg ;
ret = btc_storage_clear_bond_devices ( ) ;
param . clear_bond_dev_cmpl . status = ret ;
msg . sig = BTC_SIG_API_CB ;
msg . pid = BTC_PID_GAP_BLE ;
msg . act = ESP_GAP_BLE_CLEAR_BOND_DEV_COMPLETE_EVT ;
ret = btc_transfer_context ( & msg , & param ,
sizeof ( esp_ble_gap_cb_param_t ) , NULL ) ;
if ( ret ! = BT_STATUS_SUCCESS ) {
LOG_ERROR ( " %s btc_transfer_context failed " , __func__ ) ;
}
}
static void btc_ble_get_bond_device_list ( void )
{
int ret ;
esp_ble_gap_cb_param_t param ;
esp_ble_bond_dev_t * bond_dev ;
btc_msg_t msg ;
int num_dev = btc_storage_get_num_ble_bond_devices ( ) ;
2017-08-17 13:13:45 +00:00
bond_dev = ( esp_ble_bond_dev_t * ) osi_malloc ( sizeof ( esp_ble_bond_dev_t ) * num_dev ) ;
2017-08-09 08:46:49 +00:00
param . get_bond_dev_cmpl . status = btc_get_bonded_ble_devices_list ( bond_dev ) ;
param . get_bond_dev_cmpl . dev_num = num_dev ;
param . get_bond_dev_cmpl . bond_dev = bond_dev ;
msg . sig = BTC_SIG_API_CB ;
msg . pid = BTC_PID_GAP_BLE ;
msg . act = ESP_GAP_BLE_GET_BOND_DEV_COMPLETE_EVT ;
ret = btc_transfer_context ( & msg , & param , sizeof ( esp_ble_gap_cb_param_t ) , btc_gap_ble_cb_deep_copy ) ;
if ( ret ! = BT_STATUS_SUCCESS ) {
LOG_ERROR ( " %s btc_transfer_context failed " , __func__ ) ;
}
// release the buffer after used.
2017-08-17 13:13:45 +00:00
osi_free ( bond_dev ) ;
2017-08-09 08:46:49 +00:00
}
2017-08-22 03:28:45 +00:00
# endif /* #if (SMP_INCLUDED) */
2017-07-19 06:50:40 +00:00
static void btc_ble_config_local_privacy ( bool privacy_enable , tBTA_SET_LOCAL_PRIVACY_CBACK * set_local_privacy_cback )
2016-11-15 12:56:15 +00:00
{
2017-07-19 06:50:40 +00:00
BTA_DmBleConfigLocalPrivacy ( privacy_enable , set_local_privacy_cback ) ;
2016-11-15 12:56:15 +00:00
}
2017-06-01 07:56:36 +00:00
static void btc_ble_disconnect ( BD_ADDR bd_addr )
{
BTA_DmBleDisconnect ( bd_addr ) ;
}
2016-11-15 12:56:15 +00:00
void btc_gap_ble_cb_handler ( btc_msg_t * msg )
{
2016-11-24 18:10:15 +00:00
esp_ble_gap_cb_param_t * param = ( esp_ble_gap_cb_param_t * ) msg - > arg ;
2017-08-09 08:46:49 +00:00
if ( msg - > act < ESP_GAP_BLE_EVT_MAX ) {
btc_gap_ble_cb_to_app ( msg - > act , param ) ;
} else {
LOG_ERROR ( " %s, unknow msg->act = %d " , __func__ , msg - > act ) ;
2016-11-24 18:10:15 +00:00
}
2017-08-09 08:46:49 +00:00
btc_gap_ble_cb_deep_free ( msg ) ;
2016-11-15 12:56:15 +00:00
}
2016-11-17 16:30:35 +00:00
void btc_gap_ble_arg_deep_copy ( btc_msg_t * msg , void * p_dest , void * p_src )
{
2016-11-24 18:10:15 +00:00
switch ( msg - > act ) {
case BTC_GAP_BLE_ACT_CFG_ADV_DATA : {
btc_ble_gap_args_t * src = ( btc_ble_gap_args_t * ) p_src ;
btc_ble_gap_args_t * dst = ( btc_ble_gap_args_t * ) p_dest ;
if ( src - > cfg_adv_data . adv_data . p_manufacturer_data ) {
2017-08-17 13:13:45 +00:00
dst - > cfg_adv_data . adv_data . p_manufacturer_data = osi_malloc ( src - > cfg_adv_data . adv_data . manufacturer_len ) ;
2016-11-24 18:10:15 +00:00
memcpy ( dst - > cfg_adv_data . adv_data . p_manufacturer_data , src - > cfg_adv_data . adv_data . p_manufacturer_data ,
src - > cfg_adv_data . adv_data . manufacturer_len ) ;
}
if ( src - > cfg_adv_data . adv_data . p_service_data ) {
2017-08-17 13:13:45 +00:00
dst - > cfg_adv_data . adv_data . p_service_data = osi_malloc ( src - > cfg_adv_data . adv_data . service_data_len ) ;
2016-11-24 18:10:15 +00:00
memcpy ( dst - > cfg_adv_data . adv_data . p_service_data , src - > cfg_adv_data . adv_data . p_service_data , src - > cfg_adv_data . adv_data . service_data_len ) ;
}
if ( src - > cfg_adv_data . adv_data . p_service_uuid ) {
2017-08-17 13:13:45 +00:00
dst - > cfg_adv_data . adv_data . p_service_uuid = osi_malloc ( src - > cfg_adv_data . adv_data . service_uuid_len ) ;
2016-11-24 18:10:15 +00:00
memcpy ( dst - > cfg_adv_data . adv_data . p_service_uuid , src - > cfg_adv_data . adv_data . p_service_uuid , src - > cfg_adv_data . adv_data . service_uuid_len ) ;
}
break ;
}
2017-01-19 03:49:59 +00:00
case BTC_GAP_BLE_ACT_CFG_ADV_DATA_RAW : {
btc_ble_gap_args_t * src = ( btc_ble_gap_args_t * ) p_src ;
btc_ble_gap_args_t * dst = ( btc_ble_gap_args_t * ) p_dest ;
if ( src & & src - > cfg_adv_data_raw . raw_adv & & src - > cfg_adv_data_raw . raw_adv_len > 0 ) {
2017-08-17 13:13:45 +00:00
dst - > cfg_adv_data_raw . raw_adv = osi_malloc ( src - > cfg_adv_data_raw . raw_adv_len ) ;
2017-01-19 03:49:59 +00:00
if ( dst - > cfg_adv_data_raw . raw_adv ) {
memcpy ( dst - > cfg_adv_data_raw . raw_adv , src - > cfg_adv_data_raw . raw_adv , src - > cfg_adv_data_raw . raw_adv_len ) ;
}
}
break ;
}
case BTC_GAP_BLE_ACT_CFG_SCAN_RSP_DATA_RAW : {
btc_ble_gap_args_t * src = ( btc_ble_gap_args_t * ) p_src ;
btc_ble_gap_args_t * dst = ( btc_ble_gap_args_t * ) p_dest ;
if ( src & & src - > cfg_scan_rsp_data_raw . raw_scan_rsp & & src - > cfg_scan_rsp_data_raw . raw_scan_rsp_len > 0 ) {
2017-08-17 13:13:45 +00:00
dst - > cfg_scan_rsp_data_raw . raw_scan_rsp = osi_malloc ( src - > cfg_scan_rsp_data_raw . raw_scan_rsp_len ) ;
2017-01-19 03:49:59 +00:00
if ( dst - > cfg_scan_rsp_data_raw . raw_scan_rsp ) {
memcpy ( dst - > cfg_scan_rsp_data_raw . raw_scan_rsp , src - > cfg_scan_rsp_data_raw . raw_scan_rsp , src - > cfg_scan_rsp_data_raw . raw_scan_rsp_len ) ;
}
2017-04-13 14:14:28 +00:00
}
break ;
2017-04-14 03:50:14 +00:00
}
case BTC_GAP_BLE_SET_SECURITY_PARAM_EVT : {
2017-04-13 14:14:28 +00:00
btc_ble_gap_args_t * src = ( btc_ble_gap_args_t * ) p_src ;
btc_ble_gap_args_t * dst = ( btc_ble_gap_args_t * ) p_dest ;
uint8_t length = 0 ;
if ( src - > set_security_param . value ) {
length = dst - > set_security_param . len ;
2017-08-17 13:13:45 +00:00
dst - > set_security_param . value = osi_malloc ( length ) ;
2017-04-13 14:14:28 +00:00
if ( dst - > set_security_param . value ! = NULL ) {
memcpy ( dst - > set_security_param . value , src - > set_security_param . value , length ) ;
} else {
LOG_ERROR ( " %s %d no mem \n " , __func__ , msg - > act ) ;
}
2017-01-19 03:49:59 +00:00
}
break ;
}
2016-11-24 18:10:15 +00:00
default :
LOG_ERROR ( " Unhandled deep copy %d \n " , msg - > act ) ;
break ;
}
2016-11-17 16:30:35 +00:00
}
2017-08-22 03:28:45 +00:00
void btc_gap_ble_cb_deep_copy ( btc_msg_t * msg , void * p_dest , void * p_src )
2017-08-09 08:46:49 +00:00
{
switch ( msg - > act ) {
case ESP_GAP_BLE_GET_BOND_DEV_COMPLETE_EVT : {
esp_ble_gap_cb_param_t * src = ( esp_ble_gap_cb_param_t * ) p_src ;
esp_ble_gap_cb_param_t * dst = ( esp_ble_gap_cb_param_t * ) p_dest ;
uint16_t length = 0 ;
if ( src - > get_bond_dev_cmpl . bond_dev ) {
length = ( src - > get_bond_dev_cmpl . dev_num ) * sizeof ( esp_ble_bond_dev_t ) ;
2017-08-17 13:13:45 +00:00
dst - > get_bond_dev_cmpl . bond_dev = ( esp_ble_bond_dev_t * ) osi_malloc ( length ) ;
2017-08-09 08:46:49 +00:00
if ( dst - > get_bond_dev_cmpl . bond_dev ! = NULL ) {
memcpy ( dst - > get_bond_dev_cmpl . bond_dev , src - > get_bond_dev_cmpl . bond_dev , length ) ;
} else {
LOG_ERROR ( " %s %d no mem " , __func__ , msg - > act ) ;
}
}
break ;
}
default :
LOG_ERROR ( " %s, Unhandled deep copy %d \n " , __func__ , msg - > act ) ;
break ;
}
}
2017-08-22 03:28:45 +00:00
void btc_gap_ble_arg_deep_free ( btc_msg_t * msg )
2016-11-17 16:30:35 +00:00
{
2016-11-24 18:10:15 +00:00
LOG_DEBUG ( " %s \n " , __func__ ) ;
switch ( msg - > act ) {
case BTC_GAP_BLE_ACT_CFG_ADV_DATA : {
esp_ble_adv_data_t * adv = & ( ( btc_ble_gap_args_t * ) msg - > arg ) - > cfg_adv_data . adv_data ;
if ( adv - > p_service_data ) {
2017-08-17 13:13:45 +00:00
osi_free ( adv - > p_service_data ) ;
2016-11-24 18:10:15 +00:00
}
if ( adv - > p_service_uuid ) {
2017-08-17 13:13:45 +00:00
osi_free ( adv - > p_service_uuid ) ;
2016-11-24 18:10:15 +00:00
}
if ( adv - > p_manufacturer_data ) {
2017-08-17 13:13:45 +00:00
osi_free ( adv - > p_manufacturer_data ) ;
2016-11-24 18:10:15 +00:00
}
break ;
}
2017-01-19 03:49:59 +00:00
case BTC_GAP_BLE_ACT_CFG_ADV_DATA_RAW : {
uint8_t * raw_adv = ( ( btc_ble_gap_args_t * ) msg - > arg ) - > cfg_adv_data_raw . raw_adv ;
if ( raw_adv ) {
2017-08-17 13:13:45 +00:00
osi_free ( raw_adv ) ;
2017-01-19 03:49:59 +00:00
}
break ;
}
case BTC_GAP_BLE_ACT_CFG_SCAN_RSP_DATA_RAW : {
uint8_t * raw_scan_rsp = ( ( btc_ble_gap_args_t * ) msg - > arg ) - > cfg_scan_rsp_data_raw . raw_scan_rsp ;
if ( raw_scan_rsp ) {
2017-08-17 13:13:45 +00:00
osi_free ( raw_scan_rsp ) ;
2017-01-19 03:49:59 +00:00
}
break ;
}
2016-11-24 18:10:15 +00:00
default :
LOG_DEBUG ( " Unhandled deep free %d \n " , msg - > act ) ;
break ;
}
2016-11-17 16:30:35 +00:00
}
2017-08-22 03:28:45 +00:00
void btc_gap_ble_cb_deep_free ( btc_msg_t * msg )
2017-08-09 08:46:49 +00:00
{
LOG_DEBUG ( " %s " , __func__ ) ;
switch ( msg - > act ) {
case ESP_GAP_BLE_GET_BOND_DEV_COMPLETE_EVT : {
esp_ble_bond_dev_t * bond_dev = ( ( esp_ble_gap_cb_param_t * ) msg - > arg ) - > get_bond_dev_cmpl . bond_dev ;
if ( bond_dev ) {
2017-08-17 13:13:45 +00:00
osi_free ( bond_dev ) ;
2017-08-09 08:46:49 +00:00
}
break ;
}
default :
LOG_DEBUG ( " Unhandled deep free %d " , msg - > act ) ;
break ;
}
}
2016-11-15 12:56:15 +00:00
void btc_gap_ble_call_handler ( btc_msg_t * msg )
{
2016-11-24 18:10:15 +00:00
btc_ble_gap_args_t * arg = ( btc_ble_gap_args_t * ) msg - > arg ;
2016-11-18 14:10:35 +00:00
LOG_DEBUG ( " %s act %d \n " , __FUNCTION__ , msg - > act ) ;
2016-11-15 12:56:15 +00:00
2016-11-24 18:10:15 +00:00
switch ( msg - > act ) {
case BTC_GAP_BLE_ACT_CFG_ADV_DATA : {
if ( arg - > cfg_adv_data . adv_data . set_scan_rsp = = false ) {
btc_ble_set_adv_data ( & arg - > cfg_adv_data . adv_data , btc_adv_data_callback ) ;
} else {
btc_ble_set_adv_data ( & arg - > cfg_adv_data . adv_data , btc_scan_rsp_data_callback ) ;
}
break ;
}
case BTC_GAP_BLE_ACT_SET_SCAN_PARAM :
2016-12-07 06:11:40 +00:00
btc_ble_set_scan_params ( & arg - > set_scan_param . scan_params , btc_scan_params_callback ) ;
2016-11-24 18:10:15 +00:00
break ;
case BTC_GAP_BLE_ACT_START_SCAN :
2017-02-23 09:32:46 +00:00
btc_ble_start_scanning ( arg - > start_scan . duration , btc_search_callback , btc_start_scan_callback ) ;
2016-11-24 18:10:15 +00:00
break ;
case BTC_GAP_BLE_ACT_STOP_SCAN :
2017-03-29 08:51:21 +00:00
btc_ble_stop_scanning ( btc_stop_scan_callback ) ;
2016-11-24 18:10:15 +00:00
break ;
case BTC_GAP_BLE_ACT_START_ADV :
2017-02-23 09:32:46 +00:00
btc_ble_start_advertising ( & arg - > start_adv . adv_params , btc_start_adv_callback ) ;
2016-11-24 18:10:15 +00:00
break ;
case BTC_GAP_BLE_ACT_STOP_ADV :
2017-03-29 08:51:21 +00:00
btc_ble_stop_advertising ( btc_stop_adv_callback ) ;
2016-11-24 18:10:15 +00:00
break ;
case BTC_GAP_BLE_ACT_UPDATE_CONN_PARAM :
btc_ble_update_conn_params ( arg - > conn_update_params . conn_params . bda ,
arg - > conn_update_params . conn_params . min_int ,
arg - > conn_update_params . conn_params . max_int ,
arg - > conn_update_params . conn_params . latency ,
2017-08-24 12:46:03 +00:00
arg - > conn_update_params . conn_params . timeout ) ;
2016-11-24 18:10:15 +00:00
break ;
case BTC_GAP_BLE_ACT_SET_PKT_DATA_LEN :
2017-06-14 13:19:48 +00:00
btc_ble_set_pkt_data_len ( arg - > set_pkt_data_len . remote_device , arg - > set_pkt_data_len . tx_data_length , btc_set_pkt_length_callback ) ;
2016-11-24 18:10:15 +00:00
break ;
2017-04-14 06:45:07 +00:00
case BTC_GAP_BLE_ACT_SET_RAND_ADDRESS : {
BD_ADDR bd_addr ;
memcpy ( bd_addr , arg - > set_rand_addr . rand_addr , sizeof ( BD_ADDR ) ) ;
btc_ble_set_rand_addr ( bd_addr ) ;
2016-11-24 18:10:15 +00:00
break ;
2017-04-14 06:45:07 +00:00
}
2016-11-24 18:10:15 +00:00
case BTC_GAP_BLE_ACT_CONFIG_LOCAL_PRIVACY :
2017-07-19 06:50:40 +00:00
btc_ble_config_local_privacy ( arg - > cfg_local_privacy . privacy_enable , btc_set_local_privacy_callback ) ;
2017-04-13 14:14:28 +00:00
break ;
2017-01-19 03:49:59 +00:00
case BTC_GAP_BLE_ACT_CFG_ADV_DATA_RAW :
btc_ble_set_adv_data_raw ( arg - > cfg_adv_data_raw . raw_adv ,
arg - > cfg_adv_data_raw . raw_adv_len ,
btc_adv_data_raw_callback ) ;
break ;
case BTC_GAP_BLE_ACT_CFG_SCAN_RSP_DATA_RAW :
btc_ble_set_scan_rsp_data_raw ( arg - > cfg_scan_rsp_data_raw . raw_scan_rsp ,
arg - > cfg_scan_rsp_data_raw . raw_scan_rsp_len ,
btc_scan_rsp_data_raw_callback ) ;
break ;
2017-04-25 03:46:37 +00:00
# if (SMP_INCLUDED == TRUE)
2017-05-26 09:26:15 +00:00
case BTC_GAP_BLE_SET_ENCRYPTION_EVT : {
2017-04-13 14:14:28 +00:00
BD_ADDR bd_addr ;
memcpy ( bd_addr , arg - > set_encryption . bd_addr , sizeof ( BD_ADDR ) ) ;
BTA_DmSetEncryption ( bd_addr , BT_TRANSPORT_LE , btc_set_encryption_callback ,
( tBTA_DM_BLE_SEC_ACT ) arg - > set_encryption . sec_act ) ;
break ;
}
case BTC_GAP_BLE_SET_SECURITY_PARAM_EVT : {
switch ( arg - > set_security_param . param_type ) {
2017-04-14 03:50:14 +00:00
case ESP_BLE_SM_PASSKEY :
break ;
2017-04-13 14:14:28 +00:00
case ESP_BLE_SM_AUTHEN_REQ_MODE : {
uint8_t authen_req = 0 ;
STREAM_TO_UINT8 ( authen_req , arg - > set_security_param . value ) ;
bta_dm_co_ble_set_auth_req ( authen_req ) ;
break ;
2017-04-14 03:50:14 +00:00
}
case ESP_BLE_SM_IOCAP_MODE : {
2017-04-13 14:14:28 +00:00
uint8_t iocap = 0 ;
STREAM_TO_UINT8 ( iocap , arg - > set_security_param . value ) ;
bta_dm_co_ble_set_io_cap ( iocap ) ;
2017-04-14 03:50:14 +00:00
break ;
}
2017-04-13 14:14:28 +00:00
case ESP_BLE_SM_SET_INIT_KEY : {
uint8_t init_key = 0 ;
STREAM_TO_UINT8 ( init_key , arg - > set_security_param . value ) ;
bta_dm_co_ble_set_init_key_req ( init_key ) ;
break ;
}
2017-06-09 08:54:56 +00:00
case ESP_BLE_SM_SET_RSP_KEY : {
2017-04-13 14:14:28 +00:00
uint8_t rsp_key = 0 ;
STREAM_TO_UINT8 ( rsp_key , arg - > set_security_param . value ) ;
bta_dm_co_ble_set_rsp_key_req ( rsp_key ) ;
break ;
}
case ESP_BLE_SM_MAX_KEY_SIZE : {
uint8_t key_size = 0 ;
STREAM_TO_UINT8 ( key_size , arg - > set_security_param . value ) ;
bta_dm_co_ble_set_max_key_size ( key_size ) ;
break ;
2017-04-14 03:50:14 +00:00
}
default :
break ;
}
2017-04-13 14:14:28 +00:00
break ;
2017-04-14 03:50:14 +00:00
}
2017-04-13 14:14:28 +00:00
case BTC_GAP_BLE_SECURITY_RSP_EVT : {
2017-04-14 03:50:14 +00:00
BD_ADDR bd_addr ;
tBTA_DM_BLE_SEC_GRANT res = arg - > sec_rsp . accept ? BTA_DM_SEC_GRANTED : BTA_DM_SEC_PAIR_NOT_SPT ;
memcpy ( bd_addr , arg - > sec_rsp . bd_addr , sizeof ( BD_ADDR ) ) ;
BTA_DmBleSecurityGrant ( bd_addr , res ) ;
break ;
2017-04-13 14:14:28 +00:00
}
2017-05-26 09:26:15 +00:00
case BTC_GAP_BLE_PASSKEY_REPLY_EVT : {
BD_ADDR bd_addr ;
memcpy ( bd_addr , arg - > enc_passkey_replay . bd_addr , sizeof ( BD_ADDR ) ) ;
BTA_DmBlePasskeyReply ( bd_addr , arg - > enc_passkey_replay . accept , arg - > enc_passkey_replay . passkey ) ;
break ;
}
case BTC_GAP_BLE_CONFIRM_REPLY_EVT : {
BD_ADDR bd_addr ;
memcpy ( bd_addr , arg - > enc_comfirm_replay . bd_addr , sizeof ( BD_ADDR ) ) ;
BTA_DmBleConfirmReply ( bd_addr , arg - > enc_comfirm_replay . accept ) ;
break ;
}
2017-08-09 08:46:49 +00:00
case BTC_GAP_BLE_REMOVE_BOND_DEV_EVT : {
BD_ADDR bd_addr ;
bt_bdaddr_t bt_addr ;
memcpy ( bd_addr , arg - > remove_bond_device . bd_addr , sizeof ( BD_ADDR ) ) ;
memcpy ( bt_addr . address , arg - > remove_bond_device . bd_addr , sizeof ( bt_bdaddr_t ) ) ;
LOG_DEBUG ( " BTC_GAP_BLE_REMOVE_BOND_DEV_EVT " ) ;
if ( btc_storage_remove_ble_bonding_keys ( & bt_addr ) = = BT_STATUS_SUCCESS ) {
BTA_DmRemoveDevice ( bd_addr ) ;
} else {
LOG_ERROR ( " remove device failed: the address[%x:%x:%x:%x:%x:%x] didn't in the bonding list " , bd_addr [ 0 ] , bd_addr [ 1 ] , bd_addr [ 2 ] , bd_addr [ 3 ] , bd_addr [ 4 ] , bd_addr [ 5 ] ) ;
btc_ble_remove_bond_device ( ESP_BT_STATUS_FAIL ) ;
}
break ;
}
case BTC_GAP_BLE_CLEAR_BOND_DEV_EVT :
btc_ble_clear_bond_device ( ) ;
break ;
case BTC_GAP_BLE_GET_BOND_DEV_EVT :
btc_ble_get_bond_device_list ( ) ;
break ;
2017-05-26 09:26:15 +00:00
# endif ///SMP_INCLUDED == TRUE
2017-06-01 07:56:36 +00:00
case BTC_GAP_BLE_DISCONNECT_EVT :
btc_ble_disconnect ( arg - > disconnect . remote_device ) ;
break ;
2016-11-24 18:10:15 +00:00
default :
break ;
}
btc_gap_ble_arg_deep_free ( msg ) ;
2016-11-15 12:56:15 +00:00
}
2017-08-24 12:46:03 +00:00
//register connection parameter update callback
void btc_gap_callback_init ( void )
{
BTM_BleRegiseterConnParamCallback ( btc_update_conn_param_callback ) ;
}