if(bta_dm_cb.p_sec_cback)
bta_dm_cb.p_sec_cback(BTA_DM_ENABLE_EVT, &sec_event);
-#if ( BLE_INCLUDED == TRUE)
+#if BLE_VND_INCLUDED == TRUE
BTM_BleReadControllerFeatures (bta_dm_ctrl_features_rd_cmpl_cback);
#endif
}
{
if (!L2CA_UpdateBleConnParams(p_data->ble_update_conn_params.bd_addr,
p_data->ble_update_conn_params.min_int,
- p_data-> ble_update_conn_params.max_int,
+ p_data->ble_update_conn_params.max_int,
p_data->ble_update_conn_params.latency,
p_data->ble_update_conn_params.timeout))
{
BTM_BleConfigPrivacy (p_data->ble_local_privacy.privacy_enable);
}
#endif
-
/*******************************************************************************
**
** Function bta_dm_ble_observe
*******************************************************************************/
void bta_dm_ble_observe (tBTA_DM_MSG *p_data)
{
-
tBTM_STATUS status;
if (p_data->ble_observe.start)
{
*******************************************************************************/
void bta_dm_ble_multi_adv_enb(tBTA_DM_MSG *p_data)
{
-#if BLE_MULTI_ADV_INCLUDED == TRUE
- BTM_BleEnableAdvInstance((tBTM_BLE_ADV_PARAMS*)p_data->ble_multi_adv_enb.p_params,
- p_data->ble_multi_adv_enb.p_cback,p_data->ble_multi_adv_enb.p_ref);
-#endif
+ tBTM_STATUS btm_status = 0;
+ void *p_ref = NULL;
+
+ bta_dm_cb.p_multi_adv_cback = p_data->ble_multi_adv_enb.p_cback;
+ if(BTM_BleMaxMultiAdvInstanceCount() > 0 && NULL != p_data->ble_multi_adv_enb.p_ref)
+ {
+ btm_status = BTM_BleEnableAdvInstance((tBTM_BLE_ADV_PARAMS*)
+ p_data->ble_multi_adv_enb.p_params,
+ p_data->ble_multi_adv_enb.p_cback,
+ p_data->ble_multi_adv_enb.p_ref);
+ }
+
+ if(BTM_CMD_STARTED != btm_status)
+ {
+ bta_dm_cb.p_multi_adv_cback(BTA_BLE_MULTI_ADV_ENB_EVT, 0xFF,
+ p_data->ble_multi_adv_enb.p_ref, BTA_FAILURE);
+ }
}
/*******************************************************************************
**
*******************************************************************************/
void bta_dm_ble_multi_adv_upd_param(tBTA_DM_MSG *p_data)
{
-#if BLE_MULTI_ADV_INCLUDED == TRUE
- BTM_BleUpdateAdvInstParam(p_data->ble_multi_adv_param.inst_id,
- (tBTM_BLE_ADV_PARAMS*)p_data->ble_multi_adv_param.p_params);
-#endif
+ tBTM_STATUS btm_status = 0;
+ void *p_ref = NULL;
+
+ if(BTM_BleMaxMultiAdvInstanceCount() > 0 && p_data->ble_multi_adv_param.inst_id > 0
+ && p_data->ble_multi_adv_param.inst_id < BTM_BleMaxMultiAdvInstanceCount())
+ {
+ btm_status = BTM_BleUpdateAdvInstParam(p_data->ble_multi_adv_param.inst_id,
+ (tBTM_BLE_ADV_PARAMS*)p_data->ble_multi_adv_param.p_params);
+ }
+
+ if(BTM_CMD_STARTED != btm_status)
+ {
+ p_ref = btm_ble_multi_adv_get_ref(p_data->ble_multi_adv_param.inst_id);
+ bta_dm_cb.p_multi_adv_cback(BTA_BLE_MULTI_ADV_PARAM_EVT,
+ p_data->ble_multi_adv_param.inst_id, p_ref, BTA_FAILURE);
+ }
}
/*******************************************************************************
**
*******************************************************************************/
void bta_dm_ble_multi_adv_data(tBTA_DM_MSG *p_data)
{
-#if BLE_MULTI_ADV_INCLUDED == TRUE
- BTM_BleCfgAdvInstData(p_data->ble_multi_adv_data.inst_id,p_data->ble_multi_adv_data.is_scan_rsp,
- p_data->ble_multi_adv_data.data_mask,(tBTM_BLE_ADV_DATA*)p_data->ble_multi_adv_data.p_data);
-#endif
+ tBTM_STATUS btm_status = 0;
+ void *p_ref = NULL;
+
+ if(BTM_BleMaxMultiAdvInstanceCount() > 0 && p_data->ble_multi_adv_data.inst_id > 0
+ && p_data->ble_multi_adv_data.inst_id < BTM_BleMaxMultiAdvInstanceCount())
+ {
+ btm_status = BTM_BleCfgAdvInstData(p_data->ble_multi_adv_data.inst_id,
+ p_data->ble_multi_adv_data.is_scan_rsp,
+ p_data->ble_multi_adv_data.data_mask,
+ (tBTM_BLE_ADV_DATA*)p_data->ble_multi_adv_data.p_data);
+ }
+
+ if(BTM_CMD_STARTED != btm_status)
+ {
+ p_ref = btm_ble_multi_adv_get_ref(p_data->ble_multi_adv_data.inst_id);
+ bta_dm_cb.p_multi_adv_cback(BTA_BLE_MULTI_ADV_DATA_EVT,
+ p_data->ble_multi_adv_data.inst_id, p_ref, BTA_FAILURE);
+ }
+
}
/*******************************************************************************
**
*******************************************************************************/
void btm_dm_ble_multi_adv_disable(tBTA_DM_MSG *p_data)
{
-#if BLE_MULTI_ADV_INCLUDED == TRUE
- BTM_BleDisableAdvInstance(p_data->ble_multi_adv_disable.inst_id);
-#endif
+ tBTM_STATUS btm_status = 0;
+ void *p_ref = NULL;
+
+ if(BTM_BleMaxMultiAdvInstanceCount() > 0 && p_data->ble_multi_adv_disable.inst_id > 0
+ && p_data->ble_multi_adv_disable.inst_id < BTM_BleMaxMultiAdvInstanceCount())
+ {
+ btm_status = BTM_BleDisableAdvInstance(p_data->ble_multi_adv_disable.inst_id);
+ }
+
+ if(BTM_CMD_STARTED != btm_status)
+ {
+ p_ref = btm_ble_multi_adv_get_ref(p_data->ble_multi_adv_disable.inst_id);
+ bta_dm_cb.p_multi_adv_cback(BTA_BLE_MULTI_ADV_DISABLE_EVT,
+ p_data->ble_multi_adv_disable.inst_id, p_ref, BTA_FAILURE);
+ }
}
/*******************************************************************************
*******************************************************************************/
void bta_dm_ble_setup_storage (tBTA_DM_MSG *p_data)
{
-#if BLE_BATCH_SCAN_INCLUDED == TRUE
tBTM_STATUS btm_status = 0;
+ tBTM_BLE_VSC_CB cmn_ble_vsc_cb;
- btm_status = BTM_BleSetStorageConfig(p_data->ble_set_storage.batch_scan_full_max,
- p_data->ble_set_storage.batch_scan_trunc_max,
- p_data->ble_set_storage.batch_scan_notify_threshold,
- p_data->ble_set_storage.p_setup_cback,
- p_data->ble_set_storage.p_thres_cback,
- p_data->ble_set_storage.p_read_rep_cback,
- p_data->ble_set_storage.ref_value);
+ BTM_BleGetVendorCapabilities(&cmn_ble_vsc_cb);
+
+ if (0 != cmn_ble_vsc_cb.tot_scan_results_strg)
+ {
+ btm_status = BTM_BleSetStorageConfig(p_data->ble_set_storage.batch_scan_full_max,
+ p_data->ble_set_storage.batch_scan_trunc_max,
+ p_data->ble_set_storage.batch_scan_notify_threshold,
+ p_data->ble_set_storage.p_setup_cback,
+ p_data->ble_set_storage.p_thres_cback,
+ p_data->ble_set_storage.p_read_rep_cback,
+ p_data->ble_set_storage.ref_value);
+ }
if(BTM_CMD_STARTED != btm_status)
bta_ble_scan_setup_cb(BTM_BLE_BATCH_SCAN_CFG_STRG_EVT, p_data->ble_set_storage.ref_value,
btm_status);
-#endif
}
/*******************************************************************************
*******************************************************************************/
void bta_dm_ble_enable_batch_scan (tBTA_DM_MSG *p_data)
{
-#if BLE_BATCH_SCAN_INCLUDED == TRUE
tBTM_STATUS btm_status = 0;
+ tBTM_BLE_VSC_CB cmn_ble_vsc_cb;
+
+ BTM_BleGetVendorCapabilities(&cmn_ble_vsc_cb);
- btm_status = BTM_BleEnableBatchScan(p_data->ble_enable_scan.scan_mode,
- p_data->ble_enable_scan.scan_int,p_data->ble_enable_scan.scan_window,
- p_data->ble_enable_scan.addr_type,
- p_data->ble_enable_scan.discard_rule,
- p_data->ble_enable_scan.ref_value);
+ if (0 != cmn_ble_vsc_cb.tot_scan_results_strg)
+ {
+ btm_status = BTM_BleEnableBatchScan(p_data->ble_enable_scan.scan_mode,
+ p_data->ble_enable_scan.scan_int,
+ p_data->ble_enable_scan.scan_window,
+ p_data->ble_enable_scan.discard_rule,
+ p_data->ble_enable_scan.addr_type,
+ p_data->ble_enable_scan.ref_value);
+ }
if(BTM_CMD_STARTED != btm_status)
bta_ble_scan_setup_cb(BTM_BLE_BATCH_SCAN_ENABLE_EVT, p_data->ble_enable_scan.ref_value,
- btm_status);
-
-#endif
+ btm_status);
}
/*******************************************************************************
void bta_dm_ble_disable_batch_scan (tBTA_DM_MSG *p_data)
{
UNUSED(p_data);
-#if BLE_BATCH_SCAN_INCLUDED == TRUE
tBTM_STATUS btm_status = 0;
+ tBTM_BLE_VSC_CB cmn_ble_vsc_cb;
- btm_status = BTM_BleDisableBatchScan(p_data->ble_disable_scan.ref_value);
+ BTM_BleGetVendorCapabilities(&cmn_ble_vsc_cb);
+
+ if (0 != cmn_ble_vsc_cb.tot_scan_results_strg)
+ {
+ btm_status = BTM_BleDisableBatchScan(p_data->ble_disable_scan.ref_value);
+ }
if(BTM_CMD_STARTED != btm_status)
bta_ble_scan_setup_cb(BTM_BLE_BATCH_SCAN_DISABLE_EVT, p_data->ble_enable_scan.ref_value,
btm_status);
-#endif
}
/*******************************************************************************
*******************************************************************************/
void bta_dm_ble_read_scan_reports(tBTA_DM_MSG *p_data)
{
-#if BLE_BATCH_SCAN_INCLUDED == TRUE
tBTM_STATUS btm_status = 0;
+ tBTM_BLE_VSC_CB cmn_ble_vsc_cb;
- btm_status = BTM_BleReadScanReports(p_data->ble_read_reports.scan_type,
- p_data->ble_read_reports.ref_value);
+ BTM_BleGetVendorCapabilities(&cmn_ble_vsc_cb);
+
+ if (0 != cmn_ble_vsc_cb.tot_scan_results_strg)
+ {
+ btm_status = BTM_BleReadScanReports(p_data->ble_read_reports.scan_type,
+ p_data->ble_read_reports.ref_value);
+ }
if(BTM_CMD_STARTED != btm_status)
bta_ble_scan_setup_cb(BTM_BLE_BATCH_SCAN_READ_REPTS_EVT, p_data->ble_enable_scan.ref_value,
btm_status);
-#endif
}
/*******************************************************************************
*******************************************************************************/
void bta_dm_ble_track_advertiser(tBTA_DM_MSG *p_data)
{
- BTM_BleTrackAdvertiser(p_data->ble_track_advert.p_track_adv_cback,
- p_data->ble_track_advert.ref_value);
+ tBTM_STATUS btm_status = 0;
+ BD_ADDR bda;
+ memset(&bda, 0 , sizeof(BD_ADDR));
+ tBTM_BLE_VSC_CB cmn_ble_vsc_cb;
+
+ BTM_BleGetVendorCapabilities(&cmn_ble_vsc_cb);
+
+ if (0 != cmn_ble_vsc_cb.tot_scan_results_strg)
+ {
+ btm_status = BTM_BleTrackAdvertiser(p_data->ble_track_advert.p_track_adv_cback,
+ p_data->ble_track_advert.ref_value);
+ }
+
+ if(BTM_CMD_STARTED != btm_status)
+ p_data->ble_track_advert.p_track_adv_cback(0, 0, bda, 0, p_data->ble_track_advert.ref_value);
}
/*******************************************************************************
/*******************************************************************************
**
-** Function bta_ble_enable_scan_cmpl
-**
-** Description ADV payload filtering enable / disable complete callback
-**
-**
-** Returns None
-**
-*******************************************************************************/
-static void bta_ble_energy_info_cmpl(tBTM_BLE_TX_TIME_MS tx_time,
- tBTM_BLE_RX_TIME_MS rx_time,
- tBTM_BLE_IDLE_TIME_MS idle_time,
- tBTM_BLE_ENERGY_USED energy_used,
- tBTM_STATUS status)
-{
- tBTA_STATUS st = (status == BTM_SUCCESS) ? BTA_SUCCESS: BTA_FAILURE;
- tBTA_DM_CONTRL_STATE ctrl_state = 0;
-
- if (BTA_SUCCESS == st)
- ctrl_state = bta_dm_pm_obtain_controller_state();
-
- if (bta_dm_cb.p_energy_info_cback)
- bta_dm_cb.p_energy_info_cback(tx_time, rx_time, idle_time, energy_used, ctrl_state, st);
-}
-
-/*******************************************************************************
-**
-** Function bta_dm_ble_get_energy_info
-**
-** Description This function obtains the energy info
-**
-** Parameters:
-**
-*******************************************************************************/
-void bta_dm_ble_get_energy_info(tBTA_DM_MSG *p_data)
-{
- tBTM_STATUS btm_status = 0;
-
- bta_dm_cb.p_energy_info_cback = p_data->ble_energy_info.p_energy_info_cback;
- btm_status = BTM_BleGetEnergyInfo(bta_ble_energy_info_cmpl);
- if (BTM_CMD_STARTED != btm_status)
- bta_ble_energy_info_cmpl(0, 0, 0, 0, btm_status);
-}
-
-/*******************************************************************************
-**
** Function bta_dm_cfg_filter_cond
**
** Description This function configure adv payload filtering condition
}
#endif
+/*******************************************************************************
+**
+** Function bta_ble_enable_scan_cmpl
+**
+** Description ADV payload filtering enable / disable complete callback
+**
+**
+** Returns None
+**
+*******************************************************************************/
+static void bta_ble_energy_info_cmpl(tBTM_BLE_TX_TIME_MS tx_time,
+ tBTM_BLE_RX_TIME_MS rx_time,
+ tBTM_BLE_IDLE_TIME_MS idle_time,
+ tBTM_BLE_ENERGY_USED energy_used,
+ tBTM_STATUS status)
+{
+ tBTA_STATUS st = (status == BTM_SUCCESS) ? BTA_SUCCESS: BTA_FAILURE;
+ tBTA_DM_CONTRL_STATE ctrl_state = 0;
+
+ if (BTA_SUCCESS == st)
+ ctrl_state = bta_dm_pm_obtain_controller_state();
+
+ if (bta_dm_cb.p_energy_info_cback)
+ bta_dm_cb.p_energy_info_cback(tx_time, rx_time, idle_time, energy_used, ctrl_state, st);
+}
+
+/*******************************************************************************
+**
+** Function bta_dm_ble_get_energy_info
+**
+** Description This function obtains the energy info
+**
+** Parameters:
+**
+*******************************************************************************/
+void bta_dm_ble_get_energy_info(tBTA_DM_MSG *p_data)
+{
+ tBTM_STATUS btm_status = 0;
+
+ bta_dm_cb.p_energy_info_cback = p_data->ble_energy_info.p_energy_info_cback;
+ btm_status = BTM_BleGetEnergyInfo(bta_ble_energy_info_cmpl);
+ if (BTM_CMD_STARTED != btm_status)
+ bta_ble_energy_info_cmpl(0, 0, 0, 0, btm_status);
+}
+
#if ((defined BTA_GATT_INCLUDED) && (BTA_GATT_INCLUDED == TRUE))
#ifndef BTA_DM_GATT_CLOSE_DELAY_TOUT
#define BTA_DM_GATT_CLOSE_DELAY_TOUT 1000
#include "btm_int.h"
#include <string.h>
#include "utl.h"
+#include "vendor_ble.h"
/*****************************************************************************
** Constants
}
}
-#if BLE_INCLUDED == TRUE
-
/*******************************************************************************
**
** Function BTA_DmAddBleKey
tBTA_TRANSPORT transport)
{
tBTA_DM_API_DISCOVER *p_msg;
- UINT16 len = p_services ? (sizeof(tBTA_DM_API_DISCOVER) +
+ UINT16 len = p_services ? (sizeof(tBTA_DM_API_DISCOVER) +
sizeof(tBT_UUID) * p_services->num_uuid) :
sizeof(tBTA_DM_API_DISCOVER);
void BTA_DmBleConfigLocalPrivacy(BOOLEAN privacy_enable)
{
#if BLE_INCLUDED == TRUE
-#if BLE_VND_INCLUDED == TRUE && BLE_PRIVACY_SPT == TRUE
tBTA_DM_API_LOCAL_PRIVACY *p_msg;
if ((p_msg = (tBTA_DM_API_LOCAL_PRIVACY *) GKI_getbuf(sizeof(tBTA_DM_API_ENABLE_PRIVACY))) != NULL)
bta_sys_sendmsg(p_msg);
}
-#endif
#else
- UNUSED(privacy_enable);
+ UNUSED (privacy_enable);
#endif
}
-#endif
#if BLE_INCLUDED == TRUE
/*******************************************************************************
** Returns BTA_SUCCESS if command started sucessfully; otherwise failure.
**
*******************************************************************************/
-tBTA_STATUS BTA_BleEnableAdvInstance (tBTA_BLE_ADV_PARAMS *p_params,
+void BTA_BleEnableAdvInstance (tBTA_BLE_ADV_PARAMS *p_params,
tBTA_BLE_MULTI_ADV_CBACK *p_cback,
void *p_ref)
{
p_msg->p_ref = p_ref;
bta_sys_sendmsg(p_msg);
-
- return BTA_SUCCESS;
}
- return BTA_FAILURE;
}
/*******************************************************************************
** Returns BTA_SUCCESS if command started sucessfully; otherwise failure.
**
*******************************************************************************/
-tBTA_STATUS BTA_BleUpdateAdvInstParam (UINT8 inst_id, tBTA_BLE_ADV_PARAMS *p_params)
+void BTA_BleUpdateAdvInstParam (UINT8 inst_id, tBTA_BLE_ADV_PARAMS *p_params)
{
tBTA_DM_API_BLE_MULTI_ADV_PARAM *p_msg;
UINT16 len = sizeof(tBTA_BLE_ADV_PARAMS) + sizeof(tBTA_DM_API_BLE_MULTI_ADV_PARAM);
APPL_TRACE_API ("BTA_BleUpdateAdvInstParam");
- if (inst_id <= BTM_BLE_MULTI_ADV_MAX && inst_id != BTA_BLE_MULTI_ADV_ILLEGAL)
- {
- if ((p_msg = (tBTA_DM_API_BLE_MULTI_ADV_PARAM *) GKI_getbuf(len)) != NULL)
- {
- memset(p_msg, 0, sizeof(tBTA_DM_API_BLE_MULTI_ADV_PARAM));
+ if ((p_msg = (tBTA_DM_API_BLE_MULTI_ADV_PARAM *) GKI_getbuf(len)) != NULL)
+ {
+ memset(p_msg, 0, sizeof(tBTA_DM_API_BLE_MULTI_ADV_PARAM));
+ p_msg->hdr.event = BTA_DM_API_BLE_MULTI_ADV_PARAM_UPD_EVT;
+ p_msg->inst_id = inst_id;
+ p_msg->p_params = (void *)(p_msg + 1);
+ memcpy(p_msg->p_params, p_params, sizeof(tBTA_BLE_ADV_PARAMS));
- p_msg->hdr.event = BTA_DM_API_BLE_MULTI_ADV_PARAM_UPD_EVT;
- p_msg->inst_id = inst_id;
- p_msg->p_params = (void *)(p_msg + 1);
- memcpy(p_msg->p_params, p_params, sizeof(tBTA_BLE_ADV_PARAMS));
-
- bta_sys_sendmsg(p_msg);
-
- return BTA_SUCCESS;
- }
+ bta_sys_sendmsg(p_msg);
}
- return BTA_FAILURE;
}
/*******************************************************************************
** Returns BTA_SUCCESS if command started sucessfully; otherwise failure.
**
*******************************************************************************/
-tBTA_STATUS 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_ADV_DATA *p_data)
{
APPL_TRACE_API ("BTA_BleCfgAdvInstData");
- if (inst_id <= BTM_BLE_MULTI_ADV_MAX && inst_id != BTA_BLE_MULTI_ADV_ILLEGAL)
- {
if ((p_msg = (tBTA_DM_API_BLE_MULTI_ADV_DATA *) GKI_getbuf(len)) != NULL)
{
- memset(p_msg, 0, len);
-
- p_msg->hdr.event = BTA_DM_API_BLE_MULTI_ADV_DATA_EVT;
- p_msg->inst_id = inst_id;
- p_msg->is_scan_rsp = is_scan_rsp;
- p_msg->data_mask = data_mask;
- p_msg->p_data = p_data;
+ memset(p_msg, 0, len);
+ p_msg->hdr.event = BTA_DM_API_BLE_MULTI_ADV_DATA_EVT;
+ p_msg->inst_id = inst_id;
+ p_msg->is_scan_rsp = is_scan_rsp;
+ p_msg->data_mask = data_mask;
+ p_msg->p_data = p_data;
- bta_sys_sendmsg(p_msg);
-
- return BTA_SUCCESS;
- }
+ bta_sys_sendmsg(p_msg);
}
- return BTA_FAILURE;
}
/*******************************************************************************
** Returns BTA_SUCCESS if command started sucessfully; otherwise failure.
**
*******************************************************************************/
-tBTA_STATUS BTA_BleDisableAdvInstance (UINT8 inst_id)
+void BTA_BleDisableAdvInstance (UINT8 inst_id)
{
tBTA_DM_API_BLE_MULTI_ADV_DISABLE *p_msg;
APPL_TRACE_API ("BTA_BleDisableAdvInstance: %d", inst_id);
-
- if (inst_id <= BTM_BLE_MULTI_ADV_MAX && inst_id != BTA_BLE_MULTI_ADV_ILLEGAL)
+ if ((p_msg = (tBTA_DM_API_BLE_MULTI_ADV_DISABLE *)
+ GKI_getbuf(sizeof(tBTA_DM_API_BLE_MULTI_ADV_DISABLE))) != NULL)
{
- if ((p_msg = (tBTA_DM_API_BLE_MULTI_ADV_DISABLE *)
- GKI_getbuf(sizeof(tBTA_DM_API_BLE_MULTI_ADV_DISABLE))) != NULL)
- {
- memset(p_msg, 0, sizeof(tBTA_DM_API_BLE_MULTI_ADV_DISABLE));
- p_msg->hdr.event = BTA_DM_API_BLE_MULTI_ADV_DISABLE_EVT;
- p_msg->inst_id = inst_id;
- bta_sys_sendmsg(p_msg);
- return BTA_SUCCESS;
- }
+ memset(p_msg, 0, sizeof(tBTA_DM_API_BLE_MULTI_ADV_DISABLE));
+ p_msg->hdr.event = BTA_DM_API_BLE_MULTI_ADV_DISABLE_EVT;
+ p_msg->inst_id = inst_id;
+ bta_sys_sendmsg(p_msg);
}
- return BTA_FAILURE;
}
/*******************************************************************************
bta_sys_sendmsg(p_msg);
}
}
+
+/*******************************************************************************
+**
+** Function BTA_VendorInit
+**
+** Description This function initializes vendor specific
+**
+** Returns void
+**
+*******************************************************************************/
+void BTA_VendorInit (void)
+{
+ APPL_TRACE_API("BTA_VendorInit");
+}
+
+/*******************************************************************************
+**
+** Function BTA_VendorCleanup
+**
+** Description This function frees up Broadcom specific VS specific dynamic memory
+**
+** Returns void
+**
+*******************************************************************************/
+void BTA_VendorCleanup (void)
+{
+ tBTM_BLE_VSC_CB cmn_ble_vsc_cb;
+
+#if (BLE_INCLUDED == TRUE && BLE_ANDROID_CONTROLLER_SCAN_FILTER == TRUE)
+ btm_ble_adv_filter_cleanup();
+ btm_ble_vendor_cleanup();
+#endif
+
+ BTM_BleGetVendorCapabilities(&cmn_ble_vsc_cb);
+
+ if(cmn_ble_vsc_cb.adv_inst_max > 0)
+ btm_ble_multi_adv_cleanup();
+}
+
#endif
BTA_DM_API_BLE_SCAN_PARAM_EVT,
BTA_DM_API_BLE_OBSERVE_EVT,
BTA_DM_API_UPDATE_CONN_PARAM_EVT,
-
#if BLE_PRIVACY_SPT == TRUE
BTA_DM_API_LOCAL_PRIVACY_EVT,
#endif
-
BTA_DM_API_BLE_ADV_PARAM_EVT,
BTA_DM_API_BLE_SET_ADV_CONFIG_EVT,
BTA_DM_API_BLE_SET_SCAN_RSP_EVT,
typedef struct
{
BT_HDR hdr;
- void *p_cback;
+ tBTA_BLE_MULTI_ADV_CBACK *p_cback;
void *p_ref;
tBTA_BLE_ADV_PARAMS *p_params;
}tBTA_DM_API_BLE_MULTI_ADV_ENB;
tBTA_DM_SEC_CBACK *p_sec_cback;
#if ((defined BLE_INCLUDED) && (BLE_INCLUDED == TRUE))
tBTA_BLE_SCAN_SETUP_CBACK *p_setup_cback;
-#endif
tBTA_DM_BLE_PF_CFG_CBACK *p_scan_filt_cfg_cback;
tBTA_DM_BLE_PF_STATUS_CBACK *p_scan_filt_status_cback;
tBTA_DM_BLE_PF_PARAM_CBACK *p_scan_filt_param_cback;
-#if ((defined BLE_INCLUDED) && (BLE_INCLUDED == TRUE))
- tBTA_BLE_ENERGY_INFO_CBACK *p_energy_info_cback;
+ tBTA_BLE_MULTI_ADV_CBACK *p_multi_adv_cback;
#endif
+ tBTA_BLE_ENERGY_INFO_CBACK *p_energy_info_cback;
TIMER_LIST_ENT signal_strength_timer;
tBTA_SIG_STRENGTH_MASK signal_strength_mask;
UINT16 state;
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_update_conn_params (tBTA_DM_MSG *p_data);
-#if BLE_PRIVACY_SPT == TRUE
extern void bta_dm_ble_config_local_privacy (tBTA_DM_MSG *p_data);
-#endif
extern void bta_dm_ble_set_adv_params (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_disc_rmt_name (tBTA_DM_MSG *p_data);
extern tBTA_DM_PEER_DEVICE * bta_dm_find_peer_device(BD_ADDR peer_addr);
-#if BLE_PRIVACY_SPT == TRUE
extern void bta_dm_ble_config_local_privacy (tBTA_DM_MSG *p_data);
-#endif
extern void bta_dm_pm_active(BD_ADDR peer_addr);
bta_dm_ble_disable_batch_scan, /* BTA_DM_API_BLE_DISABLE_BATCH_SCAN_EVT */
bta_dm_ble_read_scan_reports, /* BTA_DM_API_BLE_READ_SCAN_REPORTS_EVT */
bta_dm_ble_track_advertiser, /* BTA_DM_API_BLE_TRACK_ADVERTISER_EVT */
- bta_dm_ble_get_energy_info, /* BTA_DM_API_BLE_ENERGY_INFO_EVT */
#endif
+ bta_dm_ble_get_energy_info, /* BTA_DM_API_BLE_ENERGY_INFO_EVT */
#if ( BTM_EIR_SERVER_INCLUDED == TRUE )&&( BTA_EIR_CANNED_UUID_LIST != TRUE )&&(BTA_EIR_SERVER_NUM_CUSTOM_UUID > 0)
bta_dm_update_eir_uuid, /* BTA_DM_API_UPDATE_EIR_UUID_EVT */
p_cb->rcb[first_unuse].p_cback = p_msg->api_reg.p_cback;
memcpy(&p_cb->rcb[first_unuse].app_uuid, &p_msg->api_reg.app_uuid, sizeof(tBT_UUID));
cb_data.reg_oper.server_if =
- p_cb->rcb[first_unuse].gatt_if =
+ p_cb->rcb[first_unuse].gatt_if =
GATT_Register(&p_msg->api_reg.app_uuid, &bta_gatts_cback);
if ( !p_cb->rcb[first_unuse].gatt_if)
{
/* Security callback */
typedef void (tBTA_DM_SEC_CBACK)(tBTA_DM_SEC_EVT event, tBTA_DM_SEC *p_data);
-#define BTA_BLE_MULTI_ADV_MAX BTM_BLE_MULTI_ADV_MAX
#define BTA_BLE_MULTI_ADV_ILLEGAL 0
/* multi adv callback event */
** Returns None
**
*******************************************************************************/
-BTA_API extern tBTA_STATUS BTA_BleEnableAdvInstance (tBTA_BLE_ADV_PARAMS *p_params,
+BTA_API extern void BTA_BleEnableAdvInstance (tBTA_BLE_ADV_PARAMS *p_params,
tBTA_BLE_MULTI_ADV_CBACK *p_cback,void *p_ref);
/*******************************************************************************
** Returns None
**
*******************************************************************************/
-BTA_API extern tBTA_STATUS BTA_BleUpdateAdvInstParam (UINT8 inst_id,
+BTA_API extern void BTA_BleUpdateAdvInstParam (UINT8 inst_id,
tBTA_BLE_ADV_PARAMS *p_params);
/*******************************************************************************
** Returns None
**
*******************************************************************************/
-BTA_API extern tBTA_STATUS BTA_BleCfgAdvInstData (UINT8 inst_id, BOOLEAN is_scan_rsp,
+BTA_API extern void BTA_BleCfgAdvInstData (UINT8 inst_id, BOOLEAN is_scan_rsp,
tBTA_BLE_AD_MASK data_mask, tBTA_BLE_ADV_DATA *p_data);
/*******************************************************************************
** Returns None
**
*******************************************************************************/
-BTA_API extern tBTA_STATUS BTA_BleDisableAdvInstance(UINT8 inst_id);
+BTA_API extern void BTA_BleDisableAdvInstance(UINT8 inst_id);
/*******************************************************************************
**
*******************************************************************************/
BTA_API extern void BTA_DmBleGetEnergyInfo(tBTA_BLE_ENERGY_INFO_CBACK *p_cmpl_cback);
+/*******************************************************************************
+**
+** Function BTA_BrcmInit
+**
+** Description This function initializes Broadcom specific VS handler in BTA
+**
+** Returns void
+**
+*******************************************************************************/
+BTA_API extern void BTA_VendorInit (void);
+
+/*******************************************************************************
+**
+** Function BTA_BrcmCleanup
+**
+** Description This function frees up Broadcom specific VS specific dynamic memory
+**
+** Returns void
+**
+*******************************************************************************/
+BTA_API extern void BTA_VendorCleanup (void);
+
#endif
#ifdef __cplusplus
#define CLNT_IF_IDX 0
#define INST_ID_IDX 1
+#define INST_ID_IDX_MAX INST_ID_IDX + 1
#define INVALID_ADV_INST -1
#define STD_ADV_INSTID 0
#define ADV_FLAGS 0x02
typedef struct
{
- INT8 clntif_map[BTM_BLE_MULTI_ADV_MAX][INST_ID_IDX+1];
+ INT8 *clntif_map;
// Includes the stored data for standard LE instance
- btgatt_multi_adv_inst_cb inst_cb[BTM_BLE_MULTI_ADV_MAX+1];
+ btgatt_multi_adv_inst_cb *inst_cb;
+
} btgatt_multi_adv_common_data;
extern btgatt_multi_adv_common_data *btif_obtain_multi_adv_data_cb();
extern int btif_multi_adv_add_instid_map(int client_if, int inst_id,
BOOLEAN gen_temp_instid);
extern int btif_multi_adv_instid_for_clientif(int client_if);
-extern int btif_gattc_obtain_idx_for_datacb(int value, int arrindex);
+extern int btif_gattc_obtain_idx_for_datacb(int value, int clnt_inst_index);
extern void btif_gattc_clear_clientif(int client_if);
extern void btif_gattc_cleanup_inst_cb(int inst_id);
extern void btif_gattc_cleanup_multi_inst_cb(btgatt_multi_adv_inst_cb *p_inst_cb);
btif_config_flush();
+#if (BLE_INCLUDED == TRUE)
+ BTA_VendorCleanup();
+#endif
+
if (status != BTA_SUCCESS)
{
BTIF_TRACE_ERROR("disable bt failed (%d)", status);
p_dev_cb->remote_dev[i].in_use = TRUE;
BTIF_TRACE_DEBUG("%s device overwrite idx=%d", __FUNCTION__, i );
p_dev_cb->next_storage_idx++;
- if(p_dev_cb->next_storage_idx >= BTIF_GATT_MAX_OBSERVED_DEV)
+ if (p_dev_cb->next_storage_idx >= BTIF_GATT_MAX_OBSERVED_DEV)
p_dev_cb->next_storage_idx = 0;
}
}
p_eir_remote_name = BTA_CheckEirData(p_btif_cb->value,
BTM_EIR_COMPLETE_LOCAL_NAME_TYPE, &remote_name_len);
- if(p_eir_remote_name == NULL)
+ if (p_eir_remote_name == NULL)
{
p_eir_remote_name = BTA_CheckEirData(p_btif_cb->value,
BT_EIR_SHORTENED_LOCAL_NAME_TYPE, &remote_name_len);
}
- if(p_eir_remote_name)
+ if (p_eir_remote_name)
{
memcpy(bdname.name, p_eir_remote_name, remote_name_len);
bdname.name[remote_name_len]='\0';
p_eir_remote_name = BTA_CheckEirData(p_btif_cb->value,
BTM_EIR_COMPLETE_LOCAL_NAME_TYPE, &remote_name_len);
- if(p_eir_remote_name == NULL)
+ if (p_eir_remote_name == NULL)
{
p_eir_remote_name = BTA_CheckEirData(p_btif_cb->value,
BT_EIR_SHORTENED_LOCAL_NAME_TYPE, &remote_name_len);
case BTA_GATTC_MULT_ADV_ENB_EVT:
{
btif_gattc_cb_t *p_btif_cb = (btif_gattc_cb_t*) p_param;
- btif_multi_adv_add_instid_map(p_btif_cb->client_if,
- p_btif_cb->inst_id,false);
+ if (0xFF != p_btif_cb->inst_id)
+ btif_multi_adv_add_instid_map(p_btif_cb->client_if, p_btif_cb->inst_id, false);
HAL_CBACK(bt_gatt_callbacks, client->multi_adv_enable_cb
, p_btif_cb->client_if
, p_btif_cb->status
btgatt_batch_track_cb_t *p_data = (btgatt_batch_track_cb_t*) p_param;
uint8_t *p_rep_data = NULL;
- if(p_data->read_reports.data_len > 0)
+ if (p_data->read_reports.data_len > 0)
{
p_rep_data = GKI_getbuf(p_data->read_reports.data_len);
memcpy(p_rep_data, p_data->read_reports.p_rep_data, p_data->read_reports.data_len);
tBTA_GATTC_EVT upevt;
uint8_t client_if = 0;
- if(NULL == p_ref)
+ if (NULL == p_ref)
{
- BTIF_TRACE_ERROR("%s Invalid p_ref received",__FUNCTION__);
- return;
+ BTIF_TRACE_WARNING("%s Invalid p_ref received",__FUNCTION__);
+ }
+ else
+ {
+ client_if = *(UINT8 *) p_ref;
}
- client_if = *(UINT8 *) p_ref;
BTIF_TRACE_DEBUG("%s -Inst ID %d, Status:%x, client_if:%d",__FUNCTION__,inst_id, call_status,
client_if);
-
btif_cb.status = call_status;
btif_cb.client_if = client_if;
- // Store the inst_id obtained from stack layer now
btif_cb.inst_id = inst_id;
switch(event)
btif_scan_track_cb.read_reports.data_len = data_len;
btif_scan_track_cb.read_reports.num_records = num_records;
- if(data_len > 0)
+ if (data_len > 0)
{
btif_scan_track_cb.read_reports.p_rep_data = GKI_getbuf(data_len);
memcpy(btif_scan_track_cb.read_reports.p_rep_data, p_rep_data, data_len);
btif_transfer_context(btif_gattc_upstreams_evt, BTA_GATTC_BTH_SCAN_RD_EVT,
(char*) &btif_scan_track_cb, sizeof(btgatt_batch_track_cb_t), NULL);
- if(data_len > 0)
+ if (data_len > 0)
GKI_freebuf(btif_scan_track_cb.read_reports.p_rep_data);
}
case BTIF_GATTC_SCAN_FILTER_PARAM_SETUP:
{
btgatt_adv_filter_cb_t *p_adv_filt_cb = (btgatt_adv_filter_cb_t *) p_param;
- if(1 == p_adv_filt_cb->adv_filt_param.dely_mode)
+ if (1 == p_adv_filt_cb->adv_filt_param.dely_mode)
BTA_DmBleTrackAdvertiser(p_adv_filt_cb->client_if, bta_track_adv_event_cb);
BTA_DmBleScanFilterSetup(p_adv_filt_cb->action, p_adv_filt_cb->filt_index,
&p_adv_filt_cb->adv_filt_param, NULL, bta_scan_filt_param_setup_cb,
{
btif_adv_data_t *p_adv_data = (btif_adv_data_t*) p_param;
int cbindex = CLNT_IF_IDX;
- if(cbindex >= 0 && NULL != p_adv_data)
+ if (cbindex >= 0 && NULL != p_adv_data)
{
btgatt_multi_adv_common_data *p_multi_adv_data_cb = btif_obtain_multi_adv_data_cb();
- if(!btif_gattc_copy_datacb(cbindex, p_adv_data, false))
+ if (!btif_gattc_copy_datacb(cbindex, p_adv_data, false))
return;
if (!p_adv_data->set_scan_rsp)
case BTIF_GATTC_ADV_INSTANCE_ENABLE:
{
btgatt_multi_adv_inst_cb *p_inst_cb = (btgatt_multi_adv_inst_cb*) p_param;
- int arrindex = btif_multi_adv_add_instid_map(p_inst_cb->client_if,INVALID_ADV_INST,
- true);
- int cbindex = btif_gattc_obtain_idx_for_datacb(p_inst_cb->client_if, CLNT_IF_IDX);
- if(cbindex >= 0 && arrindex >= 0)
+
+ int cbindex = -1, arrindex = -1;
+
+ arrindex = btif_multi_adv_add_instid_map(p_inst_cb->client_if,INVALID_ADV_INST, true);
+ if (arrindex >= 0)
+ cbindex = btif_gattc_obtain_idx_for_datacb(p_inst_cb->client_if, CLNT_IF_IDX);
+
+ if (cbindex >= 0 && arrindex >= 0)
{
btgatt_multi_adv_common_data *p_multi_adv_data_cb = btif_obtain_multi_adv_data_cb();
memcpy(&p_multi_adv_data_cb->inst_cb[cbindex].param,
&p_inst_cb->param, sizeof(tBTA_BLE_ADV_PARAMS));
-
+ BTIF_TRACE_DEBUG("%s, client_if value: %d", __FUNCTION__,
+ p_multi_adv_data_cb->clntif_map[arrindex + arrindex]);
BTA_BleEnableAdvInstance(&(p_multi_adv_data_cb->inst_cb[cbindex].param),
bta_gattc_multi_adv_cback,
- &(p_multi_adv_data_cb->clntif_map[arrindex][CLNT_IF_IDX]));
+ &(p_multi_adv_data_cb->clntif_map[arrindex + arrindex]));
}
else
+ {
+ /* let the error propagate up from BTA layer */
BTIF_TRACE_ERROR("%s invalid index in BTIF_GATTC_ENABLE_ADV",__FUNCTION__);
+ BTA_BleEnableAdvInstance(&p_inst_cb->param, bta_gattc_multi_adv_cback, NULL);
+ }
break;
}
btgatt_multi_adv_inst_cb *p_inst_cb = (btgatt_multi_adv_inst_cb*) p_param;
int inst_id = btif_multi_adv_instid_for_clientif(p_inst_cb->client_if);
int cbindex = btif_gattc_obtain_idx_for_datacb(p_inst_cb->client_if, CLNT_IF_IDX);
- if(inst_id >= 0 && cbindex >= 0 && NULL != p_inst_cb)
+ if (inst_id >= 0 && cbindex >= 0 && NULL != p_inst_cb)
{
btgatt_multi_adv_common_data *p_multi_adv_data_cb = btif_obtain_multi_adv_data_cb();
memcpy(&p_multi_adv_data_cb->inst_cb[cbindex].param, &p_inst_cb->param,
btif_adv_data_t *p_adv_data = (btif_adv_data_t*) p_param;
int cbindex = btif_gattc_obtain_idx_for_datacb(p_adv_data->client_if, CLNT_IF_IDX);
int inst_id = btif_multi_adv_instid_for_clientif(p_adv_data->client_if);
- if(inst_id < 0 || cbindex < 0)
+ if (inst_id < 0 || cbindex < 0)
{
BTIF_TRACE_ERROR("%s invalid index in BTIF_GATTC_SETADV_INST_DATA", __FUNCTION__);
return;
}
- if(!btif_gattc_copy_datacb(cbindex, p_adv_data, true))
+ if (!btif_gattc_copy_datacb(cbindex, p_adv_data, true))
return;
btgatt_multi_adv_common_data *p_multi_adv_data_cb = btif_obtain_multi_adv_data_cb();
{
btgatt_multi_adv_inst_cb *p_inst_cb = (btgatt_multi_adv_inst_cb*) p_param;
int inst_id = btif_multi_adv_instid_for_clientif(p_inst_cb->client_if);
- if(inst_id >=0)
+ if (inst_id >=0)
BTA_BleDisableAdvInstance((UINT8)inst_id);
else
BTIF_TRACE_ERROR("%s invalid instance ID in BTIF_GATTC_DISABLE_ADV",__FUNCTION__);
BTIF_TRACE_DEBUG("%s, %d, %d", __FUNCTION__, action, filt_type);
/* If data is passed, both mask and data have to be the same length */
- if(data_len != mask_len && NULL != p_data && NULL != p_mask)
+ if (data_len != mask_len && NULL != p_data && NULL != p_mask)
return BT_STATUS_PARM_INVALID;
btif_filt_cb.client_if = client_if;
btif_filt_cb.filt_type = filt_type;
btif_filt_cb.conn_id = company_id;
btif_filt_cb.company_id_mask = company_id_mask ? company_id_mask : 0xFFFF;
- if(bd_addr)
- bdcpy(btif_filt_cb.bd_addr.address, bd_addr->address);
+ if (bd_addr)
+ bdcpy(btif_filt_cb.bd_addr.address, bd_addr->address);
btif_filt_cb.addr_type = addr_type;
btif_filt_cb.has_mask = (p_uuid_mask != NULL);
btgatt_adv_filter_cb_t btif_filt_cb;
btif_filt_cb.client_if = client_if;
- if(true == enable)
+ if (true == enable)
action = 1;
btif_filt_cb.action = action;
return btif_transfer_context(btgattc_handle_event, BTIF_GATTC_SCAN_FILTER_ENABLE,
btgatt_multi_adv_common_data *btif_obtain_multi_adv_data_cb()
{
- if(p_multi_adv_com_data_cb == NULL)
- p_multi_adv_com_data_cb = GKI_getbuf(sizeof(btgatt_multi_adv_common_data));
+ if(0 == BTM_BleMaxMultiAdvInstanceCount())
+ {
+ BTIF_TRACE_WARNING("%s - No instances found", __FUNCTION__);
+ return NULL;
+ }
+
+ BTIF_TRACE_DEBUG("%s, Count:%d", __FUNCTION__, BTM_BleMaxMultiAdvInstanceCount());
+ if (NULL == p_multi_adv_com_data_cb)
+ {
+ BTIF_TRACE_DEBUG("Initializing in %s", __FUNCTION__);
+ p_multi_adv_com_data_cb = GKI_getbuf(sizeof(btgatt_multi_adv_common_data));
+ if (NULL != p_multi_adv_com_data_cb)
+ {
+ memset(p_multi_adv_com_data_cb, 0, sizeof(btgatt_multi_adv_common_data));
+
+ /* Storing both client_if and inst_id details */
+ p_multi_adv_com_data_cb->clntif_map =
+ GKI_getbuf(( BTM_BleMaxMultiAdvInstanceCount() * INST_ID_IDX_MAX)* sizeof(INT8));
+ memset(p_multi_adv_com_data_cb->clntif_map, 0 ,
+ ( BTM_BleMaxMultiAdvInstanceCount() * INST_ID_IDX_MAX)* sizeof(INT8));
+
+ p_multi_adv_com_data_cb->inst_cb = GKI_getbuf(( BTM_BleMaxMultiAdvInstanceCount() + 1 )
+ * sizeof(btgatt_multi_adv_inst_cb));
+ memset(p_multi_adv_com_data_cb->inst_cb, 0 ,
+ ( BTM_BleMaxMultiAdvInstanceCount() + 1) * sizeof(btgatt_multi_adv_inst_cb));
+ }
+ }
+
return p_multi_adv_com_data_cb;
}
int i;
btgatt_multi_adv_common_data *p_multi_adv_data_cb = btif_obtain_multi_adv_data_cb();
- if(NULL == p_multi_adv_data_cb)
+ if (NULL == p_multi_adv_data_cb)
return;
- if(multi_adv_enable_count == 0)
+ if (0 == multi_adv_enable_count)
{
- memset(p_multi_adv_data_cb,0,sizeof(btgatt_multi_adv_common_data));
-
- for (i=0; i < BTM_BLE_MULTI_ADV_MAX; i++)
+ for (i=0; i < BTM_BleMaxMultiAdvInstanceCount(); i++)
{
- p_multi_adv_data_cb->clntif_map[i][CLNT_IF_IDX] = INVALID_ADV_INST;
- p_multi_adv_data_cb->clntif_map[i][INST_ID_IDX] = INVALID_ADV_INST;
+ p_multi_adv_data_cb->clntif_map[i + i] = INVALID_ADV_INST;
+ p_multi_adv_data_cb->clntif_map[i + (i + 1)] = INVALID_ADV_INST;
}
}
multi_adv_enable_count++;
void btif_gattc_destroy_multi_adv_cb()
{
- if(multi_adv_enable_count > 0)
+ if (multi_adv_enable_count > 0)
multi_adv_enable_count --;
- if(multi_adv_enable_count == 0)
+
+ if (0 == multi_adv_enable_count)
{
- GKI_freebuf(p_multi_adv_com_data_cb);
- p_multi_adv_com_data_cb = NULL;
+ if (NULL != p_multi_adv_com_data_cb)
+ {
+ GKI_freebuf (p_multi_adv_com_data_cb->clntif_map);
+ GKI_freebuf (p_multi_adv_com_data_cb->inst_cb);
+ GKI_freebuf(p_multi_adv_com_data_cb);
+ p_multi_adv_com_data_cb = NULL;
+ }
}
}
int btif_multi_adv_add_instid_map(int client_if, int inst_id, BOOLEAN gen_temp_instid)
{
- int i=0;
+ int i=1;
btgatt_multi_adv_common_data *p_multi_adv_data_cb = btif_obtain_multi_adv_data_cb();
- if(NULL == p_multi_adv_data_cb)
+ if (NULL == p_multi_adv_data_cb)
return INVALID_ADV_INST;
- for(i=0; i < BTM_BLE_MULTI_ADV_MAX; i++)
+ for (i=1; i < BTM_BleMaxMultiAdvInstanceCount(); i++)
{
- if(client_if == p_multi_adv_data_cb->clntif_map[i][CLNT_IF_IDX])
+ if (client_if == p_multi_adv_data_cb->clntif_map[i + i])
{
- if(!gen_temp_instid)
+ if (!gen_temp_instid)
{
// Write the final inst_id value obtained from stack layer
- p_multi_adv_data_cb->clntif_map[i][INST_ID_IDX] = inst_id;
+ p_multi_adv_data_cb->clntif_map[i + (i + 1)] = inst_id;
BTIF_TRACE_DEBUG("%s -Index: %d, Found client_if: %d", __FUNCTION__,
- i, p_multi_adv_data_cb->clntif_map[i][CLNT_IF_IDX]);
+ i, p_multi_adv_data_cb->clntif_map[i + i]);
break;
}
else
{
//Store the passed in inst_id value
- if(inst_id != INVALID_ADV_INST)
- p_multi_adv_data_cb->clntif_map[i][INST_ID_IDX] = inst_id;
+ if (inst_id != INVALID_ADV_INST)
+ p_multi_adv_data_cb->clntif_map[i + (i + 1)] = inst_id;
else
- p_multi_adv_data_cb->clntif_map[i][INST_ID_IDX] = (i + 1);
+ p_multi_adv_data_cb->clntif_map[i + (i + 1)] = (i + 1);
+
BTIF_TRACE_DEBUG("%s - Index:%d,Found client_if: %d", __FUNCTION__,
- i, p_multi_adv_data_cb->clntif_map[i][CLNT_IF_IDX]);
+ i, p_multi_adv_data_cb->clntif_map[i + i]);
break;
}
}
}
- if(i < BTM_BLE_MULTI_ADV_MAX)
+ if (i < BTM_BleMaxMultiAdvInstanceCount())
return i;
// If client ID if is not found, then write both values
- for(i=0; i < BTM_BLE_MULTI_ADV_MAX; i++)
+ for (i=1; i < BTM_BleMaxMultiAdvInstanceCount(); i++)
{
- if(INVALID_ADV_INST == p_multi_adv_data_cb->clntif_map[i][CLNT_IF_IDX])
+ if (INVALID_ADV_INST == p_multi_adv_data_cb->clntif_map[i + i])
{
- p_multi_adv_data_cb->clntif_map[i][CLNT_IF_IDX] = client_if;
- if(inst_id != INVALID_ADV_INST)
- p_multi_adv_data_cb->clntif_map[i][INST_ID_IDX] = inst_id;
- else
- p_multi_adv_data_cb->clntif_map[i][INST_ID_IDX] = (i + 1);
- BTIF_TRACE_DEBUG("%s -Not found - Index:%d, client_if: %d, Inst ID: %d",
+ p_multi_adv_data_cb->clntif_map[i + i] = client_if;
+ if (inst_id != INVALID_ADV_INST)
+ p_multi_adv_data_cb->clntif_map[i + (i + 1)] = inst_id;
+ else
+ p_multi_adv_data_cb->clntif_map[i + (i + 1)] = (i + 1);
+ BTIF_TRACE_DEBUG("%s -Not found - Index:%d, client_if: %d, Inst ID: %d",
__FUNCTION__,i,
- p_multi_adv_data_cb->clntif_map[i][CLNT_IF_IDX],
- p_multi_adv_data_cb->clntif_map[i][INST_ID_IDX]);
- break;
+ p_multi_adv_data_cb->clntif_map[i + i],
+ p_multi_adv_data_cb->clntif_map[i + (i + 1)]);
+ break;
}
}
- if(i < BTM_BLE_MULTI_ADV_MAX)
+ if (i < BTM_BleMaxMultiAdvInstanceCount())
return i;
return INVALID_ADV_INST;
}
int btif_multi_adv_instid_for_clientif(int client_if)
{
- int i=0, ret = INVALID_ADV_INST;
+ int i=1, ret = INVALID_ADV_INST;
btgatt_multi_adv_common_data *p_multi_adv_data_cb = btif_obtain_multi_adv_data_cb();
- if(NULL == p_multi_adv_data_cb)
+ if (NULL == p_multi_adv_data_cb)
return INVALID_ADV_INST;
// Retrieve the existing inst_id for the client_if value
- for(i=0; i < BTM_BLE_MULTI_ADV_MAX; i++)
+ for (i=1; i < BTM_BleMaxMultiAdvInstanceCount(); i++)
{
- if(client_if == p_multi_adv_data_cb->clntif_map[i][CLNT_IF_IDX])
- ret = p_multi_adv_data_cb->clntif_map[i][INST_ID_IDX];
+ if (client_if == p_multi_adv_data_cb->clntif_map[i + i])
+ {
+ BTIF_TRACE_DEBUG("%s - Client if found", __FUNCTION__, client_if);
+ ret = p_multi_adv_data_cb->clntif_map[i + (i + 1)];
+ }
}
- if(ret != INVALID_ADV_INST)
- return ret;
-
- return INVALID_ADV_INST;
+ return ret;
}
-
-int btif_gattc_obtain_idx_for_datacb(int value, int arrindex)
+int btif_gattc_obtain_idx_for_datacb(int value, int clnt_inst_index)
{
- int i=0;
+ int i=1;
btgatt_multi_adv_common_data *p_multi_adv_data_cb = btif_obtain_multi_adv_data_cb();
- if(NULL == p_multi_adv_data_cb)
+ if (NULL == p_multi_adv_data_cb)
return INVALID_ADV_INST;
// Retrieve the array index for the inst_id value
- for(i=0; i < BTM_BLE_MULTI_ADV_MAX; i++)
+ for (i=1; i < BTM_BleMaxMultiAdvInstanceCount(); i++)
{
- if(value == p_multi_adv_data_cb->clntif_map[i][arrindex])
+ if (value == p_multi_adv_data_cb->clntif_map[i + (i + clnt_inst_index)])
break;
}
- if(i < BTM_BLE_MULTI_ADV_MAX)
+ if (i < BTM_BleMaxMultiAdvInstanceCount())
{
- BTIF_TRACE_DEBUG("%s, %d",__FUNCTION__,i+1);
- return (i + 1);
+ BTIF_TRACE_DEBUG("%s, %d",__FUNCTION__,i);
+ return i;
}
BTIF_TRACE_DEBUG("%s Invalid instance",__FUNCTION__);
p_multi_adv_inst->appearance = appearance;
p_multi_adv_inst->manufacturer_len = manufacturer_len;
- if(manufacturer_len > 0)
+ if (manufacturer_len > 0)
{
p_multi_adv_inst->p_manufacturer_data = GKI_getbuf(manufacturer_len);
memcpy(p_multi_adv_inst->p_manufacturer_data, manufacturer_data, manufacturer_len);
}
p_multi_adv_inst->service_data_len = service_data_len;
- if(service_data_len > 0)
+ if (service_data_len > 0)
{
p_multi_adv_inst->p_service_data = GKI_getbuf(service_data_len);
memcpy(p_multi_adv_inst->p_service_data, service_data, service_data_len);
}
p_multi_adv_inst->service_uuid_len = service_uuid_len;
- if(service_uuid_len > 0)
+ if (service_uuid_len > 0)
{
p_multi_adv_inst->p_service_uuid = GKI_getbuf(service_uuid_len);
memcpy(p_multi_adv_inst->p_service_uuid, service_uuid, service_uuid_len);
{
int i=0;
btgatt_multi_adv_common_data *p_multi_adv_data_cb = btif_obtain_multi_adv_data_cb();
- if(NULL == p_multi_adv_data_cb || cbindex < 0)
+ if (NULL == p_multi_adv_data_cb || cbindex < 0)
return false;
BTIF_TRACE_DEBUG("%s", __FUNCTION__);
p_adv_data->max_interval;
}
else
- if(true == bInstData)
+ if (true == bInstData)
{
if (p_multi_adv_data_cb->inst_cb[cbindex].param.adv_int_min > 0 &&
p_multi_adv_data_cb->inst_cb[cbindex].param.adv_int_max > 0 &&
{
p_multi_adv_data_cb->inst_cb[cbindex].data.p_manu =
GKI_getbuf(sizeof(tBTA_BLE_MANU));
- if(p_multi_adv_data_cb->inst_cb[cbindex].data.p_manu != NULL)
+ if (p_multi_adv_data_cb->inst_cb[cbindex].data.p_manu != NULL)
{
p_multi_adv_data_cb->inst_cb[cbindex].data.p_manu->p_val =
GKI_getbuf(p_adv_data->manufacturer_len);
btgatt_multi_adv_common_data *p_multi_adv_data_cb = btif_obtain_multi_adv_data_cb();
- if(NULL == p_multi_adv_data_cb)
+ if (NULL == p_multi_adv_data_cb)
return;
// Clear both the inst_id and client_if values
- for(i=0; i < BTM_BLE_MULTI_ADV_MAX; i++)
+ for (i=0; i < BTM_BleMaxMultiAdvInstanceCount(); i++)
{
- if(client_if == p_multi_adv_data_cb->clntif_map[i][CLNT_IF_IDX])
+ if (client_if == p_multi_adv_data_cb->clntif_map[i + i])
{
- p_multi_adv_data_cb->clntif_map[i][INST_ID_IDX] = INVALID_ADV_INST;
- p_multi_adv_data_cb->clntif_map[i][CLNT_IF_IDX] = INVALID_ADV_INST;
+ p_multi_adv_data_cb->clntif_map[i + (i + 1)] = INVALID_ADV_INST;
+ p_multi_adv_data_cb->clntif_map[i + i] = INVALID_ADV_INST;
BTIF_TRACE_DEBUG("Cleaning up index %d for clnt_if :%d,", i, client_if);
break;
}
{
int cbindex = 0;
// Check for invalid instance id
- if (inst_id < 0 || inst_id > BTM_BLE_MULTI_ADV_MAX)
+ if (inst_id < 0 || inst_id >= BTM_BleMaxMultiAdvInstanceCount())
return;
btgatt_multi_adv_common_data *p_multi_adv_data_cb = btif_obtain_multi_adv_data_cb();
- if(NULL == p_multi_adv_data_cb)
+ if (NULL == p_multi_adv_data_cb)
return;
- if(inst_id > 0)
+ if (inst_id > 0)
{
cbindex = btif_gattc_obtain_idx_for_datacb(inst_id, INST_ID_IDX);
if (cbindex < 0)
return;
}
else
- if(STD_ADV_INSTID == inst_id)
- cbindex = STD_ADV_INSTID;
+ if (STD_ADV_INSTID == inst_id)
+ cbindex = STD_ADV_INSTID;
BTIF_TRACE_DEBUG("Cleaning up multi_inst_cb for inst_id %d, cbindex %d", inst_id, cbindex);
btif_gattc_cleanup_multi_inst_cb(&p_multi_adv_data_cb->inst_cb[cbindex]);
GKI_freebuf(p_multi_inst_cb->data.p_sol_service_32b);
}
- if(p_multi_inst_cb->data.p_sol_service_128b != NULL)
+ if (p_multi_inst_cb->data.p_sol_service_128b != NULL)
GKI_freebuf(p_multi_inst_cb->data.p_sol_service_128b);
}
#define BLE_PRIVACY_SPT TRUE
#endif
-#ifndef BLE_MULTI_ADV_INCLUDED
-#define BLE_MULTI_ADV_INCLUDED TRUE
-#endif
-
#ifndef BLE_VND_INCLUDED
-#define BLE_VND_INCLUDED TRUE
+#define BLE_VND_INCLUDED FALSE
#endif
-
-#ifndef BLE_BATCH_SCAN_INCLUDED
-#define BLE_BATCH_SCAN_INCLUDED TRUE
-#endif
-
/******************************************************************************
**
** ATT/GATT Protocol/Profile Settings
/******************************************************************************
*
- * This module contains the routines that initialize the stack components.
+ * This module contains the routines that initialize the stack components.
* It must be called before the BTU task is started.
*
******************************************************************************/
p->transport = transport;
if (transport == BT_TRANSPORT_LE)
{
-#if ( BLE_PRIVACY_SPT == TRUE )
/*allow central device to use random address for now by skipping the role check */
if (btm_cb.ble_ctr_cb.privacy /* && p->link_role == HCI_ROLE_SLAVE */)
{
memcpy(p->conn_addr, btm_cb.ble_ctr_cb.addr_mgnt_cb.private_addr, BD_ADDR_LEN);
}
else
-#endif
{
p->conn_addr_type = BLE_ADDR_PUBLIC;
BTM_GetLocalDeviceAddr(p->conn_addr);
#include "gap_api.h"
#include "bt_utils.h"
-#if (defined BLE_VND_INCLUDED && BLE_VND_INCLUDED == TRUE)
#include "vendor_ble.h"
-#endif
#if SMP_INCLUDED == TRUE
extern BOOLEAN AES_CMAC ( BT_OCTET16 key, UINT8 *input, UINT16 length, UINT16 tlen, UINT8 *p_signature);
extern BOOLEAN smp_proc_ltk_request(BD_ADDR bda);
#endif
extern void gatt_notify_enc_cmpl(BD_ADDR bd_addr);
-
/*******************************************************************************/
/* External Function to be called by other modules */
/*******************************************************************************/
if (p_dev_rec->ble.ble_addr_type == BLE_ADDR_RANDOM && !addr_matched)
memcpy(p_dev_rec->ble.cur_rand_addr, bda, BD_ADDR_LEN);
-#if (defined BLE_VND_INCLUDED && BLE_VND_INCLUDED == TRUE)
- btm_ble_vendor_disable_irk_list();
-#endif
+ if (btm_cb.cmn_ble_vsc_cb.rpa_offloading == TRUE)
+ btm_ble_vendor_disable_irk_list();
#endif
if (role == HCI_ROLE_SLAVE)
if (status == 0)
{
#if (BLE_PRIVACY_SPT == TRUE )
-#if (BLE_VND_INCLUDED == TRUE)
- match = btm_public_addr_to_random_pseudo (bda, &bda_type);
-#endif
- /* Possibly receiving connection complete with a resolvable random address
- for a device that has been paired */
- if (!match && BTM_BLE_IS_RESOLVE_BDA(bda))
+
+ if (btm_cb.cmn_ble_vsc_cb.rpa_offloading == TRUE)
+ match = btm_public_addr_to_random_pseudo (bda, &bda_type);
+
+ /* possiblly receive connection complete with resolvable random on
+ slave role while the device has been paired */
+ if (!match && role == HCI_ROLE_SLAVE && BTM_BLE_IS_RESOLVE_BDA(bda))
{
btm_ble_resolve_random_addr(bda, btm_ble_resolve_random_addr_on_conn_cmpl, p_data);
}
#include "btm_ble_int.h"
#include "smp_api.h"
-#if (defined BLE_VND_INCLUDED && BLE_VND_INCLUDED == TRUE)
#include "vendor_ble.h"
-#endif
/*******************************************************************************
**
/* atch found or went through the list */
break;
}
- p_mgnt_cb->index ++;
+ p_mgnt_cb->index ++;
}
}
else
return BLE_ADDR_PUBLIC;
}
-#if BLE_PRIVACY_SPT == TRUE
-#if (defined BLE_VND_INCLUDED && BLE_VND_INCLUDED == TRUE)
/*******************************************************************************
**
** Function btm_find_dev_by_public_static_addr
{
UINT8 i;
tBTM_SEC_DEV_REC *p_dev_rec = &btm_cb.sec_dev_rec[0];
-
+#if BLE_PRIVACY_SPT == TRUE
for (i = 0; i < BTM_SEC_MAX_DEVICE_RECORDS; i ++, p_dev_rec ++)
{
if (p_dev_rec->ble.ble_addr_type == BLE_ADDR_RANDOM &&
}
}
}
+#endif
return NULL;
}
*******************************************************************************/
BOOLEAN btm_public_addr_to_random_pseudo(BD_ADDR bd_addr, UINT8 *p_addr_type)
{
+#if BLE_PRIVACY_SPT == TRUE
tBTM_SEC_DEV_REC *p_dev_rec = btm_find_dev_by_public_static_addr(bd_addr);
BTM_TRACE_EVENT ("btm_public_addr_to_random_pseudo");
return TRUE;
}
-
+#endif
return FALSE;
}
*******************************************************************************/
BOOLEAN btm_random_pseudo_to_public(BD_ADDR random_pseudo, UINT8 *p_static_addr_type)
{
+#if BLE_PRIVACY_SPT == TRUE
tBTM_SEC_DEV_REC *p_dev_rec = btm_find_dev (random_pseudo);
if (p_dev_rec != NULL)
return TRUE;
}
}
-
+#endif
return FALSE;
}
*******************************************************************************/
void btm_ble_refresh_rra(BD_ADDR static_bda, BD_ADDR rra)
{
+#if BLE_PRIVACY_SPT == TRUE
tBTM_SEC_DEV_REC *p_sec_rec = btm_find_dev_by_public_static_addr(static_bda);
tACL_CONN *p_acl = btm_bda_to_acl (p_sec_rec->bd_addr, BT_TRANSPORT_LE);
UINT8 rra_dummy = FALSE;
{
BTM_TRACE_ERROR("No matching known device in record");
}
-
+#endif
}
-#endif /* CS support */
-#endif /* privacy support */
#endif
#include "bt_target.h"
#if (BLE_INCLUDED == TRUE)
-#if BLE_BATCH_SCAN_INCLUDED == TRUE
#include "bt_types.h"
#include "hcimsgs.h"
#include "btu.h"
#define BTM_BLE_ADV_FILT_CB_EVT_MASK 0xF0
#define BTM_BLE_ADV_FILT_SUBCODE_MASK 0x0F
+/*******************************************************************************
+**
+** Function btm_ble_obtain_vsc_details
+**
+** Description This function obtains the VSC details
+**
+** Parameters
+**
+** Returns status
+**
+*******************************************************************************/
+tBTM_STATUS btm_ble_obtain_vsc_details()
+{
+ tBTM_STATUS st = BTM_SUCCESS;
+
+#if BLE_VND_INCLUDED == TRUE
+ BTM_BleGetVendorCapabilities(&cmn_ble_vsc_cb);
+ if (0 == cmn_ble_vsc_cb.max_filter)
+ {
+ st = BTM_MODE_UNSUPPORTED;
+ return st;
+ }
+#else
+ cmn_ble_vsc_cb.max_filter = BTM_BLE_MAX_FILTER_COUNTER;
+#endif
+ return st;
+}
/*******************************************************************************
**
STREAM_TO_UINT8(action, p);
/* Ignore the event, if it is not the same one expected */
- if(3 == evt_len)
+ if (3 == evt_len)
{
if(ocf != op_subcode)
{
tBTM_BLE_PF_COUNT* btm_ble_find_addr_filter_counter(tBLE_BD_ADDR *p_le_bda)
{
UINT8 i;
- tBTM_BLE_PF_COUNT *p_addr_filter = &btm_ble_adv_filt_cb.addr_filter_count[1];
+ tBTM_BLE_PF_COUNT *p_addr_filter = &btm_ble_adv_filt_cb.p_addr_filter_count[1];
if (p_le_bda == NULL)
- return &btm_ble_adv_filt_cb.addr_filter_count[0];
+ return &btm_ble_adv_filt_cb.p_addr_filter_count[0];
for (i = 0; i < cmn_ble_vsc_cb.max_filter; i ++, p_addr_filter ++)
{
tBTM_BLE_PF_COUNT * btm_ble_alloc_addr_filter_counter(BD_ADDR bd_addr)
{
UINT8 i;
- tBTM_BLE_PF_COUNT *p_addr_filter = &btm_ble_adv_filt_cb.addr_filter_count[1];
+ tBTM_BLE_PF_COUNT *p_addr_filter = &btm_ble_adv_filt_cb.p_addr_filter_count[1];
for (i = 0; i < cmn_ble_vsc_cb.max_filter; i ++, p_addr_filter ++)
{
BOOLEAN btm_ble_dealloc_addr_filter_counter(tBLE_BD_ADDR *p_bd_addr, UINT8 filter_type)
{
UINT8 i;
- tBTM_BLE_PF_COUNT *p_addr_filter = &btm_ble_adv_filt_cb.addr_filter_count[1];
+ tBTM_BLE_PF_COUNT *p_addr_filter = &btm_ble_adv_filt_cb.p_addr_filter_count[1];
BOOLEAN found = FALSE;
if (BTM_BLE_PF_TYPE_ALL == filter_type && NULL == p_bd_addr)
- memset(&btm_ble_adv_filt_cb.addr_filter_count[0], 0, sizeof(tBTM_BLE_PF_COUNT));
+ memset(&btm_ble_adv_filt_cb.p_addr_filter_count[0], 0, sizeof(tBTM_BLE_PF_COUNT));
for (i = 0; i < cmn_ble_vsc_cb.max_filter; i ++, p_addr_filter ++)
{
len = BTM_BLE_ADV_FILT_META_HDR_LENGTH;
tBTM_STATUS st = BTM_ILLEGAL_VALUE;
- if(NULL!= p_data && 0 == p_data->manu_data.data_len && 0 == p_data->srvc_data.data_len)
+ if (NULL!= p_data && 0 == p_data->manu_data.data_len && 0 == p_data->srvc_data.data_len)
return st;
memset(param, 0, BTM_BLE_PF_STR_LEN_MAX + BTM_BLE_PF_STR_LEN_MAX
if (p_srvc_data->data_len > (BTM_BLE_PF_STR_LEN_MAX - 2))
p_srvc_data->data_len = (BTM_BLE_PF_STR_LEN_MAX - 2);
- if(p_srvc_data->data_len > 0)
+ if (p_srvc_data->data_len > 0)
{
ARRAY_TO_STREAM(p, p_srvc_data->p_pattern, p_srvc_data->data_len);
len += (p_srvc_data->data_len);
UINT16_TO_STREAM(p, p_manu_data->company_id);
- if(p_manu_data->data_len > 0)
+ if (p_manu_data->data_len > 0)
ARRAY_TO_STREAM(p, p_manu_data->p_pattern, p_manu_data->data_len);
len += (p_manu_data->data_len + 2);
p += 2;
}
- if(p_manu_data->data_len > 0)
+ if (p_manu_data->data_len > 0)
ARRAY_TO_STREAM(p, p_manu_data->p_pattern_mask, p_manu_data->data_len);
len += (p_manu_data->data_len + 2);
tBTM_BLE_PF_COUNT *p_addr_filter = NULL;
UINT8 *p_counter = NULL;
- BTM_BleGetVendorCapabilities(&cmn_ble_vsc_cb);
+ btm_ble_obtain_vsc_details();
if (cond_type > BTM_BLE_PF_TYPE_ALL)
{
else if (cond_type != BTM_BLE_PF_TYPE_ALL)
{
p_counter = p_addr_filter->pf_counter;
- if(num_available > 0)
- p_counter[cond_type] += 1;
-
- /* update corresponding feature mask */
if (num_available > 0)
- p_addr_filter->feat_mask |= (BTM_BLE_PF_BIT_TO_MASK(cond_type));
- else
- p_addr_filter->feat_mask &= ~(BTM_BLE_PF_BIT_TO_MASK(cond_type));
+ p_counter[cond_type] += 1;
- BTM_TRACE_DEBUG("counter = %d, maxfilt = %d, num_avbl=%d, feat_mask = %d",
- p_counter[cond_type], cmn_ble_vsc_cb.max_filter, num_available,
- p_addr_filter->feat_mask);
+ BTM_TRACE_DEBUG("counter = %d, maxfilt = %d, num_avbl=%d",
+ p_counter[cond_type], cmn_ble_vsc_cb.max_filter, num_available);
return p_counter[cond_type];
}
}
p_bda_filter = btm_ble_find_addr_filter_counter(p_target);
if (NULL == p_bda_filter ||
- /* not a generic filter, and feature selection is empty */
- (p_target != NULL && p_bda_filter && 0 == p_bda_filter->feat_mask))
+ /* not a generic filter */
+ (p_target != NULL && p_bda_filter))
{
BTM_TRACE_ERROR("Error: Can not clear filter, No PF filter has been configured!");
return st;
btm_ble_scan_pf_cmpl_cback))
!= BTM_NO_RESOURCES)
{
- if (p_bda_filter)
- p_bda_filter->feat_mask = BTM_BLE_PF_SELECT_NONE;
-
if (p_target)
memcpy(&btm_ble_adv_filt_cb.cur_filter_target, p_target, sizeof(tBLE_BD_ADDR));
else
tBTM_BLE_PF_COUNT *p_bda_filter = NULL;
UINT8 len =0;
+ if (BTM_SUCCESS != btm_ble_obtain_vsc_details())
+ return st;
+
p = param;
memset(param, 0, 20);
BTM_TRACE_EVENT (" BTM_BleAdvFilterParamSetup");
- BTM_BleGetVendorCapabilities(&cmn_ble_vsc_cb);
- if (0 == cmn_ble_vsc_cb.max_filter)
- {
- st = BTM_MODE_UNSUPPORTED;
- return st;
- }
-
if (BTM_BLE_SCAN_COND_ADD == action)
{
p_bda_filter = btm_ble_find_addr_filter_counter(p_target);
return st;
}
- BTM_TRACE_DEBUG("BTM_BleAdvFilterParamSetup : Feat mask:%d", p_bda_filter->feat_mask);
+ BTM_TRACE_DEBUG("BTM_BleAdvFilterParamSetup : Feat mask:%d", p_filt_params->feat_seln);
/* select feature based on control block settings */
UINT8_TO_STREAM(p, BTM_BLE_META_PF_FEAT_SEL);
UINT8_TO_STREAM(p, BTM_BLE_SCAN_COND_ADD);
/* set delivery mode */
UINT8_TO_STREAM(p, p_filt_params->dely_mode);
- if(0x01 == p_filt_params->dely_mode)
+ if (0x01 == p_filt_params->dely_mode)
{
/* set onfound timeout */
UINT16_TO_STREAM(p, p_filt_params->found_timeout);
ref_value, NULL, p_cmpl_cback);
}
else
- if(BTM_BLE_SCAN_COND_DELETE == action)
+ if (BTM_BLE_SCAN_COND_DELETE == action)
{
/* select feature based on control block settings */
UINT8_TO_STREAM(p, BTM_BLE_META_PF_FEAT_SEL);
ref_value, NULL, p_cmpl_cback);
}
else
- if(BTM_BLE_SCAN_COND_CLEAR == action)
+ if (BTM_BLE_SCAN_COND_CLEAR == action)
{
/* Deallocate all filters here */
btm_ble_dealloc_addr_filter_counter(NULL, BTM_BLE_PF_TYPE_ALL);
UINT8 param[20], *p;
tBTM_STATUS st = BTM_WRONG_MODE;
- BTM_BleGetVendorCapabilities(&cmn_ble_vsc_cb);
- if (0 == cmn_ble_vsc_cb.max_filter)
- {
- st = BTM_MODE_UNSUPPORTED;
- return st;
- }
+ if (BTM_SUCCESS != btm_ble_obtain_vsc_details())
+ return st;
p = param;
memset(param, 0, 20);
BTM_TRACE_EVENT (" BTM_BleCfgFilterCondition action:%d, cond_type:%d, index:%d", action,
cond_type, filt_index);
- BTM_BleGetVendorCapabilities(&cmn_ble_vsc_cb);
- if (0 == cmn_ble_vsc_cb.max_filter)
- {
- st = BTM_MODE_UNSUPPORTED;
+ if (BTM_SUCCESS != btm_ble_obtain_vsc_details())
return st;
- }
switch (cond_type)
{
void btm_ble_adv_filter_init(void)
{
memset(&btm_ble_adv_filt_cb, 0, sizeof(tBTM_BLE_MULTI_ADV_CB));
+ if (BTM_SUCCESS != btm_ble_obtain_vsc_details())
+ return;
+
+ if (cmn_ble_vsc_cb.max_filter > 0)
+ {
+ btm_ble_adv_filt_cb.p_addr_filter_count =
+ (tBTM_BLE_PF_COUNT*) GKI_getbuf( sizeof(tBTM_BLE_PF_COUNT) * cmn_ble_vsc_cb.max_filter);
+ }
+
if (!HCI_LE_HOST_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_1]))
return;
}
-#endif
+/*******************************************************************************
+**
+** Function btm_ble_adv_filter_cleanup
+**
+** Description This function de-initializes the adv filter control block
+**
+** Parameters
+**
+** Returns status
+**
+*******************************************************************************/
+void btm_ble_adv_filter_cleanup(void)
+{
+ if (btm_ble_adv_filt_cb.p_addr_filter_count)
+ GKI_freebuf (btm_ble_adv_filt_cb.p_addr_filter_count);
+}
+
#endif
#include "btm_int.h"
#include "hcimsgs.h"
-#if (BLE_INCLUDED == TRUE && BLE_BATCH_SCAN_INCLUDED == TRUE)
+#if (BLE_INCLUDED == TRUE)
tBTM_BLE_BATCH_SCAN_CB ble_batchscan_cb;
tBTM_BLE_ADV_TRACK_CB ble_advtrack_cb;
{
case BTM_BLE_BATCH_SCAN_ENB_DISAB_CUST_FEATURE:
{
- if (BTM_SUCCESS == status && BTM_BLE_SCAN_ENABLE_CALLED == cur_state)
- ble_batchscan_cb.cur_state = BTM_BLE_SCAN_ENABLED_STATE;
- else
- if (BTM_BLE_SCAN_ENABLE_CALLED == cur_state)
- {
- BTM_TRACE_ERROR("SCAN_ENB_DISAB_CUST_FEATURE - Invalid state after enb");
- ble_batchscan_cb.cur_state = BTM_BLE_SCAN_INVALID_STATE;
- }
-
- if (BTM_SUCCESS == status && BTM_BLE_SCAN_DISABLE_CALLED == cur_state)
- ble_batchscan_cb.cur_state = BTM_BLE_SCAN_DISABLED_STATE;
- else
- if (BTM_BLE_SCAN_DISABLE_CALLED == cur_state)
- {
- BTM_TRACE_ERROR("SCAN_ENB_DISAB_CUST_FEATURE - Invalid state after disabled");
+ if (BTM_SUCCESS == status && BTM_BLE_SCAN_ENABLE_CALLED == cur_state)
+ ble_batchscan_cb.cur_state = BTM_BLE_SCAN_ENABLED_STATE;
+ else
+ if (BTM_BLE_SCAN_ENABLE_CALLED == cur_state)
+ {
+ BTM_TRACE_ERROR("SCAN_ENB_DISAB_CUST_FEATURE - Invalid state after enb");
ble_batchscan_cb.cur_state = BTM_BLE_SCAN_INVALID_STATE;
- }
- BTM_TRACE_DEBUG("BTM_BLE_BATCH_SCAN_ENB_DISAB_CUST_FEAT status = %d, state: %d,evt=%d",
- status, ble_batchscan_cb.cur_state, cb_evt);
+ }
- /* Clear the queues here */
- if(BTM_SUCCESS == status && BTM_BLE_SCAN_DISABLE_CALLED == cur_state)
- {
- for (index = 0; index < BTM_BLE_BATCH_REP_MAIN_Q_SIZE; index++)
- {
- ble_batchscan_cb.main_rep_q.rep_mode[index] = 0;
- if (NULL != ble_batchscan_cb.main_rep_q.p_data[index])
- GKI_freebuf(ble_batchscan_cb.main_rep_q.p_data[index]);
- ble_batchscan_cb.main_rep_q.p_data[index] = NULL;
- ble_batchscan_cb.main_rep_q.ref_value[index] = 0;
- ble_batchscan_cb.main_rep_q.num_records[index] = 0;
- }
-
- for (index = 0; index < BTM_BLE_BATCH_SCAN_MAX; index++)
- {
- ble_batchscan_cb.op_q.sub_code[index] = 0;
- ble_batchscan_cb.op_q.ref_value[index] = 0;
- ble_batchscan_cb.op_q.cur_state[index] = 0;
- }
- ble_batchscan_cb.op_q.pending_idx = 0;
- ble_batchscan_cb.op_q.next_idx = 0;
- }
-
- if (cb_evt != 0 && NULL != ble_batchscan_cb.p_setup_cback)
+ if (BTM_SUCCESS == status && BTM_BLE_SCAN_DISABLE_CALLED == cur_state)
+ ble_batchscan_cb.cur_state = BTM_BLE_SCAN_DISABLED_STATE;
+ else
+ if (BTM_BLE_SCAN_DISABLE_CALLED == cur_state)
+ {
+ BTM_TRACE_ERROR("SCAN_ENB_DISAB_CUST_FEATURE - Invalid state after disabled");
+ ble_batchscan_cb.cur_state = BTM_BLE_SCAN_INVALID_STATE;
+ }
+ BTM_TRACE_DEBUG("BTM_BLE_BATCH_SCAN_ENB_DISAB_CUST_FEAT status = %d, state: %d,evt=%d",
+ status, ble_batchscan_cb.cur_state, cb_evt);
+ if (cb_evt != 0 && NULL != ble_batchscan_cb.p_setup_cback)
ble_batchscan_cb.p_setup_cback(cb_evt, ref_value, status);
- break;
+ break;
}
case BTM_BLE_BATCH_SCAN_SET_STORAGE_PARAM:
{
BTM_TRACE_DEBUG("BTM_BLE_BATCH_SCAN_SET_PARAMS status = %d,evt=%d", status, cb_evt);
if (cb_evt != 0 && NULL != ble_batchscan_cb.p_setup_cback)
- ble_batchscan_cb.p_setup_cback(cb_evt, ref_value, status);
+ ble_batchscan_cb.p_setup_cback(cb_evt, ref_value, status);
break;
}
BTM_BLE_SCAN_DISABLE_CALLED == ble_batchscan_cb.cur_state)
{
status = btm_ble_enable_disable_batchscan(TRUE);
- if (BTM_CMD_STARTED != status)
- return status;
+ if (BTM_CMD_STARTED != status)
+ return status;
ble_batchscan_cb.cur_state = BTM_BLE_SCAN_ENABLE_CALLED;
btm_ble_batchscan_enq_op_q(BTM_BLE_BATCH_SCAN_ENB_DISAB_CUST_FEATURE,
BTM_BLE_SCAN_ENABLE_CALLED, 0, ref_value);
status = btm_ble_set_storage_config(batch_scan_full_max, batch_scan_trunc_max,
batch_scan_notify_threshold);
if (BTM_CMD_STARTED != status)
- return status;
- /* The user needs to be provided scan config storage event */
+ return status;
+ /* The user needs to be provided scan config storage event */
btm_ble_batchscan_enq_op_q(BTM_BLE_BATCH_SCAN_SET_STORAGE_PARAM, ble_batchscan_cb.cur_state,
BTM_BLE_BATCH_SCAN_CFG_STRG_EVT, ref_value);
|| BTM_BLE_SCAN_DISABLED_STATE == ble_batchscan_cb.cur_state ||
BTM_BLE_SCAN_DISABLE_CALLED == ble_batchscan_cb.cur_state)
{
- status = btm_ble_enable_disable_batchscan(TRUE);
- if (BTM_CMD_STARTED != status)
- return status;
- btm_ble_batchscan_enq_op_q(BTM_BLE_BATCH_SCAN_ENB_DISAB_CUST_FEATURE,
- BTM_BLE_SCAN_ENABLE_CALLED, 0, ref_value);
+ status = btm_ble_enable_disable_batchscan(TRUE);
+ if (BTM_CMD_STARTED != status)
+ return status;
+ btm_ble_batchscan_enq_op_q(BTM_BLE_BATCH_SCAN_ENB_DISAB_CUST_FEATURE,
+ BTM_BLE_SCAN_ENABLE_CALLED, 0, ref_value);
}
ble_batchscan_cb.scan_mode = scan_mode;
/* Check if the requested scan mode has already been setup by the user */
read_scan_mode = ble_batchscan_cb.scan_mode & BTM_BLE_BATCH_SCAN_MODE_ACTI;
if (0 == read_scan_mode)
- read_scan_mode = ble_batchscan_cb.scan_mode & BTM_BLE_BATCH_SCAN_MODE_PASS;
+ read_scan_mode = ble_batchscan_cb.scan_mode & BTM_BLE_BATCH_SCAN_MODE_PASS;
if (read_scan_mode > 0 && (BTM_BLE_BATCH_SCAN_MODE_PASS == scan_mode ||
BTM_BLE_BATCH_SCAN_MODE_ACTI == scan_mode)
&& (BTM_BLE_SCAN_ENABLED_STATE == ble_batchscan_cb.cur_state ||
BTM_BLE_SCAN_ENABLE_CALLED == ble_batchscan_cb.cur_state))
{
- status = btm_ble_batchscan_enq_rep_q(scan_mode, ref_value);
- if (BTM_SUCCESS == status)
+ status = btm_ble_read_batchscan_reports(scan_mode, ref_value);
+ if (BTM_CMD_STARTED == status)
{
- status = btm_ble_read_batchscan_reports(scan_mode, ref_value);
if (BTM_CMD_STARTED != status)
btm_ble_batchscan_deq_rep_data(scan_mode, &ref_value,
&num_records, &p_data, &data_len);
#include "l2c_int.h"
#include "hcimsgs.h"
#include "bt_utils.h"
-#if (defined BLE_VND_INCLUDED && BLE_VND_INCLUDED == TRUE)
#include "vendor_ble.h"
-#endif
#ifndef BTM_BLE_SCAN_PARAM_TOUT
#define BTM_BLE_SCAN_PARAM_TOUT 50 /* 50 seconds */
{
if (p_dev_rec->ble.ble_addr_type == BLE_ADDR_PUBLIC || !BTM_BLE_IS_RESOLVE_BDA(bd_addr))
{
-#if (defined BLE_VND_INCLUDED && BLE_VND_INCLUDED == TRUE)
#if (defined BLE_PRIVACY_SPT && BLE_PRIVACY_SPT == TRUE)
/* add device into IRK list */
btm_ble_vendor_irk_list_load_dev(p_dev_rec);
#endif
-#endif
started = btsnd_hcic_ble_add_white_list (p_dev_rec->ble.ble_addr_type, bd_addr);
}
if (memcmp(p_dev_rec->ble.static_addr, bd_addr, BD_ADDR_LEN) != 0 &&
btsnd_hcic_ble_create_conn_cancel();
btm_ble_set_conn_st (BLE_CONN_CANCEL);
-#if (defined BLE_VND_INCLUDED && BLE_VND_INCLUDED == TRUE)
#if (defined BLE_PRIVACY_SPT && BLE_PRIVACY_SPT == TRUE)
- btm_ble_vendor_disable_irk_list();
-#endif
+ if (btm_cb.cmn_ble_vsc_cb.rpa_offloading == TRUE)
+ btm_ble_vendor_disable_irk_list();
#endif
}
else
p_cb->p_select_cback = NULL;
#if (defined BLE_PRIVACY_SPT && BLE_PRIVACY_SPT == TRUE)
-#if (defined BLE_VND_INCLUDED && BLE_VND_INCLUDED == TRUE)
- btm_ble_vendor_disable_irk_list();
-#endif
+ if (btm_cb.cmn_ble_vsc_cb.rpa_offloading == TRUE)
+ btm_ble_vendor_disable_irk_list();
#endif
/* stop scanning */
#if (GAP_INCLUDED == TRUE)
#include "gap_api.h"
#endif
-#if (BLE_INCLUDED == TRUE)
-#if (defined BLE_VND_INCLUDED && BLE_VND_INCLUDED == TRUE)
+
+#if BLE_INCLUDED == TRUE
+
#include "vendor_ble.h"
-#endif
+
#include "gattdefs.h"
#include "gatt_int.h"
btm_cb.ble_ctr_cb.addr_mgnt_cb.own_addr_type,
BTM_BLE_DEFAULT_SFP); /* assume observe always not using white list */
-#if (defined BLE_VND_INCLUDED && BLE_VND_INCLUDED == TRUE)
#if (defined BLE_PRIVACY_SPT && BLE_PRIVACY_SPT == TRUE)
/* enable IRK list */
btm_ble_vendor_irk_list_known_dev (TRUE);
#endif
-#endif
status = btm_ble_start_scan(BTM_BLE_DUPLICATE_DISABLE);
}
if (status == BTM_CMD_STARTED)
{
#if BLE_VND_INCLUDED == TRUE
UINT8 status = 0xFF, *p;
- UINT8 rpa_offloading, max_irk_list_sz, filtering_support, max_filter;
- UINT16 scan_result_storage;
- tBTM_BLE_VENDOR_CB *p_vcb = &btm_ble_vendor_cb;
- max_irk_list_sz = 0;
BTM_TRACE_DEBUG("btm_ble_vendor_capability_vsc_cmpl_cback");
/* Check status of command complete event */
- if((p_vcs_cplt_params->opcode == HCI_BLE_VENDOR_CAP_OCF)
- &&(p_vcs_cplt_params->param_len > 0 ))
+ if ((p_vcs_cplt_params->opcode == HCI_BLE_VENDOR_CAP_OCF) &&(p_vcs_cplt_params->param_len > 0))
{
p = p_vcs_cplt_params->p_param_buf;
STREAM_TO_UINT8 (status, p);
}
- if(status == HCI_SUCCESS)
+ if (status == HCI_SUCCESS)
{
STREAM_TO_UINT8 (btm_cb.cmn_ble_vsc_cb.adv_inst_max, p);
STREAM_TO_UINT8 (btm_cb.cmn_ble_vsc_cb.rpa_offloading, p);
STREAM_TO_UINT8 (btm_cb.cmn_ble_vsc_cb.energy_support, p);
}
- p_vcb->irk_avail_size = max_irk_list_sz;
+ BTM_TRACE_DEBUG("btm_ble_vnd_cap_vsc_cmpl_cback: stat=%d, irk=%d, ADV ins:%d, rpa=%d, ener=%d",
+ status, btm_ble_vendor_cb.irk_avail_size, btm_cb.cmn_ble_vsc_cb.adv_inst_max,
+ btm_cb.cmn_ble_vsc_cb.rpa_offloading, btm_cb.cmn_ble_vsc_cb.energy_support);
+
+ if (BTM_BleMaxMultiAdvInstanceCount() > 0)
+ btm_ble_multi_adv_init();
+
+ if (btm_cb.cmn_ble_vsc_cb.max_filter > 0)
+ {
+ btm_ble_adv_filter_init();
+ btm_ble_vendor_init(btm_cb.cmn_ble_vsc_cb.max_irk_list_sz);
+ }
+
+ if (btm_cb.cmn_ble_vsc_cb.tot_scan_results_strg > 0)
+ btm_ble_batchscan_init();
if (p_ctrl_le_feature_rd_cmpl_cback != NULL)
p_ctrl_le_feature_rd_cmpl_cback(status);
- BTM_TRACE_DEBUG("btm_ble_vendor_capability_vsc_cmpl_cback: status=%d, max_irk_size=%d",
- status, btm_ble_vendor_cb.irk_avail_size);
#else
UNUSED(p_vcs_cplt_params);
#endif
{
BTM_TRACE_DEBUG("BTM_BleGetVendorCapabilities");
- if(NULL != p_cmn_vsc_cb)
+ if (NULL != p_cmn_vsc_cb)
{
*p_cmn_vsc_cb = btm_cb.cmn_ble_vsc_cb;
}
#if BLE_VND_INCLUDED == TRUE
BTM_TRACE_DEBUG("BTM_BleReadControllerFeatures");
- memset(&btm_ble_vendor_cb, 0, sizeof(tBTM_BLE_VENDOR_CB));
-
p_ctrl_le_feature_rd_cmpl_cback = p_vsc_cback;
if ( BTM_VendorSpecificCommand (HCI_BLE_VENDOR_CAP_OCF,
0,
#endif
}
-#if BLE_PRIVACY_SPT == TRUE
/*******************************************************************************
**
** Function BTM_BleConfigPrivacy
{
p_cb->addr_mgnt_cb.own_addr_type = BLE_ADDR_PUBLIC;
}
- btm_ble_multi_adv_enb_privacy(p_cb->privacy);
+
+ if (BTM_BleMaxMultiAdvInstanceCount() > 0)
+ btm_ble_multi_adv_enb_privacy(p_cb->privacy);
}
}
/*******************************************************************************
**
+** Function BTM_BleMaxMultiAdvInstanceCount
+**
+** Description Returns max number of multi adv instances supported by controller
+**
+** Returns Max multi adv instance count
+**
+*******************************************************************************/
+BTM_API extern UINT8 BTM_BleMaxMultiAdvInstanceCount()
+{
+ return btm_cb.cmn_ble_vsc_cb.adv_inst_max;
+}
+
+#if BLE_PRIVACY_SPT == TRUE
+/*******************************************************************************
+**
** Function btm_ble_resolve_random_addr_on_adv
**
** Description resolve random address complete callback.
{
evt_type = BTM_BLE_CONNECT_EVT;
-#if BLE_PRIVACY_SPT == TRUE
/* may need to reset random address if privacy is enabled */
if (btm_cb.ble_ctr_cb.privacy && /* own addr_type is random */
!BTM_BLE_IS_RESOLVE_BDA(btm_cb.ble_ctr_cb.addr_mgnt_cb.private_addr))
/* need to generate RRA and update random addresss in controller */
btm_gen_resolvable_private_addr((void *)btm_gen_resolve_paddr_low);
}
-#endif
}
return evt_type;
btm_update_scanner_filter_policy(SP_ADV_ALL);
#if (defined BLE_PRIVACY_SPT && BLE_PRIVACY_SPT == TRUE)
-#if (defined BLE_VND_INCLUDED && BLE_VND_INCLUDED == TRUE)
/* enable IRK list */
- btm_ble_vendor_irk_list_known_dev (TRUE);
-#endif
+ if (btm_cb.cmn_ble_vsc_cb.rpa_offloading == TRUE)
+ btm_ble_vendor_irk_list_known_dev (TRUE);
#endif
status = btm_ble_start_scan(BTM_BLE_DUPLICATE_DISABLE);
}
#endif
#if (defined BLE_PRIVACY_SPT && BLE_PRIVACY_SPT == TRUE)
-#if (defined BLE_VND_INCLUDED && BLE_VND_INCLUDED == TRUE)
/* map address to security record */
btm_public_addr_to_random_pseudo(bda, &addr_type);
BTM_TRACE_ERROR("new address: %02x:%02x:%02x:%02x:%02x:%02x",
bda[0], bda[1], bda[2], bda[3], bda[4], bda[5]);
#endif
-#endif
/* Only process the results if the inquiry is still active */
if (!BTM_BLE_IS_SCAN_ACTIVE(btm_cb.ble_ctr_cb.scan_activity))
case BTU_TTYPE_BLE_RANDOM_ADDR:
if (btm_cb.ble_ctr_cb.addr_mgnt_cb.own_addr_type == BLE_ADDR_RANDOM)
{
- if ((void *)(p_tle->param) == NULL)
- /* refresh the random addr */
- btm_gen_resolvable_private_addr((void *)btm_gen_resolve_paddr_low);
+ if (NULL == (void *)(p_tle->param))
+ {
+ /* refresh the random addr */
+ btm_gen_resolvable_private_addr((void *)btm_gen_resolve_paddr_low);
+ }
else
{
-#if BLE_MULTI_ADV_INCLUDED == TRUE
- btm_ble_multi_adv_configure_rpa((tBTM_BLE_MULTI_ADV_INST*)p_tle->param);
-#endif
+ if (BTM_BleMaxMultiAdvInstanceCount() > 0)
+ btm_ble_multi_adv_configure_rpa((tBTM_BLE_MULTI_ADV_INST*)p_tle->param);
}
}
break;
p_cb->adv_mode = !p_cb->adv_mode;
}
-#if (BLE_VND_INCLUDED == TRUE && BLE_PRIVACY_SPT == TRUE)
- if (p_cb->adv_mode == BTM_BLE_ADV_DISABLE)
+#if (BLE_PRIVACY_SPT == TRUE)
+ if ((p_cb->adv_mode == BTM_BLE_ADV_DISABLE) &&
+ (btm_cb.cmn_ble_vsc_cb.rpa_offloading == TRUE))
btm_ble_vendor_disable_irk_list();
#endif
}
BTM_TRACE_EVENT ("btm_ble_init ");
memset(p_cb, 0, sizeof(tBTM_BLE_CB));
- memset(&btm_cb.cmn_ble_vsc_cb, 0 , sizeof(tBTM_BLE_VSC_CB));
+ memset(&(btm_cb.cmn_ble_vsc_cb), 0 , sizeof(tBTM_BLE_VSC_CB));
p_cb->cur_states = 0;
p_cb->inq_var.adv_mode = BTM_BLE_ADV_DISABLE;
p_cb->scan_int = p_cb->scan_win = BTM_BLE_CONN_PARAM_UNDEF;
p_cb->inq_var.evt_type = BTM_BLE_NON_CONNECT_EVT;
-#if BLE_MULTI_ADV_INCLUDED == TRUE
- btm_ble_multi_adv_init();
-#endif
-
-#if BLE_BATCH_SCAN_INCLUDED == TRUE
- btm_ble_batchscan_init();
-#endif
-#if BLE_ANDROID_CONTROLLER_SCAN_FILTER == TRUE
+#if BLE_VND_INCLUDED == FALSE
+ btm_ble_vendor_init(BTM_CS_IRK_LIST_MAX);
btm_ble_adv_filter_init();
#endif
}
tBTM_LE_RANDOM_CB addr_mgnt_cb;
BOOLEAN enabled;
-#if BLE_PRIVACY_SPT == TRUE
- BOOLEAN privacy; /* privacy enabled or disabled */
-#endif
+ BOOLEAN privacy; /* local privacy enabled or disabled */
tBTM_BLE_WL_OP wl_op_q[BTM_BLE_MAX_BG_CONN_DEV_NUM];
#ifdef BTM_BLE_PC_ADV_TEST_MODE
extern void btm_ble_test_command_complete(UINT8 *p);
extern void btm_ble_rand_enc_complete (UINT8 *p, UINT16 op_code, tBTM_RAND_ENC_CB *p_enc_cplt_cback);
+
extern void btm_sec_save_le_key(BD_ADDR bd_addr, tBTM_LE_KEY_TYPE key_type, tBTM_LE_KEY_VALUE *p_keys, BOOLEAN pass_to_application);
extern void btm_ble_update_sec_key_size(BD_ADDR bd_addr, UINT8 enc_key_size);
extern UINT8 btm_ble_read_sec_key_size(BD_ADDR bd_addr);
extern void btm_ble_multi_adv_configure_rpa (tBTM_BLE_MULTI_ADV_INST *p_inst);
extern void btm_ble_multi_adv_init(void);
-extern void btm_ble_batchscan_init(void);
+extern void* btm_ble_multi_adv_get_ref(UINT8 inst_id);
+extern void btm_ble_multi_adv_cleanup(void);
extern void btm_ble_multi_adv_reenable(UINT8 inst_id);
extern void btm_ble_multi_adv_enb_privacy(BOOLEAN enable);
extern char btm_ble_map_adv_tx_power(int tx_power_index);
+extern void btm_ble_batchscan_init(void);
extern void btm_ble_adv_filter_init(void);
+extern void btm_ble_adv_filter_cleanup(void);
extern BOOLEAN btm_ble_topology_check(tBTM_BLE_STATE_MASK request);
extern BOOLEAN btm_ble_clear_topology_mask(tBTM_BLE_STATE_MASK request_state);
extern BOOLEAN btm_ble_set_topology_mask(tBTM_BLE_STATE_MASK request_state);
-#if (defined BLE_VND_INCLUDED && BLE_VND_INCLUDED == TRUE)
/* BLE address mapping with CS feature */
extern BOOLEAN btm_public_addr_to_random_pseudo(BD_ADDR bd_addr, UINT8 *p_addr_type);
extern BOOLEAN btm_random_pseudo_to_public(BD_ADDR random_pseudo, UINT8 *p_static_addr_type);
extern void btm_ble_refresh_rra(BD_ADDR pseudo_bda, BD_ADDR rra);
-#endif
#if BTM_BLE_CONFORMANCE_TESTING == TRUE
BT_API extern void btm_ble_set_no_disc_if_pair_fail (BOOLEAN disble_disc);
#include "bt_target.h"
#if (BLE_INCLUDED == TRUE)
-#if BLE_MULTI_ADV_INCLUDED == TRUE
#include "bt_types.h"
#include "hcimsgs.h"
#include "btu.h"
#define BTM_BLE_MULTI_ADV_WRITE_DATA_LEN (BTM_BLE_AD_DATA_LEN + 3)
#define BTM_BLE_MULTI_ADV_SET_RANDOM_ADDR_LEN 8
-#ifndef BTM_BLE_MULTI_ADV_INST_MAX
-#define BTM_BLE_MULTI_ADV_INST_MAX 5
-#endif
-
tBTM_BLE_MULTI_ADV_CB btm_multi_adv_cb;
-
-static void btm_ble_multi_adv_gen_rpa_cmpl_1(tBTM_RAND_ENC *p);
-static void btm_ble_multi_adv_gen_rpa_cmpl_2(tBTM_RAND_ENC *p);
-static void btm_ble_multi_adv_gen_rpa_cmpl_3(tBTM_RAND_ENC *p);
-static void btm_ble_multi_adv_gen_rpa_cmpl_4(tBTM_RAND_ENC *p);
-
-typedef void (*tBTM_MULTI_ADV_RPA_CMPL)(tBTM_RAND_ENC *p);
-const tBTM_MULTI_ADV_RPA_CMPL btm_ble_multi_adv_rpa_cmpl [] =
-{
- btm_ble_multi_adv_gen_rpa_cmpl_1,
- btm_ble_multi_adv_gen_rpa_cmpl_2,
- btm_ble_multi_adv_gen_rpa_cmpl_3,
- btm_ble_multi_adv_gen_rpa_cmpl_4
-};
+tBTM_BLE_MULTI_ADV_INST_IDX_Q btm_multi_adv_idx_q;
#define BTM_BLE_MULTI_ADV_CB_EVT_MASK 0xF0
#define BTM_BLE_MULTI_ADV_SUBCODE_MASK 0x0F
{
tBTM_BLE_MULTI_ADV_OPQ *p_op_q = &btm_multi_adv_cb.op_q;
- p_op_q->inst_id[p_op_q->next_idx] = inst_id;
+ p_op_q->p_inst_id[p_op_q->next_idx] = inst_id;
- p_op_q->sub_code[p_op_q->next_idx] = (opcode |(cb_evt << 4));
+ p_op_q->p_sub_code[p_op_q->next_idx] = (opcode |(cb_evt << 4));
- p_op_q->next_idx = (p_op_q->next_idx + 1) % BTM_BLE_MULTI_ADV_MAX;
+ p_op_q->next_idx = (p_op_q->next_idx + 1) % BTM_BleMaxMultiAdvInstanceCount();
}
/*******************************************************************************
{
tBTM_BLE_MULTI_ADV_OPQ *p_op_q = &btm_multi_adv_cb.op_q;
- *p_inst_id = p_op_q->inst_id[p_op_q->pending_idx] & 0x7F;
- *p_cb_evt = (p_op_q->sub_code[p_op_q->pending_idx] >> 4);
- *p_opcode = (p_op_q->sub_code[p_op_q->pending_idx] & BTM_BLE_MULTI_ADV_SUBCODE_MASK);
+ *p_inst_id = p_op_q->p_inst_id[p_op_q->pending_idx] & 0x7F;
+ *p_cb_evt = (p_op_q->p_sub_code[p_op_q->pending_idx] >> 4);
+ *p_opcode = (p_op_q->p_sub_code[p_op_q->pending_idx] & BTM_BLE_MULTI_ADV_SUBCODE_MASK);
- p_op_q->pending_idx = (p_op_q->pending_idx + 1) % BTM_BLE_MULTI_ADV_MAX;
+ p_op_q->pending_idx = (p_op_q->pending_idx + 1) % BTM_BleMaxMultiAdvInstanceCount();
}
/*******************************************************************************
return;
}
- p_inst = &btm_multi_adv_cb.adv_inst[inst_id - 1];
+ p_inst = &btm_multi_adv_cb.p_adv_inst[inst_id - 1];
switch (subcode)
{
BTM_TRACE_DEBUG("BTM_BLE_MULTI_ADV_ENB status = %d", status);
if (status != HCI_SUCCESS)
{
- btm_multi_adv_cb.adv_inst[inst_id-1].inst_id = 0;
+ btm_multi_adv_cb.p_adv_inst[inst_id-1].inst_id = 0;
}
break;
** Returns none.
**
*******************************************************************************/
-void btm_ble_multi_adv_gen_rpa_cmpl(tBTM_RAND_ENC *p, tBTM_BLE_MULTI_ADV_INST *p_inst )
+void btm_ble_multi_adv_gen_rpa_cmpl(tBTM_RAND_ENC *p)
{
#if (SMP_INCLUDED == TRUE)
tBTM_LE_RANDOM_CB *p_cb = &btm_cb.ble_ctr_cb.addr_mgnt_cb;
tSMP_ENC output;
+ UINT8 index = 0;
+ tBTM_BLE_MULTI_ADV_INST *p_inst = NULL;
+
+ /* Retrieve the index of adv instance from stored Q */
+ if (btm_multi_adv_idx_q.front == -1)
+ {
+ BTM_TRACE_ERROR(" %s can't locate advertise instance", __FUNCTION__);
+ return;
+ }
+ else
+ {
+ index = btm_multi_adv_idx_q.inst_index_queue[btm_multi_adv_idx_q.front];
+ if (btm_multi_adv_idx_q.front == btm_multi_adv_idx_q.rear)
+ {
+ btm_multi_adv_idx_q.front = -1;
+ btm_multi_adv_idx_q.rear = -1;
+ }
+ else
+ {
+ btm_multi_adv_idx_q.front = btm_multi_adv_idx_q.front +1 % BTM_BLE_MULTI_ADV_MAX;
+ }
+ }
+
+ p_inst = &(btm_multi_adv_cb.p_adv_inst[index]);
BTM_TRACE_EVENT ("btm_ble_multi_adv_gen_rpa_cmpl inst_id = %d", p_inst->inst_id);
if (p)
p_inst->rpa[4] = output.param_buf[1];
p_inst->rpa[3] = output.param_buf[2];
- if (p_inst->inst_id != 0)
+ if (p_inst->inst_id != 0 && (p_inst->inst_id < BTM_BleMaxMultiAdvInstanceCount()))
{
/* set it to controller */
btm_ble_multi_adv_write_rpa(p_inst, p_inst->rpa);
/*******************************************************************************
**
-** Function btm_ble_multi_adv_gen_rpa_cmpl1
-**
-** Description RPA generation completion callback for each adv instance. Will
-** continue write the new RPA into controller.
-**
-** Returns none.
-**
-*******************************************************************************/
-static void btm_ble_multi_adv_gen_rpa_cmpl_1(tBTM_RAND_ENC *p)
-{
- btm_ble_multi_adv_gen_rpa_cmpl(p, &btm_multi_adv_cb.adv_inst[0]);
-}
-
-/*******************************************************************************
-**
-** Function btm_ble_multi_adv_gen_rpa_cmpl2
-**
-** Description RPA generation completion callback for each adv instance. Will
-** continue write the new RPA into controller.
-**
-** Returns none.
-**
-*******************************************************************************/
-static void btm_ble_multi_adv_gen_rpa_cmpl_2(tBTM_RAND_ENC *p)
-{
- btm_ble_multi_adv_gen_rpa_cmpl(p, &btm_multi_adv_cb.adv_inst[1]);
-}
-
-/*******************************************************************************
-**
-** Function btm_ble_multi_adv_gen_rpa_cmpl3
-**
-** Description RPA generation completion callback for each adv instance. Will
-** continue write the new RPA into controller.
-**
-** Returns none.
-**
-*******************************************************************************/
-static void btm_ble_multi_adv_gen_rpa_cmpl_3(tBTM_RAND_ENC *p)
-{
- btm_ble_multi_adv_gen_rpa_cmpl(p, &btm_multi_adv_cb.adv_inst[2]);
-}
-
-/*******************************************************************************
-**
-** Function btm_ble_multi_adv_gen_rpa_cmpl4
-**
-** Description RPA generation completion callback for each adv instance. Will
-** continue write the new RPA into controller.
-**
-** Returns none.
-**
-*******************************************************************************/
-static void btm_ble_multi_adv_gen_rpa_cmpl_4(tBTM_RAND_ENC *p)
-{
- btm_ble_multi_adv_gen_rpa_cmpl(p, &btm_multi_adv_cb.adv_inst[3]);
-}
-/*******************************************************************************
-**
** Function btm_ble_multi_adv_configure_rpa
**
** Description This function set the random address for the adv instance
*******************************************************************************/
void btm_ble_multi_adv_configure_rpa (tBTM_BLE_MULTI_ADV_INST *p_inst)
{
- btm_gen_resolvable_private_addr((void *)p_inst->p_rpa_cback);
+ if (btm_multi_adv_idx_q.front == btm_multi_adv_idx_q.rear +1 % BTM_BLE_MULTI_ADV_MAX)
+ {
+ BTM_TRACE_ERROR("outstanding rand generation exceeded max allowed ");
+ return;
+ }
+ else
+ {
+ if (btm_multi_adv_idx_q.front == -1)
+ {
+ btm_multi_adv_idx_q.front = 0;
+ btm_multi_adv_idx_q.rear = 0;
+ }
+ else
+ {
+ btm_multi_adv_idx_q.rear = btm_multi_adv_idx_q.rear +1 % BTM_BLE_MULTI_ADV_MAX;
+ }
+ btm_multi_adv_idx_q.inst_index_queue[btm_multi_adv_idx_q.rear] = p_inst->index;
+ }
+ btm_gen_resolvable_private_addr((void *)btm_ble_multi_adv_gen_rpa_cmpl);
}
/*******************************************************************************
*******************************************************************************/
void btm_ble_multi_adv_reenable(UINT8 inst_id)
{
- tBTM_BLE_MULTI_ADV_INST *p_inst = &btm_multi_adv_cb.adv_inst[inst_id - 1];
+ tBTM_BLE_MULTI_ADV_INST *p_inst = &btm_multi_adv_cb.p_adv_inst[inst_id - 1];
if (p_inst->inst_id != 0)
{
void btm_ble_multi_adv_enb_privacy(BOOLEAN enable)
{
UINT8 i;
- tBTM_BLE_MULTI_ADV_INST *p_inst = &btm_multi_adv_cb.adv_inst[0];
+ tBTM_BLE_MULTI_ADV_INST *p_inst = &btm_multi_adv_cb.p_adv_inst[0];
- for (i = 0; i < BTM_BLE_MULTI_ADV_MAX; i ++, p_inst++)
+ for (i = 0; i < BTM_BleMaxMultiAdvInstanceCount() - 1; i ++, p_inst++)
{
if (enable)
btm_ble_multi_adv_configure_rpa (p_inst);
{
UINT8 i;
tBTM_STATUS rt = BTM_NO_RESOURCES;
- tBTM_BLE_MULTI_ADV_INST *p_inst = &btm_multi_adv_cb.adv_inst[0];
- tBTM_BLE_VSC_CB cmn_ble_vsc_cb;
-
+ tBTM_BLE_MULTI_ADV_INST *p_inst = &btm_multi_adv_cb.p_adv_inst[0];
BTM_TRACE_EVENT("BTM_BleEnableAdvInstance called");
- BTM_BleGetVendorCapabilities(&cmn_ble_vsc_cb);
-
- if (0 == cmn_ble_vsc_cb.adv_inst_max)
+ if (0 == btm_cb.cmn_ble_vsc_cb.adv_inst_max)
{
BTM_TRACE_ERROR("Controller does not support Multi ADV");
return BTM_ERR_PROCESSING;
}
- for (i = 0; i < BTM_BLE_MULTI_ADV_MAX; i ++, p_inst++)
+ if (NULL == p_inst)
+ {
+ BTM_TRACE_ERROR("Invalid instance in BTM_BleEnableAdvInstance");
+ return BTM_ERR_PROCESSING;
+ }
+
+ for (i = 0; i < BTM_BleMaxMultiAdvInstanceCount() - 1; i ++, p_inst++)
{
if (p_inst->inst_id == 0)
{
/* configure adv parameter */
if (p_params)
- btm_ble_multi_adv_set_params(p_inst, p_params, 0);
+ rt = btm_ble_multi_adv_set_params(p_inst, p_params, 0);
+ else
+ rt = BTM_CMD_STARTED;
/* enable adv */
BTM_TRACE_EVENT("btm_ble_enable_multi_adv being called with inst_id:%d",
p_inst->inst_id);
- if ((rt = btm_ble_enable_multi_adv (TRUE, p_inst->inst_id, BTM_BLE_MULTI_ADV_ENB_EVT))
- == BTM_CMD_STARTED)
+
+ if (BTM_CMD_STARTED == rt)
{
- p_inst->p_cback = p_cback;
- p_inst->p_ref = p_ref;
+ if ((rt = btm_ble_enable_multi_adv (TRUE, p_inst->inst_id,
+ BTM_BLE_MULTI_ADV_ENB_EVT)) == BTM_CMD_STARTED)
+ {
+ p_inst->p_cback = p_cback;
+ p_inst->p_ref = p_ref;
+ }
}
- else
+
+ if (BTM_CMD_STARTED != rt)
{
p_inst->inst_id = 0;
- BTM_TRACE_ERROR("BTM_BleEnableAdvInstance failed, no resources");
+ BTM_TRACE_ERROR("BTM_BleEnableAdvInstance failed");
}
break;
}
tBTM_STATUS BTM_BleUpdateAdvInstParam (UINT8 inst_id, tBTM_BLE_ADV_PARAMS *p_params)
{
tBTM_STATUS rt = BTM_ILLEGAL_VALUE;
- tBTM_BLE_MULTI_ADV_INST *p_inst = &btm_multi_adv_cb.adv_inst[inst_id - 1];
- tBTM_BLE_VSC_CB cmn_ble_vsc_cb;
+ tBTM_BLE_MULTI_ADV_INST *p_inst = &btm_multi_adv_cb.p_adv_inst[inst_id - 1];
BTM_TRACE_EVENT("BTM_BleUpdateAdvInstParam called with inst_id:%d", inst_id);
- BTM_BleGetVendorCapabilities(&cmn_ble_vsc_cb);
-
- if (0 == cmn_ble_vsc_cb.adv_inst_max)
+ if (0 == btm_cb.cmn_ble_vsc_cb.adv_inst_max)
{
BTM_TRACE_ERROR("Controller does not support Multi ADV");
return BTM_ERR_PROCESSING;
}
- if (inst_id <= BTM_BLE_MULTI_ADV_MAX &&
+ if (inst_id < BTM_BleMaxMultiAdvInstanceCount() &&
inst_id != BTM_BLE_MULTI_ADV_DEFAULT_STD &&
p_params != NULL)
{
else
btm_ble_enable_multi_adv(FALSE, inst_id, 0);
- btm_ble_multi_adv_set_params(p_inst, p_params, 0);
-
- rt = btm_ble_enable_multi_adv(TRUE, inst_id, BTM_BLE_MULTI_ADV_PARAM_EVT);
+ if (BTM_CMD_STARTED == btm_ble_multi_adv_set_params(p_inst, p_params, 0))
+ rt = btm_ble_enable_multi_adv(TRUE, inst_id, BTM_BLE_MULTI_ADV_PARAM_EVT);
}
return rt;
}
return BTM_ERR_PROCESSING;
}
+
BTM_TRACE_EVENT("BTM_BleCfgAdvInstData called with inst_id:%d", inst_id);
if (inst_id > BTM_BLE_MULTI_ADV_MAX || inst_id == BTM_BLE_MULTI_ADV_DEFAULT_STD)
return BTM_ILLEGAL_VALUE;
return BTM_ERR_PROCESSING;
}
- if (inst_id <= BTM_BLE_MULTI_ADV_MAX && inst_id != BTM_BLE_MULTI_ADV_DEFAULT_STD)
+ if (inst_id < BTM_BleMaxMultiAdvInstanceCount() &&
+ inst_id != BTM_BLE_MULTI_ADV_DEFAULT_STD)
{
if ((rt = btm_ble_enable_multi_adv(FALSE, inst_id, BTM_BLE_MULTI_ADV_DISABLE_EVT))
== BTM_CMD_STARTED)
{
- btu_stop_timer(&btm_multi_adv_cb.adv_inst[inst_id-1].raddr_timer_ent);
- btm_ble_multi_adv_configure_rpa(&btm_multi_adv_cb.adv_inst[inst_id-1]);
- btm_multi_adv_cb.adv_inst[inst_id-1].inst_id = 0;
+ btm_ble_multi_adv_configure_rpa(&btm_multi_adv_cb.p_adv_inst[inst_id-1]);
+ btu_stop_timer(&btm_multi_adv_cb.p_adv_inst[inst_id-1].raddr_timer_ent);
+ btm_multi_adv_cb.p_adv_inst[inst_id-1].inst_id = 0;
}
}
return rt;
len--;
BTM_TRACE_EVENT("btm_ble_multi_adv_vse_cback called with event:%d", sub_event);
- if ((sub_event == HCI_VSE_SUBCODE_BLE_MULTI_ADV_ST_CHG) && (len>=4))
+ if ((sub_event == HCI_VSE_SUBCODE_BLE_MULTI_ADV_ST_CHG) && (len >= 4))
{
STREAM_TO_UINT8(adv_inst, p);
STREAM_TO_UINT8(reason, p);
STREAM_TO_UINT16(conn_handle, p);
- if (adv_inst <= BTM_BLE_MULTI_ADV_MAX && adv_inst != BTM_BLE_MULTI_ADV_DEFAULT_STD)
+ if (adv_inst < BTM_BleMaxMultiAdvInstanceCount() &&
+ adv_inst != BTM_BLE_MULTI_ADV_DEFAULT_STD)
{
BTM_TRACE_EVENT("btm_ble_multi_adv_reenable called");
btm_ble_multi_adv_reenable(adv_inst);
if (btm_cb.ble_ctr_cb.inq_var.connectable_mode == BTM_BLE_CONNECTABLE)
{
btm_ble_set_connectability ( btm_cb.ble_ctr_cb.inq_var.connectable_mode );
-
}
}
**
** Description This function initialize the multi adv control block.
**
-** Parameters
+** Parameters None
**
-** Returns status
+** Returns void
**
*******************************************************************************/
-void btm_ble_multi_adv_init(void)
+void btm_ble_multi_adv_init()
{
- UINT8 i;
-
+ UINT8 i = 0;
memset(&btm_multi_adv_cb, 0, sizeof(tBTM_BLE_MULTI_ADV_CB));
+ memset (&btm_multi_adv_idx_q,0, sizeof (tBTM_BLE_MULTI_ADV_INST_IDX_Q));
+ btm_multi_adv_idx_q.front = -1;
+ btm_multi_adv_idx_q.rear = -1;
- for (i = 0; i < BTM_BLE_MULTI_ADV_MAX; i ++)
- btm_multi_adv_cb.adv_inst[i].p_rpa_cback = btm_ble_multi_adv_rpa_cmpl[i];
+ if (btm_cb.cmn_ble_vsc_cb.adv_inst_max > 0)
+ {
+ btm_multi_adv_cb.p_adv_inst = GKI_getbuf( sizeof(tBTM_BLE_MULTI_ADV_INST)*
+ (btm_cb.cmn_ble_vsc_cb.adv_inst_max));
+ memset(btm_multi_adv_cb.p_adv_inst, 0, sizeof(tBTM_BLE_MULTI_ADV_INST)*
+ (btm_cb.cmn_ble_vsc_cb.adv_inst_max));
+
+ btm_multi_adv_cb.op_q.p_sub_code = GKI_getbuf( sizeof(UINT8) *
+ (btm_cb.cmn_ble_vsc_cb.adv_inst_max));
+ memset(btm_multi_adv_cb.op_q.p_sub_code, 0,
+ sizeof(UINT8)*(btm_cb.cmn_ble_vsc_cb.adv_inst_max));
+
+ btm_multi_adv_cb.op_q.p_inst_id = GKI_getbuf( sizeof(UINT8) *
+ (btm_cb.cmn_ble_vsc_cb.adv_inst_max));
+ memset(btm_multi_adv_cb.op_q.p_inst_id, 0,
+ sizeof(UINT8)*(btm_cb.cmn_ble_vsc_cb.adv_inst_max));
+ }
+
+ for (i = 0; i < btm_cb.cmn_ble_vsc_cb.adv_inst_max ; i ++)
+ btm_multi_adv_cb.p_adv_inst[i].index = i;
BTM_RegisterForVSEvents(btm_ble_multi_adv_vse_cback, TRUE);
}
-#endif
+
+/*******************************************************************************
+**
+** Function btm_ble_multi_adv_cleanup
+**
+** Description This function cleans up multi adv control block.
+**
+** Parameters
+** Returns void
+**
+*******************************************************************************/
+void btm_ble_multi_adv_cleanup(void)
+{
+ if (btm_multi_adv_cb.p_adv_inst)
+ GKI_freebuf(btm_multi_adv_cb.p_adv_inst);
+
+ if (btm_multi_adv_cb.op_q.p_sub_code)
+ GKI_freebuf(btm_multi_adv_cb.op_q.p_sub_code);
+
+ if (btm_multi_adv_cb.op_q.p_inst_id)
+ GKI_freebuf(btm_multi_adv_cb.op_q.p_inst_id);
+
+}
+
+/*******************************************************************************
+**
+** Function btm_ble_multi_adv_get_ref
+**
+** Description This function obtains the reference pointer for the instance ID provided
+**
+** Parameters inst_id - Instance ID
+**
+** Returns void*
+**
+*******************************************************************************/
+void* btm_ble_multi_adv_get_ref(UINT8 inst_id)
+{
+ tBTM_BLE_MULTI_ADV_INST *p_inst = NULL;
+
+ if (inst_id < BTM_BleMaxMultiAdvInstanceCount())
+ {
+ p_inst = &btm_multi_adv_cb.p_adv_inst[inst_id - 1];
+ if (NULL != p_inst)
+ return p_inst->p_ref;
+ }
+
+ return NULL;
+}
#endif
btm_cb.ble_ctr_cb.p_select_cback = NULL;
memset(&btm_cb.ble_ctr_cb.bg_dev_list, 0, (sizeof(tBTM_LE_BG_CONN_DEV)*BTM_BLE_MAX_BG_CONN_DEV_NUM));
gatt_reset_bgdev_list();
-#if BLE_MULTI_ADV_INCLUDED == TRUE
- btm_ble_multi_adv_init();
-#endif
#endif
}
}
case HCI_BLE_RAND:
case HCI_BLE_ENCRYPT:
-
btm_ble_rand_enc_complete (p, opcode, (tBTM_RAND_ENC_CB *)p_cplt_cback);
break;
+
case HCI_BLE_READ_BUFFER_SIZE:
btm_read_ble_buf_size_complete(p, evt_len);
break;
}tBTM_BLE_ADV_DATA;
#ifndef BTM_BLE_MULTI_ADV_MAX
-#define BTM_BLE_MULTI_ADV_MAX 4
+#define BTM_BLE_MULTI_ADV_MAX 10 /* controller returned adv_inst_max should be less
+ than this number */
#endif
#define BTM_BLE_MULTI_ADV_INVALID 0
typedef struct
{
- UINT8 sub_code[BTM_BLE_MULTI_ADV_MAX];
- UINT8 inst_id[BTM_BLE_MULTI_ADV_MAX];
+ UINT8 *p_sub_code; /* dynamic array to store sub code */
+ UINT8 *p_inst_id; /* dynamic array to store instance id */
UINT8 pending_idx;
UINT8 next_idx;
}tBTM_BLE_MULTI_ADV_OPQ;
UINT8 adv_evt;
BD_ADDR rpa;
TIMER_LIST_ENT raddr_timer_ent;
- void *p_rpa_cback;
tBTM_BLE_MULTI_ADV_CBACK *p_cback;
void *p_ref;
+ UINT8 index;
}tBTM_BLE_MULTI_ADV_INST;
typedef struct
{
- tBTM_BLE_MULTI_ADV_INST adv_inst[BTM_BLE_MULTI_ADV_MAX];
+ UINT8 inst_index_queue[BTM_BLE_MULTI_ADV_MAX];
+ int front;
+ int rear;
+}tBTM_BLE_MULTI_ADV_INST_IDX_Q;
+
+typedef struct
+{
+ tBTM_BLE_MULTI_ADV_INST *p_adv_inst; /* dynamic array to store adv instance */
tBTM_BLE_MULTI_ADV_OPQ op_q;
}tBTM_BLE_MULTI_ADV_CB;
#define BTM_BLE_MAX_FILTER_COUNTER (BTM_BLE_MAX_ADDR_FILTER + 1) /* per device filter + one generic filter indexed by 0 */
+#ifndef BTM_CS_IRK_LIST_MAX
+#define BTM_CS_IRK_LIST_MAX 0x20
+#endif
+
typedef struct
{
BOOLEAN in_use;
BD_ADDR bd_addr;
- UINT16 feat_mask; /* per BD_ADDR feature mask */
UINT8 pf_counter[BTM_BLE_PF_TYPE_MAX]; /* number of filter indexed by tBTM_BLE_PF_COND_TYPE */
}tBTM_BLE_PF_COUNT;
{
BOOLEAN enable;
UINT8 op_type;
- tBTM_BLE_PF_COUNT addr_filter_count[BTM_BLE_MAX_FILTER_COUNTER]; /* per BDA filter indexed by tBTM_BLE_PF_COND_TYPE */
+ tBTM_BLE_PF_COUNT *p_addr_filter_count; /* per BDA filter array */
tBLE_BD_ADDR cur_filter_target;
tBTM_BLE_PF_STATUS_CBACK *p_filt_stat_cback;
tBTM_BLE_ADV_FILTER_ADV_OPQ op_q;
*******************************************************************************/
BTM_API extern BOOLEAN BTM_BleLocalPrivacyEnabled();
-
+/*******************************************************************************
+**
+** Function BTM_BleMaxMultiAdvInstanceCount
+**
+** Description Returns max number of multi adv instances supported by controller
+**
+** Returns Max multi adv instance count
+**
+*******************************************************************************/
+BTM_API extern UINT8 BTM_BleMaxMultiAdvInstanceCount();
/*******************************************************************************
**
typedef void (tGAP_BLE_DEV_NAME_CBACK)(BOOLEAN status, BD_ADDR addr, UINT16 length, char *p_name);
typedef void (tGAP_BLE_RECONN_ADDR_CBACK)(BOOLEAN status, BD_ADDR addr, BD_ADDR reconn_bda);
-#if BLE_PRIVACY_SPT == TRUE
-typedef void (tGAP_BLE_PRIVACY_CBACK)(BOOLEAN status, BD_ADDR addr, BOOLEAN privacy_enabled);
-#endif
/*****************************************************************************
** External Function Declarations
#define L2CA_GET_UPD_ST(x) ((x) & UPD_ST_MASK)
#define L2CA_SET_UPD_ST(x, y) x = (((x) & ~UPD_ST_MASK) | (y))
-#if (defined BLE_VND_INCLUDED && BLE_VND_INCLUDED == TRUE)
#include "vendor_ble.h"
-#else
-#if BLE_PRIVACY_SPT == TRUE
-extern BOOLEAN btm_ble_get_acl_remote_addr(tBTM_SEC_DEV_REC *p_dev_rec, BD_ADDR conn_addr,
- tBLE_ADDR_TYPE *p_addr_type);
-#endif
-#endif
-
/*******************************************************************************
**
** Function L2CA_CancelBleConnectReq
L2CAP_TRACE_ERROR("initate direct connection fail, topology limitation");
return FALSE;
}
-#if BLE_PRIVACY_SPT == TRUE
-#if (defined BLE_VND_INCLUDED && BLE_VND_INCLUDED == TRUE)
- extern tBTM_STATUS BTM_BleEnableIRKFeature(BOOLEAN enable);
- if (btm_ble_vendor_irk_list_load_dev(p_dev_rec))
- BTM_BleEnableIRKFeature(TRUE);
-
- btm_random_pseudo_to_public(init_addr, &init_addr_type);
-#else
- btm_ble_get_acl_remote_addr(p_dev_rec, init_addr, &init_addr_type);
-#endif
-#endif
+ if (btm_ble_vendor_irk_list_load_dev(p_dev_rec) &&
+ (btm_cb.cmn_ble_vsc_cb.rpa_offloading == TRUE ))
+ {
+ btm_ble_vendor_enable_irk_feature(TRUE);
+ btm_random_pseudo_to_public(init_addr, &init_addr_type);
+ }
+
if (!btsnd_hcic_ble_create_ll_conn (scan_int,/* UINT16 scan_int */
scan_win, /* UINT16 scan_win */
FALSE, /* UINT8 white_list */
keylen = 24;
break;
case 32:
- /* case 256: length in bits (256 = 8*32) */
+ /* case 256: length in bits (256 = 8*32) */
keylen = 32;
break;
default:
+++ /dev/null
-/******************************************************************************
- *
- * Copyright (C) 2003-2014 Broadcom Corporation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at:
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- ******************************************************************************/
-
-/*****************************************************************************
-**
-** Name: bta_vendor.c
-**
-** Description: This is the implementation VENDOR custom Ble APIs
-**
-*****************************************************************************/
-
-#include "bta_api.h"
-#include "bta_vendor_api.h"
-#include "bta_sys_int.h"
-#include "bta_dm_int.h"
-#include "vendor_api.h"
-#include "vendor_ble.h"
-#include <string.h>
-
-#if (BLE_INCLUDED == TRUE && BLE_ANDROID_CONTROLLER_SCAN_FILTER == TRUE)
-
-static tBTA_DM_SCAN_PF_CBACK *bta_vendor_ble_scan_pf_cmpl_cback = NULL;
-
-/*******************************************************************************
-**
-** Function bta_vendor_ble_scan_pf_cmpl
-**
-** Description ADV payload filtering operation complete callback
-**
-**
-** Returns TRUE if handled, otherwise FALSE.
-**
-*******************************************************************************/
-static void bta_vendor_ble_scan_pf_cmpl(tBTM_BLE_PF_ACTION action, tBTM_BLE_PF_COND_TYPE cfg_cond, tBTM_STATUS status)
-{
- tBTA_STATUS st = (status == BTM_SUCCESS) ? BTA_SUCCESS: BTA_FAILURE;
-
- if (bta_vendor_ble_scan_pf_cmpl_cback)
- ((tBTA_DM_SCAN_PF_CBACK *) bta_vendor_ble_scan_pf_cmpl_cback)(action, cfg_cond, st);
-
-}
-/*******************************************************************************
-**
-** Function bta_vendor_ble_scan_pf_enable
-**
-** Description This function processes events for enabling adv payload filtering
-** feature
-**
-** Returns TRUE if handled, otherwise FALSE.
-**
-*******************************************************************************/
-BOOLEAN bta_vendor_ble_scan_pf_enable(tBTA_SYS_VS_BLE_SCAN_PF_ENABLE *p_data)
-{
- tBTM_STATUS st;
- tBTA_STATUS status;
-
- if ((st = BTM_BleEnableFilterCondition(p_data->enable,
- p_data->p_target,
- (tBTM_BLE_PF_CMPL_CBACK *)p_data->p_cmpl_cback))
- == BTM_CMD_STARTED)
- {
- bta_vendor_ble_scan_pf_cmpl_cback = (tBTA_DM_SCAN_PF_CBACK *)p_data->p_cmpl_cback;
- }
- else
- {
- status = (st == BTM_SUCCESS) ? BTA_SUCCESS: BTA_FAILURE;
- if (p_data->p_cmpl_cback)
- ((tBTA_DM_SCAN_PF_CBACK *) p_data->p_cmpl_cback)(BTA_DM_BLE_PF_CONFIG_EVT, 0, status);
- }
-
- return TRUE;
-}
-
-
-/*******************************************************************************
-**
-** Function bta_vendor_ble_scan_pf_condition
-**
-** Description This function processes events for configuring the ADV filtering
-** condition
-**
-**
-** Returns TRUE if handled, otherwise FALSE.
-**
-*******************************************************************************/
-BOOLEAN bta_vendor_ble_scan_pf_condition(tBTA_SYS_VS_BLE_SCAN_PF_COND *p_data)
-{
- tBTM_STATUS st;
- tBTA_STATUS status;
-
- if ((st = BTM_BleCfgFilterCondition(p_data->action,
- p_data->cond_type,
- (tBTM_BLE_PF_COND_PARAM *)p_data->p_cond,
- bta_vendor_ble_scan_pf_cmpl))
- == BTM_CMD_STARTED)
- {
- bta_vendor_ble_scan_pf_cmpl_cback = (tBTA_DM_SCAN_PF_CBACK *)p_data->p_cmpl_cback;
- }
- else
- {
- status = (st == BTM_SUCCESS) ? BTA_SUCCESS: BTA_FAILURE;
- if (p_data->p_cmpl_cback)
- ((tBTA_DM_SCAN_PF_CBACK *) p_data->p_cmpl_cback)(BTA_DM_BLE_PF_CONFIG_EVT, p_data->cond_type, status);
- }
- return TRUE;
-}
-#endif
-/*******************************************************************************
-**
-** Function bta_vendor_evt_hdlr
-**
-** Description This function processes events for Broadcom specific features.
-**
-** Returns TRUE if handled, otherwise FALSE.
-**
-*******************************************************************************/
-BOOLEAN bta_vendor_evt_hdlr(UINT16 event, void *p)
-{
- BOOLEAN st = TRUE;
-
- APPL_TRACE_EVENT("bta_vendor_evt_hdlr :0x%04x", event);
-
- switch (event)
- {
-#if BLE_INCLUDED == TRUE && BLE_ANDROID_CONTROLLER_SCAN_FILTER == TRUE
- case BTA_VS_BLE_SCAN_PF_ENABLE_EVT:
- st = bta_vendor_ble_scan_pf_enable((tBTA_SYS_VS_BLE_SCAN_PF_ENABLE *)p);
- break;
-
- case BTA_VS_BLE_SCAN_PF_COND_EVT:
- bta_vendor_ble_scan_pf_condition((tBTA_SYS_VS_BLE_SCAN_PF_COND*)p);
- break;
-#endif
-
- default:
- APPL_TRACE_EVENT("Unknown BTA VS event: %d", event);
- st = FALSE;
- break;
- }
-
- return st;
-}
-
-
-
-/*******************************************************************************
-**
-** Function BTA_DmBleCfgFilterCondition
-**
-** Description This function is called to configure the adv data payload filter
-** condition.
-**
-** Parameters action: to read/write/clear
-** cond_type: filter condition type.
-** p_cond: filter condition paramter
-**
-** Returns void
-**
-*******************************************************************************/
-void BTA_DmBleCfgFilterCondition(tBTA_DM_BLE_SCAN_COND_OP action,
- tBTA_DM_BLE_PF_COND_TYPE cond_type,
- tBTA_DM_BLE_PF_COND_PARAM *p_cond,
- tBTA_DM_SCAN_PF_CBACK *p_cmpl_cback)
-{
-#if BLE_INCLUDED == TRUE && BLE_ANDROID_CONTROLLER_SCAN_FILTER == TRUE
- tBTA_DM_API_CFG_FILTER_COND *p_msg;
- UINT16 len = sizeof(tBTA_DM_API_CFG_FILTER_COND) + sizeof(tBTA_DM_BLE_PF_COND_PARAM) + \
- BTM_BLE_PF_STR_LEN_MAX + BTM_BLE_PF_STR_LEN_MAX + sizeof(tBTA_DM_BLE_PF_COND_MASK);
-
- UINT8 *p;
-
- if ((p_msg = (tBTA_DM_API_CFG_FILTER_COND *) GKI_getbuf(len)) != NULL)
- {
- memset (p_msg, 0, len);
-
- p_msg->hdr.event = BTA_DM_API_CFG_FILTER_COND_EVT;
- p_msg->action = action;
- p_msg->cond_type = cond_type;
- p_msg->p_cmpl_cback = (void *) p_cmpl_cback;
-
- if (p_cond)
- {
- p_msg->p_cond_param = (tBTA_DM_BLE_PF_COND_PARAM *)(p_msg + 1);
- memcpy(p_msg->p_cond_param, p_cond, sizeof(tBTA_DM_BLE_PF_COND_PARAM));
-
- p = (UINT8 *)(p_msg->p_cond_param + 1);
-
- if (cond_type == BTA_DM_BLE_PF_SRVC_DATA_PATTERN ||cond_type == BTA_DM_BLE_PF_MANU_DATA)
- {
- p_msg->p_cond_param->manu_data.p_pattern = p;
- p_msg->p_cond_param->manu_data.data_len = p_cond->manu_data.data_len;
- memcpy(p_msg->p_cond_param->manu_data.p_pattern, p_cond->manu_data.p_pattern, p_cond->manu_data.data_len);
- p += p_cond->manu_data.data_len;
-
- if (cond_type == BTA_DM_BLE_PF_MANU_DATA)
- {
- p_msg->p_cond_param->manu_data.company_id_mask = p_cond->manu_data.company_id_mask;
- if ( p_cond->manu_data.p_pattern_mask != NULL)
- {
- p_msg->p_cond_param->manu_data.p_pattern_mask = p;
- memcpy(p_msg->p_cond_param->manu_data.p_pattern_mask, p_cond->manu_data.p_pattern_mask, p_cond->manu_data.data_len);
- }
- }
- }
- else if (cond_type == BTA_DM_BLE_PF_LOCAL_NAME)
- {
- p_msg->p_cond_param->local_name.p_data = p;
- memcpy(p_msg->p_cond_param->local_name.p_data, p_cond->local_name.p_data, p_cond->local_name.data_len);
-
- }
- else if ((cond_type == BTM_BLE_PF_SRVC_UUID || cond_type == BTM_BLE_PF_SRVC_SOL_UUID))
- {
- if (p_cond->srvc_uuid.p_target_addr != NULL)
- {
- p_msg->p_cond_param->srvc_uuid.p_target_addr = (tBLE_BD_ADDR *)(p);
- p_msg->p_cond_param->srvc_uuid.p_target_addr->type = p_cond->srvc_uuid.p_target_addr->type;
- memcpy(p_msg->p_cond_param->srvc_uuid.p_target_addr->bda, p_cond->srvc_uuid.p_target_addr->bda, BD_ADDR_LEN);
- p = (UINT8*)( p_msg->p_cond_param->srvc_uuid.p_target_addr + 1);
- }
- if (p_cond->srvc_uuid.p_uuid_mask)
- {
- p_msg->p_cond_param->srvc_uuid.p_uuid_mask = (tBTA_DM_BLE_PF_COND_MASK *)p;
- memcpy(p_msg->p_cond_param->srvc_uuid.p_uuid_mask, p_cond->srvc_uuid.p_uuid_mask, sizeof(tBTA_DM_BLE_PF_COND_MASK));
- }
- }
- }
-
- bta_sys_sendmsg(p_msg);
- }
-#endif
-}
-
-/*******************************************************************************
-**
-** Function BTA_DmBleEnableFilterCondition
-**
-** Description This function is called to enable the adv data payload filter
-** condition.
-**
-** Parameters p_target: enabble the filter condition on a target device; if NULL
-** enable the generic scan condition.
-** enable: enable or disable the filter condition
-**
-** Returns void
-**
-*******************************************************************************/
-void BTA_DmBleEnableFilterCondition(BOOLEAN enable, tBLE_BD_ADDR *p_target, tBTA_DM_SCAN_PF_CBACK *p_cmpl_cback)
-{
-#if BLE_INCLUDED == TRUE && BLE_ANDROID_CONTROLLER_SCAN_FILTER == TRUE
- tBTA_DM_API_ENABLE_SCAN_FILTER *p_msg;
- UINT16 len = sizeof(tBTA_DM_API_ENABLE_SCAN_FILTER) + sizeof(tBLE_BD_ADDR);
-
- if ((p_msg = (tBTA_DM_API_ENABLE_SCAN_FILTER *) GKI_getbuf(len)) != NULL)
- {
- memset (p_msg, 0, len);
-
- p_msg->hdr.event = BTA_DM_API_ENABLE_SCAN_FILTER_EVT;
- p_msg->enable = enable;
- p_msg->p_cmpl_cback = (void *) p_cmpl_cback;
-
- if (p_target)
- {
- p_msg->p_target = (tBLE_BD_ADDR *)(p_msg + 1);
- memcpy(p_msg->p_target, p_target, sizeof(tBLE_BD_ADDR));
- }
-
- bta_sys_sendmsg(p_msg);
- }
-#endif
-}
-
-/*******************************************************************************
-**
-** Function BTA_BrcmInit
-**
-** Description This function initializes Broadcom specific
-**
-** Returns void
-**
-*******************************************************************************/
-void BTA_BrcmInit (void)
-{
- APPL_TRACE_API("BTA_BrcmInit");
- bta_sys_cb.p_vs_evt_hdlr = bta_vendor_evt_hdlr;
-#if BLE_INCLUDED == TRUE && BLE_ANDROID_CONTROLLER_SCAN_FILTER == TRUE
- btm_ble_vendor_init();
-#endif
-}
-
-
#include <string.h>
#include "bt_target.h"
-#if (BLE_INCLUDED == TRUE && BLE_ANDROID_CONTROLLER_SCAN_FILTER == TRUE)
+#if (BLE_INCLUDED == TRUE)
#include "bt_types.h"
#include "hcimsgs.h"
#include "btu.h"
static const BD_ADDR na_bda= {0};
-
/*******************************************************************************
** Resolve Address Using IRK List functions
*******************************************************************************/
-#if BLE_PRIVACY_SPT == TRUE
-/* Forward declaration */
-tBTM_STATUS BTM_BleEnableIRKFeature(BOOLEAN enable);
/*******************************************************************************
**
*******************************************************************************/
void btm_ble_vendor_enq_irk_pending(BD_ADDR target_bda, BD_ADDR psuedo_bda, UINT8 to_add)
{
+#if BLE_PRIVACY_SPT == TRUE
tBTM_BLE_IRK_Q *p_q = &btm_ble_vendor_cb.irk_pend_q;
memcpy(p_q->irk_q[p_q->q_next], target_bda, BD_ADDR_LEN);
p_q->irk_q_action[p_q->q_next] = to_add;
p_q->q_next ++;
- p_q->q_next %= BTM_CS_IRK_LIST_MAX;
-
+ p_q->q_next %= btm_cb.cmn_ble_vsc_cb.max_irk_list_sz;;
+#endif
return ;
}
/*******************************************************************************
*******************************************************************************/
BOOLEAN btm_ble_vendor_find_irk_pending_entry(BD_ADDR psuedo_addr, UINT8 action)
{
+#if BLE_PRIVACY_SPT == TRUE
tBTM_BLE_IRK_Q *p_q = &btm_ble_vendor_cb.irk_pend_q;
UINT8 i;
return TRUE;
i ++;
- i %= BTM_CS_IRK_LIST_MAX;
+ i %= btm_cb.cmn_ble_vsc_cb.max_irk_list_sz;
}
+#endif
return FALSE;
}
/*******************************************************************************
*******************************************************************************/
BOOLEAN btm_ble_vendor_deq_irk_pending(BD_ADDR target_bda, BD_ADDR psuedo_addr)
{
+#if BLE_PRIVACY_SPT == TRUE
tBTM_BLE_IRK_Q *p_q = &btm_ble_vendor_cb.irk_pend_q;
if (p_q->q_next != p_q->q_pending)
memcpy(psuedo_addr, p_q->irk_q_random_pseudo[p_q->q_pending], BD_ADDR_LEN);
p_q->q_pending ++;
- p_q->q_pending %= BTM_CS_IRK_LIST_MAX;
+ p_q->q_pending %= btm_cb.cmn_ble_vsc_cb.max_irk_list_sz;
return TRUE;
}
-
+#endif
return FALSE;
}
*******************************************************************************/
tBTM_BLE_IRK_ENTRY * btm_ble_vendor_find_irk_entry(BD_ADDR target_bda)
{
+#if BLE_PRIVACY_SPT == TRUE
tBTM_BLE_IRK_ENTRY *p_irk_entry = &btm_ble_vendor_cb.irk_list[0];
UINT8 i;
- for (i = 0; i < BTM_CS_IRK_LIST_MAX; i ++, p_irk_entry++)
+ for (i = 0; i < btm_cb.cmn_ble_vsc_cb.max_irk_list_sz; i ++, p_irk_entry++)
{
if (p_irk_entry->in_use && memcmp(p_irk_entry->bd_addr, target_bda, BD_ADDR_LEN) == 0)
{
return p_irk_entry ;
}
}
+#endif
return NULL;
}
/*******************************************************************************
*******************************************************************************/
tBTM_BLE_IRK_ENTRY * btm_ble_vendor_find_irk_entry_by_psuedo_addr (BD_ADDR psuedo_bda)
{
+#if BLE_PRIVACY_SPT == TRUE
tBTM_BLE_IRK_ENTRY *p_irk_entry = &btm_ble_vendor_cb.irk_list[0];
UINT8 i;
- for (i = 0; i < BTM_CS_IRK_LIST_MAX; i ++, p_irk_entry++)
+ for (i = 0; i < btm_cb.cmn_ble_vsc_cb.max_irk_list_sz; i ++, p_irk_entry++)
{
if (p_irk_entry->in_use && memcmp(p_irk_entry->psuedo_bda, psuedo_bda, BD_ADDR_LEN) == 0)
{
return p_irk_entry ;
}
}
+#endif
return NULL;
}
/*******************************************************************************
*******************************************************************************/
UINT8 btm_ble_vendor_alloc_irk_entry(BD_ADDR target_bda, BD_ADDR pseudo_bda)
{
+#if BLE_PRIVACY_SPT == TRUE
tBTM_BLE_IRK_ENTRY *p_irk_entry = &btm_ble_vendor_cb.irk_list[0];
UINT8 i;
- for (i = 0; i < BTM_CS_IRK_LIST_MAX; i ++, p_irk_entry++)
+ for (i = 0; i < btm_cb.cmn_ble_vsc_cb.max_irk_list_sz; i ++, p_irk_entry++)
{
if (!p_irk_entry->in_use)
{
return i;
}
}
+#endif
return BTM_CS_IRK_LIST_INVALID;
}
*******************************************************************************/
void btm_ble_vendor_update_irk_list(BD_ADDR target_bda, BD_ADDR pseudo_bda, BOOLEAN add)
{
+#if BLE_PRIVACY_SPT == TRUE
tBTM_BLE_IRK_ENTRY *p_irk_entry = btm_ble_vendor_find_irk_entry(target_bda);
UINT8 i;
BTM_TRACE_ERROR("No IRK exist in list, can not remove");
}
}
+#endif
return ;
}
/*******************************************************************************
op_subcode = *p ++;
BTM_TRACE_DEBUG("btm_ble_vendor_irk_vsc_op_cmpl op_subcode = %d", op_subcode);
- if (evt_len < 2 )
+ if (evt_len < 1)
{
- BTM_TRACE_ERROR("can not interpret IRK VSC cmpl callback");
+ BTM_TRACE_ERROR("cannot interpret IRK VSC cmpl callback");
return;
}
-
+ if (BTM_BLE_META_IRK_ENABLE == op_subcode)
+ {
+ BTM_TRACE_DEBUG("IRK enable: %d, %d", status, op_subcode);
+ return;
+ }
+ else
if (op_subcode == BTM_BLE_META_CLEAR_IRK_LIST)
{
if (status == HCI_SUCCESS)
BTM_TRACE_DEBUG("p_cb->irk_list_size = %d", p_cb->irk_avail_size);
- for (i = 0; i < BTM_CS_IRK_LIST_MAX; i ++)
+ for (i = 0; i < btm_cb.cmn_ble_vsc_cb.max_irk_list_sz; i ++)
memset(&p_cb->irk_list[i], 0, sizeof(tBTM_BLE_IRK_ENTRY));
}
}
p += (1 + 16 + 1); /* skip index, IRK value, address type */
STREAM_TO_BDADDR(target_bda, p);
STREAM_TO_BDADDR(rra, p);
-
-#if (defined BLE_VND_INCLUDED && BLE_VND_INCLUDED == TRUE)
btm_ble_refresh_rra(target_bda, rra);
-#endif
}
}
*******************************************************************************/
tBTM_STATUS btm_ble_remove_irk_entry(tBTM_SEC_DEV_REC *p_dev_rec)
{
+#if BLE_PRIVACY_SPT == TRUE
UINT8 param[20], *p;
tBTM_STATUS st;
tBTM_BLE_VENDOR_CB *p_cb = &btm_ble_vendor_cb;
}
return st;
-
+#endif
+ return BTM_MODE_UNSUPPORTED;
}
/*******************************************************************************
**
*******************************************************************************/
tBTM_STATUS btm_ble_vendor_clear_irk_list(void)
{
+#if BLE_PRIVACY_SPT == TRUE
UINT8 param[20], *p;
tBTM_STATUS st;
btm_ble_vendor_irk_vsc_op_cmpl);
return st;
-
+#endif
+ return BTM_MODE_UNSUPPORTED;
}
/*******************************************************************************
**
*******************************************************************************/
tBTM_STATUS btm_ble_read_irk_entry(BD_ADDR target_bda)
{
+#if BLE_PRIVACY_SPT == TRUE
UINT8 param[20], *p;
tBTM_STATUS st = BTM_UNKNOWN_ADDR;
tBTM_BLE_IRK_ENTRY *p_entry = btm_ble_vendor_find_irk_entry(target_bda);
btm_ble_vendor_irk_vsc_op_cmpl);
return st;
-
+#endif
+ return BTM_MODE_UNSUPPORTED;
}
*******************************************************************************/
void btm_ble_vendor_irk_list_known_dev(BOOLEAN enable)
{
+#if BLE_PRIVACY_SPT == TRUE
UINT8 i;
UINT8 count = 0;
tBTM_SEC_DEV_REC *p_dev_rec = &btm_cb.sec_dev_rec[0];
}
if ((count > 0 && enable) || !enable)
- BTM_BleEnableIRKFeature(enable);
-
+ btm_ble_vendor_enable_irk_feature(enable);
+#endif
return ;
}
/*******************************************************************************
*******************************************************************************/
BOOLEAN btm_ble_vendor_irk_list_load_dev(tBTM_SEC_DEV_REC *p_dev_rec)
{
+#if BLE_PRIVACY_SPT == TRUE
UINT8 param[40], *p;
tBTM_BLE_VENDOR_CB *p_cb = &btm_ble_vendor_cb;
BOOLEAN rt = FALSE;
BTM_TRACE_DEBUG("Device not a RPA enabled device");
}
return rt;
+#endif
+ return FALSE;
}
/*******************************************************************************
**
*******************************************************************************/
void btm_ble_vendor_irk_list_remove_dev(tBTM_SEC_DEV_REC *p_dev_rec)
{
+#if BLE_PRIVACY_SPT == TRUE
tBTM_BLE_VENDOR_CB *p_cs_cb = &btm_ble_vendor_cb;
tBTM_BLE_IRK_ENTRY *p_irk_entry;
}
if (p_cs_cb->irk_list_size == 0)
- BTM_BleEnableIRKFeature(FALSE);
+ btm_ble_vendor_enable_irk_feature(FALSE);
+#endif
}
/*******************************************************************************
**
*******************************************************************************/
void btm_ble_vendor_disable_irk_list(void)
{
- BTM_BleEnableIRKFeature(FALSE);
-
+#if BLE_PRIVACY_SPT == TRUE
+ btm_ble_vendor_enable_irk_feature(FALSE);
+#endif
}
/*******************************************************************************
**
-** Function BTM_BleEnableIRKFeature
+** Function btm_ble_vendor_enable_irk_feature
**
** Description This function is called to enable or disable the RRA
** offloading feature.
** Returns BTM_SUCCESS if successful
**
*******************************************************************************/
-tBTM_STATUS BTM_BleEnableIRKFeature(BOOLEAN enable)
+tBTM_STATUS btm_ble_vendor_enable_irk_feature(BOOLEAN enable)
{
+#if BLE_PRIVACY_SPT == TRUE
UINT8 param[20], *p;
tBTM_STATUS st = BTM_WRONG_MODE;
tBTM_BLE_PF_COUNT *p_bda_filter;
param, btm_ble_vendor_irk_vsc_op_cmpl);
return st;
+#endif
+ return BTM_MODE_UNSUPPORTED;
}
#endif
+
+/*******************************************************************************
+**
+** Function btm_ble_vendor_init
+**
+** Description Initialize customer specific feature information in host stack
+**
+** Parameters Max IRK list size
+** Max filter supported
+**
+** Returns void
+**
+*******************************************************************************/
+void btm_ble_vendor_init(UINT8 max_irk_list_sz)
+{
+ memset(&btm_ble_vendor_cb, 0, sizeof(tBTM_BLE_VENDOR_CB));
+
+#if BLE_PRIVACY_SPT == TRUE
+ if (max_irk_list_sz > 0)
+ {
+ btm_ble_vendor_cb.irk_list = (tBTM_BLE_IRK_ENTRY*)GKI_getbuf (sizeof (tBTM_BLE_IRK_ENTRY)
+ * max_irk_list_sz);
+ btm_ble_vendor_cb.irk_pend_q.irk_q = (BD_ADDR*) GKI_getbuf (sizeof (BD_ADDR) *
+ max_irk_list_sz);
+ btm_ble_vendor_cb.irk_pend_q.irk_q_random_pseudo = (BD_ADDR*)GKI_getbuf (sizeof (BD_ADDR) *
+ max_irk_list_sz);
+ btm_ble_vendor_cb.irk_pend_q.irk_q_action = (UINT8*) GKI_getbuf (max_irk_list_sz);
+ }
+
+ btm_ble_vendor_cb.irk_avail_size = max_irk_list_sz;
+
+ if (!HCI_LE_HOST_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_1]))
+ return;
+#endif
+}
+
+/*******************************************************************************
+**
+** Function btm_ble_vendor_cleanup
+**
+** Description Cleanup VSC specific dynamic memory
+**
+** Parameters
+**
+** Returns void
+**
+*******************************************************************************/
+void btm_ble_vendor_cleanup(void)
+{
+#if BLE_PRIVACY_SPT == TRUE
+ if (btm_ble_vendor_cb.irk_list)
+ GKI_freebuf(btm_ble_vendor_cb.irk_list);
+
+ if (btm_ble_vendor_cb.irk_pend_q.irk_q)
+ GKI_freebuf(btm_ble_vendor_cb.irk_pend_q.irk_q);
+
+ if (btm_ble_vendor_cb.irk_pend_q.irk_q_random_pseudo)
+ GKI_freebuf(btm_ble_vendor_cb.irk_pend_q.irk_q_random_pseudo);
+
+ if (btm_ble_vendor_cb.irk_pend_q.irk_q_action)
+ GKI_freebuf(btm_ble_vendor_cb.irk_pend_q.irk_q_action);
#endif
+ memset(&btm_ble_vendor_cb, 0, sizeof(tBTM_BLE_VENDOR_CB));
+}
+
+++ /dev/null
-
-/******************************************************************************
- *
- * Copyright (C) 2003-2014 Broadcom Corporation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at:
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- ******************************************************************************/
-
-/*****************************************************************************
-**
-** Name: bta_vendor_api.h
-**
-** Description: VENDOR custom Ble API Bluetooth application definitions
-**
-*****************************************************************************/
-#ifndef BTA_VENDOR_API_H
-#define BTA_VENDOR_API_H
-
-#include "bta_api.h"
-#include "bta_sys.h"
-#include "vendor_api.h"
-
-
-
-
-#if (BLE_INCLUDED == TRUE && BLE_ANDROID_CONTROLLER_SCAN_FILTER == TRUE)
-
-/*******************************************************************************
-**
-** Function BTA_BrcmInit
-**
-** Description This function initializes Broadcom specific VS handler in BTA
-**
-** Returns void
-**
-*******************************************************************************/
-BTA_API extern void BTA_BrcmInit (void);
-
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
-
-
-
#define BTM_BLE_PF_SRVC_DATA_PATTERN_BIT BTM_BLE_PF_BIT_TO_MASK(BTM_BLE_PF_SRVC_DATA_PATTERN)
typedef UINT8 tBTM_BLE_PF_SEL_MASK;
-
-#ifndef BTM_CS_IRK_LIST_MAX
-#define BTM_CS_IRK_LIST_MAX 0x20
-#endif
+#define BTM_BLE_MAX_FILTER_COUNTER (BTM_BLE_MAX_ADDR_FILTER + 1) /* per device filter + one generic filter indexed by 0 */
#define BTM_CS_IRK_LIST_INVALID 0xff
typedef struct
{
- BD_ADDR irk_q[BTM_CS_IRK_LIST_MAX];
- BD_ADDR irk_q_random_pseudo[BTM_CS_IRK_LIST_MAX];
- UINT8 irk_q_action[BTM_CS_IRK_LIST_MAX];
+ BD_ADDR *irk_q;
+ BD_ADDR *irk_q_random_pseudo;
+ UINT8 *irk_q_action;
UINT8 q_next;
UINT8 q_pending;
} tBTM_BLE_IRK_Q;
BOOLEAN enable;
UINT8 op_type;
- tBTM_BLE_PF_COUNT addr_filter_count[BTM_BLE_MAX_FILTER_COUNTER]; /* per BDA filter indexed by tBTM_BLE_PF_COND_TYPE */
tBLE_BD_ADDR cur_filter_target;
UINT8 irk_list_size;
UINT8 irk_avail_size;
- tBTM_BLE_IRK_ENTRY irk_list[BTM_CS_IRK_LIST_MAX];
+ tBTM_BLE_IRK_ENTRY *irk_list;
tBTM_BLE_IRK_Q irk_pend_q;
-
+ UINT8 max_filter_supported;
tBTM_BLE_PF_CMPL_CBACK *p_scan_pf_cback;
}tBTM_BLE_VENDOR_CB;
extern void btm_ble_vendor_irk_list_remove_dev(tBTM_SEC_DEV_REC *p_dev_rec);
extern tBTM_STATUS btm_ble_enable_vendor_feature (BOOLEAN enable, UINT32 feature_bit);
-extern void btm_ble_vendor_init(void);
+extern void btm_ble_vendor_init(UINT8 max_irk_list_sz);
+extern void btm_ble_vendor_cleanup(void);
extern BOOLEAN btm_ble_vendor_write_device_wl_attribute (tBLE_ADDR_TYPE addr_type, BD_ADDR bd_addr, UINT8 attribute);
+extern tBTM_STATUS btm_ble_vendor_enable_irk_feature(BOOLEAN enable);
+
#ifdef __cplusplus
}
#endif
OSDN Git Service
