| /****************************************************************************** |
| * |
| * 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: vendor_ble.c |
| ** |
| ** Description: This file contains vendor specific feature for BLE |
| ** |
| ******************************************************************************/ |
| #include <string.h> |
| #include "bt_target.h" |
| |
| #if (BLE_INCLUDED == TRUE && BLE_ANDROID_CONTROLLER_SCAN_FILTER == TRUE) |
| #include "bt_types.h" |
| #include "hcimsgs.h" |
| #include "btu.h" |
| #include "vendor_ble.h" |
| #include "vendor_hcidefs.h" |
| #include "gatt_int.h" |
| |
| #define BTM_BLE_INVALID_COUNTER 0xff |
| |
| |
| static UINT8 btm_ble_cs_update_pf_counter(tBTM_BLE_SCAN_COND_OP action, |
| UINT8 cond_type, |
| tBLE_BD_ADDR *p_bd_addr, |
| UINT8 num_available); |
| |
| #define BTM_BLE_SET_SCAN_PF_OPCODE(x, y) (((x)<<4)|y) |
| #define BTM_BLE_GET_SCAN_PF_SUBCODE(x) ((x) >> 4) |
| #define BTM_BLE_GET_SCAN_PF_ACTION(x) ((x) & 0x0f) |
| |
| /* max number of filter available for different filter type, controller dependent number */ |
| static const UINT8 btm_ble_cs_filter_max[BTM_BLE_PF_TYPE_MAX] = |
| { |
| BTM_BLE_MAX_ADDR_FILTER, /* address filter */ |
| 1, /* no limit for service data change, always enable or disable */ |
| BTM_BLE_MAX_UUID_FILTER, /* service UUID filter */ |
| BTM_BLE_MAX_UUID_FILTER, /* solicitated UUID filter */ |
| BTM_BLE_PF_STR_COND_MAX, /* local name filter */ |
| BTM_BLE_PF_STR_COND_MAX /* manufacturer data filter */ |
| }; |
| |
| /*** This needs to be moved to a VSC control block eventually per coding conventions ***/ |
| #if VENDOR_DYNAMIC_MEMORY == FALSE |
| tBTM_BLE_VENDOR_CB btm_ble_vendor_cb; |
| #endif |
| |
| static const UINT8 op_code_to_cond_type[] = |
| { |
| BTM_BLE_PF_TYPE_ALL, |
| BTM_BLE_PF_ADDR_FILTER, |
| BTM_BLE_PF_SRVC_UUID, |
| BTM_BLE_PF_SRVC_SOL_UUID, |
| BTM_BLE_PF_LOCAL_NAME, |
| BTM_BLE_PF_MANU_DATA, |
| BTM_BLE_PF_SRVC_DATA_PATTERN |
| }; |
| |
| static const BD_ADDR na_bda= {0}; |
| |
| /******************************************************************************* |
| ** |
| ** Function btm_ble_vendor_scan_pf_cmpl_cback |
| ** |
| ** Description the BTM BLE customer feature VSC complete callback for ADV PF |
| ** filtering |
| ** |
| ** Returns pointer to the counter if found; NULL otherwise. |
| ** |
| *******************************************************************************/ |
| void btm_ble_vendor_scan_pf_cmpl_cback(tBTM_VSC_CMPL *p_params) |
| { |
| UINT8 status; |
| UINT8 *p = p_params->p_param_buf, op_subcode, action = 0xff; |
| UINT16 evt_len = p_params->param_len; |
| UINT8 num_avail = 0, cond_type = BTM_BLE_PF_TYPE_MAX; |
| tBTM_BLE_PF_CMPL_CBACK *p_cmpl_cback = btm_ble_vendor_cb.p_scan_pf_cback; |
| UINT8 op = BTM_BLE_GET_SCAN_PF_ACTION(btm_ble_vendor_cb.op_type); |
| UINT8 subcode = BTM_BLE_GET_SCAN_PF_SUBCODE(btm_ble_vendor_cb.op_type); |
| |
| STREAM_TO_UINT8(status, p); |
| |
| evt_len--; |
| |
| if (evt_len < 1 ) |
| { |
| BTM_TRACE_ERROR1("can not interpret ADV PF filter setting callback. status = %d", status); |
| return; |
| } |
| op_subcode = *p ++; |
| |
| switch (op_subcode) |
| { |
| case BTM_BLE_META_PF_LOCAL_NAME: |
| case BTM_BLE_META_PF_MANU_DATA: |
| case BTM_BLE_META_PF_ADDR: |
| case BTM_BLE_META_PF_UUID: |
| case BTM_BLE_META_PF_SOL_UUID: |
| case BTM_BLE_META_PF_FEAT_SEL: |
| case BTM_BLE_META_PF_SRVC_DATA: |
| cond_type = op_code_to_cond_type[op_subcode - BTM_BLE_META_PF_FEAT_SEL]; |
| if (status == HCI_SUCCESS) |
| { |
| action = *p ++; |
| if (op_subcode != BTM_BLE_META_PF_FEAT_SEL) |
| { |
| STREAM_TO_UINT8(num_avail, p); |
| } |
| |
| if (memcmp(&btm_ble_vendor_cb.cur_filter_target.bda, &na_bda, BD_ADDR_LEN) == 0) |
| btm_ble_cs_update_pf_counter(action, cond_type, NULL, num_avail); |
| else |
| btm_ble_cs_update_pf_counter(action, cond_type, &btm_ble_vendor_cb.cur_filter_target, num_avail); |
| } |
| break; |
| |
| case BTM_BLE_META_PF_ENABLE: |
| cond_type = BTM_BLE_META_PF_ENABLE; |
| BTM_TRACE_DEBUG0("CS feature Enabled"); |
| break; |
| |
| default: |
| BTM_TRACE_ERROR1("unknow operation: %d", op_subcode); |
| break; |
| } |
| |
| /* send ADV PF opeartion complete */ |
| if (p_cmpl_cback && subcode == cond_type) |
| { |
| btm_ble_vendor_cb.p_scan_pf_cback = NULL; |
| btm_ble_vendor_cb.op_type = 0; |
| (* p_cmpl_cback)(op, subcode, status); |
| } |
| } |
| /******************************************************************************* |
| ** adv payload filtering functions |
| *******************************************************************************/ |
| /******************************************************************************* |
| ** |
| ** Function btm_ble_find_addr_filter_counter |
| ** |
| ** Description find the per bd address ADV payload filter counter by BD_ADDR. |
| ** |
| ** Returns pointer to the counter if found; NULL otherwise. |
| ** |
| *******************************************************************************/ |
| 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_vendor_cb.addr_filter_count[1]; |
| |
| if (p_le_bda == NULL) |
| return &btm_ble_vendor_cb.addr_filter_count[0]; |
| |
| for (i = 0; i < BTM_BLE_MAX_FILTER_COUNTER; i ++, p_addr_filter ++) |
| { |
| if (p_addr_filter->in_use && |
| memcmp(p_le_bda->bda, p_addr_filter->bd_addr, BD_ADDR_LEN) == 0) |
| { |
| return p_addr_filter; |
| } |
| } |
| return NULL; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function btm_ble_alloc_addr_filter_counter |
| ** |
| ** Description allocate the per device adv payload filter counter. |
| ** |
| ** Returns pointer to the counter if allocation succeed; NULL otherwise. |
| ** |
| *******************************************************************************/ |
| 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_vendor_cb.addr_filter_count[1]; |
| |
| for (i = 0; i < BTM_BLE_MAX_FILTER_COUNTER; i ++, p_addr_filter ++) |
| { |
| if (memcmp(na_bda, p_addr_filter->bd_addr, BD_ADDR_LEN) == 0) |
| { |
| memcpy(p_addr_filter->bd_addr, bd_addr, BD_ADDR_LEN); |
| p_addr_filter->in_use = TRUE; |
| return p_addr_filter; |
| } |
| } |
| return NULL; |
| } |
| /******************************************************************************* |
| ** |
| ** Function btm_ble_dealloc_addr_filter_counter |
| ** |
| ** Description de-allocate the per device adv payload filter counter. |
| ** |
| ** Returns TRUE if deallocation succeed; FALSE otherwise. |
| ** |
| *******************************************************************************/ |
| 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_vendor_cb.addr_filter_count[1]; |
| BOOLEAN found = FALSE; |
| |
| if (filter_type == BTM_BLE_PF_TYPE_ALL && p_bd_addr == NULL) |
| memset(&btm_ble_vendor_cb.addr_filter_count[0], 0, sizeof(tBTM_BLE_PF_COUNT)); |
| |
| for (i = 0; i < BTM_BLE_MAX_FILTER_COUNTER; i ++, p_addr_filter ++) |
| { |
| if ((p_addr_filter->in_use) && |
| (p_bd_addr == NULL || |
| (p_bd_addr != NULL && memcmp(p_bd_addr->bda, p_addr_filter->bd_addr, BD_ADDR_LEN) == 0))) |
| { |
| found = TRUE; |
| memset(p_addr_filter, 0, sizeof(tBTM_BLE_PF_COUNT)); |
| |
| if (p_bd_addr != NULL) break; |
| } |
| } |
| return found; |
| } |
| /******************************************************************************* |
| ** |
| ** Function btm_ble_cs_update_pf_counter |
| ** |
| ** Description this function is to update the adv data payload filter counter |
| ** |
| ** Returns current number of the counter; BTM_BLE_INVALID_COUNTER if |
| ** counter update failed. |
| ** |
| *******************************************************************************/ |
| UINT8 btm_ble_cs_update_pf_counter(tBTM_BLE_SCAN_COND_OP action, |
| UINT8 cond_type, |
| tBLE_BD_ADDR *p_bd_addr, |
| UINT8 num_available) |
| { |
| tBTM_BLE_PF_COUNT *p_addr_filter = NULL; |
| UINT8 *p_counter = NULL; |
| UINT32 *p_feat_mask = NULL; |
| |
| |
| if (cond_type > BTM_BLE_PF_TYPE_ALL) |
| { |
| BTM_TRACE_ERROR1("unknown PF filter condition type %d", cond_type); |
| return BTM_BLE_INVALID_COUNTER; |
| } |
| /* for these three types of filter, always generic */ |
| if (cond_type == BTM_BLE_PF_ADDR_FILTER || |
| cond_type == BTM_BLE_PF_MANU_DATA || |
| cond_type == BTM_BLE_PF_LOCAL_NAME || |
| cond_type == BTM_BLE_PF_SRVC_DATA_PATTERN) |
| p_bd_addr = NULL; |
| |
| if ((p_addr_filter = btm_ble_find_addr_filter_counter(p_bd_addr)) == NULL && |
| action == BTM_BLE_SCAN_COND_ADD) |
| { |
| p_addr_filter = btm_ble_alloc_addr_filter_counter(p_bd_addr->bda); |
| } |
| |
| if (p_addr_filter != NULL) |
| { |
| /* all filter just cleared */ |
| if ((cond_type == BTM_BLE_PF_TYPE_ALL && action == BTM_BLE_SCAN_COND_CLEAR) || |
| /* or bd address filter been deleted */ |
| (cond_type == BTM_BLE_PF_ADDR_FILTER && |
| (action == BTM_BLE_SCAN_COND_DELETE || action == BTM_BLE_SCAN_COND_CLEAR))) |
| { |
| btm_ble_dealloc_addr_filter_counter(p_bd_addr, cond_type); |
| } |
| /* if not feature selection, update new addition/reduction of the filter counter */ |
| else if (cond_type != BTM_BLE_PF_TYPE_ALL) |
| { |
| p_counter = p_addr_filter->pf_counter; |
| p_feat_mask = &p_addr_filter->feat_mask; |
| |
| p_counter[cond_type] = btm_ble_cs_filter_max[cond_type] - num_available; |
| |
| BTM_TRACE_DEBUG1("current filter counter number = %d", p_counter[cond_type]); |
| |
| /* update corresponding feature mask */ |
| if (p_counter[cond_type] > 0) |
| *p_feat_mask |= (BTM_BLE_PF_BIT_TO_MASK(cond_type)); |
| else |
| *p_feat_mask &= ~(BTM_BLE_PF_BIT_TO_MASK(cond_type)); |
| |
| return p_counter[cond_type]; |
| } |
| } |
| else |
| { |
| BTM_TRACE_ERROR0("no matching filter counter found"); |
| } |
| /* no matching filter located and updated */ |
| return BTM_BLE_INVALID_COUNTER; |
| } |
| /******************************************************************************* |
| ** |
| ** Function btm_ble_update_pf_manu_data |
| ** |
| ** Description this function update(add,delete or clear) the adv manufacturer |
| ** data filtering condition. |
| ** |
| ** |
| ** Returns BTM_SUCCESS if sucessful, |
| ** BTM_ILLEGAL_VALUE if paramter is not valid. |
| ** |
| *******************************************************************************/ |
| tBTM_STATUS btm_ble_update_pf_manu_data(tBTM_BLE_SCAN_COND_OP action, |
| tBTM_BLE_PF_COND_PARAM *p_data, |
| tBTM_BLE_PF_COND_TYPE cond_type) |
| { |
| tBTM_BLE_PF_MANU_COND *p_manu_data = (p_data == NULL) ? NULL : &p_data->manu_data; |
| tBTM_BLE_PF_SRVC_PATTERN_COND *p_srvc_data = (p_data == NULL) ? NULL : &p_data->srvc_data; |
| UINT8 param[BTM_BLE_PF_STR_LEN_MAX + BTM_BLE_PF_STR_LEN_MAX + BTM_BLE_META_HDR_LENGTH], |
| *p = param, |
| len = BTM_BLE_META_HDR_LENGTH; |
| tBTM_STATUS st = BTM_ILLEGAL_VALUE; |
| |
| memset(param, 0, BTM_BLE_PF_STR_LEN_MAX + BTM_BLE_META_HDR_LENGTH); |
| |
| if (cond_type == BTM_BLE_PF_SRVC_DATA_PATTERN) |
| { |
| UINT8_TO_STREAM(p, BTM_BLE_META_PF_SRVC_DATA); |
| } |
| else |
| { |
| UINT8_TO_STREAM(p, BTM_BLE_META_PF_MANU_DATA); |
| } |
| UINT8_TO_STREAM(p, action); |
| |
| if (action == BTM_BLE_SCAN_COND_ADD || |
| action == BTM_BLE_SCAN_COND_DELETE) |
| { |
| if (p_manu_data == NULL) |
| return st; |
| if (cond_type == BTM_BLE_PF_SRVC_DATA_PATTERN) |
| { |
| 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); |
| |
| UINT16_TO_STREAM(p, p_srvc_data->uuid); |
| ARRAY_TO_STREAM(p, p_srvc_data->p_pattern, p_srvc_data->data_len); |
| len += (p_srvc_data->data_len + 2); |
| } |
| else |
| { |
| if (p_manu_data->data_len > (BTM_BLE_PF_STR_LEN_MAX - 2)) |
| p_manu_data->data_len = (BTM_BLE_PF_STR_LEN_MAX - 2); |
| |
| UINT16_TO_STREAM(p, p_manu_data->company_id); |
| ARRAY_TO_STREAM(p, p_manu_data->p_pattern, p_manu_data->data_len); |
| len += (p_manu_data->data_len + 2); |
| |
| if (p_manu_data->company_id_mask != 0) |
| { |
| UINT16_TO_STREAM (p, p_manu_data->company_id_mask); |
| } |
| else |
| { |
| memset(p, 0xff, 2); |
| p += 2; |
| } |
| if (p_manu_data->p_pattern_mask != NULL) |
| { |
| ARRAY_TO_STREAM(p, p_manu_data->p_pattern_mask, p_manu_data->data_len); |
| } |
| else |
| memset(p, 0xff, p_manu_data->data_len); |
| len += (p_manu_data->data_len + 2); |
| } |
| } |
| |
| /* send manufacturer*/ |
| if ((st = BTM_VendorSpecificCommand (HCI_VENDOR_BLE_PCF_VSC, |
| len, |
| param, |
| btm_ble_vendor_scan_pf_cmpl_cback)) != BTM_NO_RESOURCES) |
| { |
| memset(&btm_ble_vendor_cb.cur_filter_target, 0, sizeof(tBLE_BD_ADDR)); |
| } |
| else |
| { |
| BTM_TRACE_ERROR0("manufacturer data PF filter update failed"); |
| } |
| |
| return st; |
| } |
| /******************************************************************************* |
| ** |
| ** Function btm_ble_update_pf_local_name |
| ** |
| ** Description this function update(add,delete or clear) the adv lcoal name |
| ** filtering condition. |
| ** |
| ** |
| ** Returns BTM_SUCCESS if sucessful, |
| ** BTM_ILLEGAL_VALUE if paramter is not valid. |
| ** |
| *******************************************************************************/ |
| tBTM_STATUS btm_ble_update_pf_local_name(tBTM_BLE_SCAN_COND_OP action, |
| tBTM_BLE_PF_COND_PARAM *p_cond) |
| { |
| tBTM_BLE_PF_LOCAL_NAME_COND *p_local_name = (p_cond == NULL) ? NULL : &p_cond->local_name; |
| UINT8 param[BTM_BLE_PF_STR_LEN_MAX + BTM_BLE_META_HDR_LENGTH], |
| *p = param, |
| len = BTM_BLE_META_HDR_LENGTH; |
| tBTM_STATUS st = BTM_ILLEGAL_VALUE; |
| |
| memset(param, 0, BTM_BLE_PF_STR_LEN_MAX + BTM_BLE_META_HDR_LENGTH); |
| |
| UINT8_TO_STREAM(p, BTM_BLE_META_PF_LOCAL_NAME); |
| UINT8_TO_STREAM(p, action); |
| |
| if (action == BTM_BLE_SCAN_COND_ADD || |
| action == BTM_BLE_SCAN_COND_DELETE) |
| { |
| if (p_local_name == NULL) |
| return st; |
| |
| if (p_local_name->data_len > BTM_BLE_PF_STR_LEN_MAX) |
| p_local_name->data_len = BTM_BLE_PF_STR_LEN_MAX; |
| |
| ARRAY_TO_STREAM(p, p_local_name->p_data, p_local_name->data_len); |
| len += p_local_name->data_len; |
| } |
| /* send local name filter */ |
| if ((st = BTM_VendorSpecificCommand (HCI_VENDOR_BLE_PCF_VSC, |
| len, |
| param, |
| btm_ble_vendor_scan_pf_cmpl_cback)) |
| != BTM_NO_RESOURCES) |
| { |
| memset(&btm_ble_vendor_cb.cur_filter_target, 0, sizeof(tBLE_BD_ADDR)); |
| } |
| else |
| { |
| BTM_TRACE_ERROR0("Local Name PF filter update failed"); |
| } |
| |
| return st; |
| } |
| /******************************************************************************* |
| ** |
| ** Function btm_ble_update_addr_filter |
| ** |
| ** Description this function update(add,delete or clear) the address filter of adv. |
| ** |
| ** |
| ** Returns BTM_SUCCESS if sucessful, |
| ** BTM_ILLEGAL_VALUE if paramter is not valid. |
| ** |
| *******************************************************************************/ |
| tBTM_STATUS btm_ble_update_addr_filter(tBTM_BLE_SCAN_COND_OP action, |
| tBTM_BLE_PF_COND_PARAM *p_cond) |
| { |
| UINT8 param[BTM_BLE_META_ADDR_LEN + BTM_BLE_META_HDR_LENGTH], |
| * p= param; |
| tBTM_STATUS st = BTM_ILLEGAL_VALUE; |
| tBLE_BD_ADDR *p_addr = (p_cond == NULL) ? NULL : &p_cond->target_addr; |
| |
| memset(param, 0, BTM_BLE_META_ADDR_LEN + BTM_BLE_META_HDR_LENGTH); |
| |
| UINT8_TO_STREAM(p, BTM_BLE_META_PF_ADDR); |
| UINT8_TO_STREAM(p, action); |
| |
| if (action == BTM_BLE_SCAN_COND_ADD || |
| action == BTM_BLE_SCAN_COND_DELETE) |
| { |
| if (p_addr == NULL) |
| return st; |
| |
| BDADDR_TO_STREAM(p, p_addr->bda); |
| UINT8_TO_STREAM(p, p_addr->type); |
| } |
| /* send address filter */ |
| if ((st = BTM_VendorSpecificCommand (HCI_VENDOR_BLE_PCF_VSC, |
| (UINT8)(BTM_BLE_META_HDR_LENGTH + BTM_BLE_META_ADDR_LEN), |
| param, |
| btm_ble_vendor_scan_pf_cmpl_cback)) != BTM_NO_RESOURCES) |
| { |
| memset(&btm_ble_vendor_cb.cur_filter_target, 0, sizeof(tBLE_BD_ADDR)); |
| } |
| else |
| { |
| BTM_TRACE_ERROR0("Broadcaster Address Filter Update failed"); |
| } |
| return st; |
| } |
| /******************************************************************************* |
| ** |
| ** Function btm_ble_update_uuid_filter |
| ** |
| ** Description this function update(add,delete or clear) service UUID filter. |
| ** |
| ** |
| ** Returns BTM_SUCCESS if sucessful, |
| ** BTM_ILLEGAL_VALUE if paramter is not valid. |
| ** |
| *******************************************************************************/ |
| tBTM_STATUS btm_ble_update_uuid_filter(tBTM_BLE_SCAN_COND_OP action, |
| tBTM_BLE_PF_COND_TYPE filter_type, |
| tBTM_BLE_PF_COND_PARAM *p_cond) |
| { |
| UINT8 param[BTM_BLE_META_UUID_LEN + BTM_BLE_META_HDR_LENGTH], |
| * p= param, |
| len = BTM_BLE_META_HDR_LENGTH + 7; |
| tBTM_STATUS st = BTM_ILLEGAL_VALUE; |
| tBTM_BLE_PF_UUID_COND *p_uuid_cond; |
| UINT8 evt_type; |
| |
| memset(param, 0, BTM_BLE_META_UUID_LEN + BTM_BLE_META_HDR_LENGTH); |
| |
| if (filter_type == BTM_BLE_PF_SRVC_UUID) |
| { |
| evt_type = BTM_BLE_META_PF_UUID; |
| p_uuid_cond = p_cond ? &p_cond->srvc_uuid : NULL; |
| } |
| else |
| { |
| evt_type = BTM_BLE_META_PF_SOL_UUID; |
| p_uuid_cond = p_cond ? &p_cond->solicitate_uuid : NULL; |
| } |
| |
| if (p_uuid_cond == NULL && action != BTM_BLE_SCAN_COND_CLEAR) |
| { |
| BTM_TRACE_ERROR0("Illegal param for add/delete UUID filter"); |
| return st; |
| } |
| |
| /* need to add address fitler first, if adding per bda UUID filter without address filter */ |
| if (action == BTM_BLE_SCAN_COND_ADD && |
| p_uuid_cond->p_target_addr && |
| btm_ble_find_addr_filter_counter(p_uuid_cond->p_target_addr) == NULL) |
| { |
| UINT8_TO_STREAM(p, BTM_BLE_META_PF_ADDR); |
| UINT8_TO_STREAM(p, action); |
| |
| BDADDR_TO_STREAM(p, p_uuid_cond->p_target_addr->bda); |
| UINT8_TO_STREAM(p, p_uuid_cond->p_target_addr->type); |
| |
| /* send address filter */ |
| if ((st = BTM_VendorSpecificCommand (HCI_VENDOR_BLE_PCF_VSC, |
| (UINT8)(BTM_BLE_META_HDR_LENGTH + BTM_BLE_META_ADDR_LEN), |
| param, |
| btm_ble_vendor_scan_pf_cmpl_cback)) == BTM_NO_RESOURCES) |
| { |
| BTM_TRACE_ERROR0("Update Address filter into controller failed."); |
| return st; |
| } |
| } |
| |
| p= param; |
| UINT8_TO_STREAM(p, evt_type); |
| UINT8_TO_STREAM(p, action); |
| |
| /* per BD ADDR UUID filter */ |
| if (p_uuid_cond && p_uuid_cond->p_target_addr) |
| { |
| BDADDR_TO_STREAM(p, p_uuid_cond->p_target_addr->bda); |
| UINT8_TO_STREAM(p, p_uuid_cond->p_target_addr->type); |
| } |
| else /* generic UUID filter */ |
| { |
| BDADDR_TO_STREAM(p, na_bda); |
| UINT8_TO_STREAM(p, 0x02); |
| } |
| |
| if (action == BTM_BLE_SCAN_COND_ADD || |
| action == BTM_BLE_SCAN_COND_DELETE) |
| { |
| UINT8_TO_STREAM(p, p_uuid_cond->cond_logic); |
| len ++; |
| |
| if (p_uuid_cond->uuid.len == LEN_UUID_16) |
| { |
| UINT16_TO_STREAM(p, p_uuid_cond->uuid.uu.uuid16); |
| len += LEN_UUID_16; |
| } |
| else if (p_uuid_cond->uuid.len == LEN_UUID_32)/*4 bytes */ |
| { |
| UINT32_TO_STREAM(p, p_uuid_cond->uuid.uu.uuid32); |
| len += LEN_UUID_32; |
| } |
| else if (p_uuid_cond->uuid.len == LEN_UUID_128) |
| { |
| ARRAY_TO_STREAM (p, p_uuid_cond->uuid.uu.uuid128, LEN_UUID_128); |
| len += LEN_UUID_128; |
| } |
| else |
| { |
| BTM_TRACE_ERROR1("illegal UUID length: %d", p_uuid_cond->uuid.len); |
| return BTM_ILLEGAL_VALUE; |
| } |
| #if !(defined VENDOR_ADV_PCF_LEGACY && VENDOR_ADV_PCF_LEGACY == TRUE) |
| if (p_uuid_cond->p_uuid_mask != NULL) |
| { |
| if (p_uuid_cond->uuid.len == LEN_UUID_16) |
| { |
| UINT16_TO_STREAM(p, p_uuid_cond->p_uuid_mask->uuid16_mask); |
| len += LEN_UUID_16; |
| } |
| else if (p_uuid_cond->uuid.len == LEN_UUID_32)/*4 bytes */ |
| { |
| UINT32_TO_STREAM(p, p_uuid_cond->p_uuid_mask->uuid32_mask); |
| len += LEN_UUID_32; |
| } |
| else if (p_uuid_cond->uuid.len == LEN_UUID_128) |
| { |
| ARRAY_TO_STREAM (p, p_uuid_cond->p_uuid_mask->uuid128_mask, LEN_UUID_128); |
| len += LEN_UUID_128; |
| } |
| } |
| else |
| { |
| memset(p, 0xff, p_uuid_cond->uuid.len); |
| len += p_uuid_cond->uuid.len; |
| } |
| #endif |
| } |
| |
| /* send UUID filter update */ |
| if ((st = BTM_VendorSpecificCommand (HCI_VENDOR_BLE_PCF_VSC, |
| len, |
| param, |
| btm_ble_vendor_scan_pf_cmpl_cback)) != BTM_NO_RESOURCES) |
| { |
| if (p_uuid_cond && p_uuid_cond->p_target_addr) |
| memcpy(&btm_ble_vendor_cb.cur_filter_target, p_uuid_cond->p_target_addr, sizeof(tBLE_BD_ADDR)); |
| else |
| memset(&btm_ble_vendor_cb.cur_filter_target, 0, sizeof(tBLE_BD_ADDR)); |
| } |
| else |
| { |
| BTM_TRACE_ERROR0("UUID filter udpating failed"); |
| } |
| |
| return st; |
| } |
| /******************************************************************************* |
| ** |
| ** Function btm_ble_update_srvc_data_change |
| ** |
| ** Description this function update(add/remove) service data change filter. |
| ** |
| ** |
| ** Returns BTM_SUCCESS if sucessful, |
| ** BTM_ILLEGAL_VALUE if paramter is not valid. |
| ** |
| *******************************************************************************/ |
| tBTM_STATUS btm_ble_update_srvc_data_change(tBTM_BLE_SCAN_COND_OP action, |
| tBTM_BLE_PF_COND_PARAM *p_cond) |
| { |
| tBTM_STATUS st = BTM_ILLEGAL_VALUE; |
| tBLE_BD_ADDR *p_bd_addr = p_cond ? &p_cond->target_addr : NULL; |
| UINT8 num_avail = (action == BTM_BLE_SCAN_COND_ADD) ? 0 : 1; |
| |
| if (btm_ble_cs_update_pf_counter (action, BTM_BLE_PF_SRVC_DATA, p_bd_addr, num_avail) |
| != BTM_BLE_INVALID_COUNTER) |
| st = BTM_SUCCESS; |
| |
| return st; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function btm_ble_clear_scan_pf_filter |
| ** |
| ** Description clear all adv payload filter by de-select all the adv pf feature bits |
| ** |
| ** |
| ** Returns BTM_SUCCESS if sucessful, |
| ** BTM_ILLEGAL_VALUE if paramter is not valid. |
| ** |
| *******************************************************************************/ |
| tBTM_STATUS btm_ble_clear_scan_pf_filter(tBTM_BLE_SCAN_COND_OP action, |
| tBTM_BLE_PF_COND_PARAM *p_cond) |
| { |
| tBLE_BD_ADDR *p_target = (p_cond == NULL)? NULL : &p_cond->target_addr; |
| tBTM_BLE_PF_COUNT *p_bda_filter; |
| tBTM_STATUS st = BTM_WRONG_MODE; |
| UINT8 param[20], *p; |
| |
| if (action != BTM_BLE_SCAN_COND_CLEAR) |
| { |
| BTM_TRACE_ERROR1("unable to perform action:%d for generic adv filter type", action); |
| return BTM_ILLEGAL_VALUE; |
| } |
| |
| p = param; |
| memset(param, 0, 20); |
| |
| p_bda_filter = btm_ble_find_addr_filter_counter(p_target); |
| |
| if (p_bda_filter == NULL || |
| /* not a generic filter, and feature selection is empty */ |
| (p_target != NULL && p_bda_filter && p_bda_filter->feat_mask == 0)) |
| { |
| BTM_TRACE_ERROR0("Error: Can not clear filter, No PF filter has been configured!"); |
| return st; |
| } |
| |
| /* clear the general filter entry */ |
| if (p_target == NULL) |
| { |
| /* clear manufactuer data filter */ |
| btm_ble_update_pf_manu_data(BTM_BLE_SCAN_COND_CLEAR, NULL, BTM_BLE_PF_MANU_DATA); |
| /* clear local name filter */ |
| btm_ble_update_pf_local_name(BTM_BLE_SCAN_COND_CLEAR, NULL); |
| /* update the counter for service data */ |
| btm_ble_update_srvc_data_change(BTM_BLE_SCAN_COND_CLEAR, NULL); |
| /* clear UUID filter */ |
| btm_ble_update_uuid_filter(BTM_BLE_SCAN_COND_CLEAR, BTM_BLE_PF_SRVC_UUID, NULL); |
| btm_ble_update_uuid_filter(BTM_BLE_SCAN_COND_CLEAR, BTM_BLE_META_PF_SOL_UUID, NULL); |
| /* clear service data filter */ |
| btm_ble_update_pf_manu_data(BTM_BLE_SCAN_COND_CLEAR, NULL, BTM_BLE_PF_MANU_DATA); |
| } |
| |
| /* 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_CLEAR); |
| |
| if (p_target != NULL) |
| { |
| BDADDR_TO_STREAM(p, p_target->bda); |
| UINT8_TO_STREAM(p, p_target->type); |
| } |
| else |
| { |
| BDADDR_TO_STREAM(p, na_bda); |
| UINT8_TO_STREAM(p, 0x02); |
| } |
| |
| /* set PCF selection */ |
| UINT32_TO_STREAM(p, BTM_BLE_PF_SELECT_NONE); |
| /* set logic condition as OR as default */ |
| UINT8_TO_STREAM(p, BTM_BLE_PF_LOGIC_OR); |
| |
| if ((st = BTM_VendorSpecificCommand (HCI_VENDOR_BLE_PCF_VSC, |
| (UINT8)(BTM_BLE_META_HDR_LENGTH + BTM_BLE_PF_FEAT_SEL_LEN), |
| param, |
| btm_ble_vendor_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_vendor_cb.cur_filter_target, p_target, sizeof(tBLE_BD_ADDR)); |
| else |
| memset(&btm_ble_vendor_cb.cur_filter_target, 0, sizeof(tBLE_BD_ADDR)); |
| } |
| |
| return st; |
| } |
| /******************************************************************************* |
| ** |
| ** Function BTM_BleEnableFilterCondition |
| ** |
| ** 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 |
| ** |
| *******************************************************************************/ |
| tBTM_STATUS BTM_BleEnableFilterCondition(BOOLEAN enable, tBLE_BD_ADDR *p_target, |
| tBTM_BLE_PF_CMPL_CBACK *p_cmpl_cback) |
| { |
| UINT8 param[20], *p; |
| tBTM_STATUS st = BTM_WRONG_MODE; |
| tBTM_BLE_PF_COUNT *p_bda_filter; |
| |
| p = param; |
| memset(param, 0, 20); |
| |
| if (btm_ble_vendor_cb.p_scan_pf_cback) |
| { |
| BTM_TRACE_ERROR0("ADV PF Filter activity busy"); |
| return BTM_BUSY; |
| } |
| |
| if (enable) |
| { |
| p_bda_filter = btm_ble_find_addr_filter_counter(p_target); |
| |
| if (p_bda_filter == NULL || |
| (p_bda_filter && p_bda_filter->feat_mask == BTM_BLE_PF_SELECT_NONE)) |
| { |
| BTM_TRACE_ERROR0("No PF filter has been configured!"); |
| return st; |
| } |
| |
| /* 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); |
| |
| if (p_target != NULL) |
| { |
| BDADDR_TO_STREAM(p, p_target->bda); |
| UINT8_TO_STREAM(p, p_target->type); |
| } |
| else |
| { |
| BDADDR_TO_STREAM(p, na_bda); |
| UINT8_TO_STREAM(p, 0x02); |
| } |
| |
| /* set PCF selection */ |
| UINT32_TO_STREAM(p, p_bda_filter->feat_mask); |
| /* set logic condition as OR as default */ |
| UINT8_TO_STREAM(p, BTM_BLE_PF_LOGIC_OR); |
| |
| if ((st = BTM_VendorSpecificCommand (HCI_VENDOR_BLE_PCF_VSC, |
| (UINT8)(BTM_BLE_META_HDR_LENGTH + BTM_BLE_PF_FEAT_SEL_LEN), |
| param, |
| btm_ble_vendor_scan_pf_cmpl_cback)) |
| == BTM_NO_RESOURCES) |
| { |
| return st; |
| } |
| |
| /* enable the content filter in controller */ |
| p = param; |
| UINT8_TO_STREAM(p, BTM_BLE_META_PF_ENABLE); |
| /* enable adv data payload filtering */ |
| UINT8_TO_STREAM(p, enable); |
| } |
| else |
| { |
| UINT8_TO_STREAM(p, BTM_BLE_META_PF_ENABLE); |
| /* disable adv data payload filtering */ |
| UINT8_TO_STREAM(p, enable); |
| } |
| |
| if ((st = BTM_VendorSpecificCommand (HCI_VENDOR_BLE_PCF_VSC, |
| BTM_BLE_PCF_ENABLE_LEN, |
| param, |
| btm_ble_vendor_scan_pf_cmpl_cback)) |
| == BTM_CMD_STARTED) |
| { |
| btm_ble_vendor_cb.op_type = BTM_BLE_SET_SCAN_PF_OPCODE(BTM_BLE_META_PF_ENABLE, BTM_BLE_PF_ENABLE); |
| btm_ble_vendor_cb.p_scan_pf_cback = p_cmpl_cback; |
| } |
| |
| return st; |
| } |
| /******************************************************************************* |
| ** |
| ** Function BTM_BleCfgFilterCondition |
| ** |
| ** 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 |
| ** |
| *******************************************************************************/ |
| tBTM_STATUS BTM_BleCfgFilterCondition(tBTM_BLE_SCAN_COND_OP action, |
| tBTM_BLE_PF_COND_TYPE cond_type, |
| tBTM_BLE_PF_COND_PARAM *p_cond, |
| tBTM_BLE_PF_CMPL_CBACK *p_cmpl_cback) |
| { |
| tBTM_STATUS st = BTM_ILLEGAL_VALUE; |
| |
| if (btm_ble_vendor_cb.p_scan_pf_cback != NULL) |
| return BTM_BUSY; |
| |
| switch (cond_type) |
| { |
| case BTM_BLE_PF_SRVC_DATA_PATTERN: |
| /* write manufacture data filter */ |
| case BTM_BLE_PF_MANU_DATA: |
| st = btm_ble_update_pf_manu_data(action, p_cond, cond_type); |
| break; |
| |
| /* write local name filter */ |
| case BTM_BLE_PF_LOCAL_NAME: |
| st = btm_ble_update_pf_local_name(action, p_cond); |
| break; |
| |
| /* filter on advertiser address */ |
| case BTM_BLE_PF_ADDR_FILTER: |
| st = btm_ble_update_addr_filter(action, p_cond); |
| break; |
| |
| /* filter on service/solicitated UUID */ |
| case BTM_BLE_PF_SRVC_UUID: |
| case BTM_BLE_PF_SRVC_SOL_UUID: |
| st = btm_ble_update_uuid_filter(action, cond_type, p_cond); |
| break; |
| |
| case BTM_BLE_PF_SRVC_DATA: |
| st = btm_ble_update_srvc_data_change(action, p_cond); |
| break; |
| |
| case BTM_BLE_PF_TYPE_ALL: /* only used to clear filter */ |
| st = btm_ble_clear_scan_pf_filter(action, p_cond); |
| break; |
| |
| default: |
| BTM_TRACE_WARNING1("condition type [%d] not supported currently.", cond_type); |
| break; |
| } |
| if (st == BTM_CMD_STARTED |
| /* no vsc needed for service data change */ |
| && cond_type != BTM_BLE_PF_SRVC_DATA) |
| { |
| btm_ble_vendor_cb.op_type = BTM_BLE_SET_SCAN_PF_OPCODE(cond_type, BTM_BLE_PF_CONFIG); |
| btm_ble_vendor_cb.p_scan_pf_cback = p_cmpl_cback; |
| } |
| |
| return st; |
| } |
| |
| |
| /******************************************************************************* |
| ** |
| ** Function btm_ble_vendor_init |
| ** |
| ** Description Initialize customer specific feature information in host stack |
| ** |
| ** Parameters |
| ** |
| ** Returns status |
| ** |
| *******************************************************************************/ |
| void btm_ble_vendor_init(void) |
| { |
| memset(&btm_ble_vendor_cb, 0, sizeof(tBTM_BLE_VENDOR_CB)); |
| |
| if (!HCI_LE_HOST_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_1])) |
| return; |
| } |
| |
| #endif |
| |
| |
