stack/btm/btm_ble_adv_filter.c

   1 /******************************************************************************
   2  *
   3  *  Copyright (C) 2014  Broadcom Corporation
   4  *
   5  *  Licensed under the Apache License, Version 2.0 (the "License");
   6  *  you may not use this file except in compliance with the License.
   7  *  You may obtain a copy of the License at:
   8  *
   9  *  http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  *  Unless required by applicable law or agreed to in writing, software
  12  *  distributed under the License is distributed on an "AS IS" BASIS,
  13  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  *  See the License for the specific language governing permissions and
  15  *  limitations under the License.
  16  *
  17  ******************************************************************************/
  18
  19 #define LOG_TAG "bt_btm_ble"
  20
  21 #include <string.h>
  22 #include "bt_target.h"
  23
  24 #if (BLE_INCLUDED == TRUE)
  25 #include "bt_types.h"
  26 #include "hcimsgs.h"
  27 #include "btu.h"
  28 #include "btm_int.h"
  29 #include "bt_utils.h"
  30 #include "hcidefs.h"
  31 #include "btm_ble_api.h"
  32 #include "device/include/controller.h"
  33
  34 #define BTM_BLE_ADV_FILT_META_HDR_LENGTH 3
  35 #define BTM_BLE_ADV_FILT_FEAT_SELN_LEN  13
  36 #define BTM_BLE_ADV_FILT_TRACK_NUM       2
  37
  38 #define BTM_BLE_PF_SELECT_NONE              0
  39
  40 /* BLE meta vsc header: 1 bytes of sub_code, 1 byte of PCF action */
  41 #define BTM_BLE_META_HDR_LENGTH     3
  42 #define BTM_BLE_PF_FEAT_SEL_LEN     18
  43 #define BTM_BLE_PCF_ENABLE_LEN      2
  44
  45 #define BTM_BLE_META_ADDR_LEN       7
  46 #define BTM_BLE_META_UUID_LEN       40
  47
  48 #define BTM_BLE_PF_BIT_TO_MASK(x)          (UINT16)(1 << (x))
  49
  50
  51 tBTM_BLE_ADV_FILTER_CB btm_ble_adv_filt_cb;
  52 tBTM_BLE_VSC_CB cmn_ble_vsc_cb;
  53 static const BD_ADDR     na_bda= {0};
  54
  55 static UINT8 btm_ble_cs_update_pf_counter(tBTM_BLE_SCAN_COND_OP action,
  56                                   UINT8 cond_type, tBLE_BD_ADDR *p_bd_addr, UINT8 num_available);
  57
  58 #define BTM_BLE_SET_SCAN_PF_OPCODE(x, y) (((x)<<4)|y)
  59 #define BTM_BLE_GET_SCAN_PF_SUBCODE(x)    ((x) >> 4)
  60 #define BTM_BLE_GET_SCAN_PF_ACTION(x)    ((x) & 0x0f)
  61 #define BTM_BLE_INVALID_COUNTER     0xff
  62
  63
  64 /* length of each multi adv sub command */
  65 #define BTM_BLE_ADV_FILTER_ENB_LEN                       3
  66
  67 /* length of each batch scan command */
  68 #define BTM_BLE_ADV_FILTER_CLEAR_LEN            3
  69 #define BTM_BLE_ADV_FILTER_LEN     2
  70
  71 #define BTM_BLE_ADV_FILT_CB_EVT_MASK       0xF0
  72 #define BTM_BLE_ADV_FILT_SUBCODE_MASK      0x0F
  73
  74 /*******************************************************************************
  75 **
  76 ** Function         btm_ble_obtain_vsc_details
  77 **
  78 ** Description      This function obtains the VSC details
  79 **
  80 ** Parameters
  81 **
  82 ** Returns          status
  83 **
  84 *******************************************************************************/
  85 tBTM_STATUS btm_ble_obtain_vsc_details()
  86 {
  87     tBTM_STATUS st = BTM_SUCCESS;
  88
  89 #if BLE_VND_INCLUDED == TRUE
  90     BTM_BleGetVendorCapabilities(&cmn_ble_vsc_cb);
  91     if (0 == cmn_ble_vsc_cb.max_filter)
  92     {
  93         st = BTM_MODE_UNSUPPORTED;
  94         return st;
  95     }
  96 #else
  97     cmn_ble_vsc_cb.max_filter = BTM_BLE_MAX_FILTER_COUNTER;
  98 #endif
  99     return st;
 100 }
 101
 102 /*******************************************************************************
 103 **
 104 ** Function         btm_ble_advfilt_enq_op_q
 105 **
 106 ** Description      enqueue an adv filter operation in q to check command complete
 107 **                  status
 108 **
 109 ** Returns          void
 110 **
 111 *******************************************************************************/
 112 void btm_ble_advfilt_enq_op_q(UINT8 action, UINT8 ocf, tBTM_BLE_FILT_CB_EVT cb_evt,
 113                               tBTM_BLE_REF_VALUE ref, tBTM_BLE_PF_CFG_CBACK *p_cmpl_cback,
 114                               tBTM_BLE_PF_PARAM_CBACK  *p_filt_param_cback)
 115 {
 116     btm_ble_adv_filt_cb.op_q.action_ocf[btm_ble_adv_filt_cb.op_q.next_idx] = (action |(ocf << 4));
 117     btm_ble_adv_filt_cb.op_q.ref_value[btm_ble_adv_filt_cb.op_q.next_idx] = ref;
 118     btm_ble_adv_filt_cb.op_q.cb_evt[btm_ble_adv_filt_cb.op_q.next_idx] = cb_evt;
 119     btm_ble_adv_filt_cb.op_q.p_scan_cfg_cback[btm_ble_adv_filt_cb.op_q.next_idx] = p_cmpl_cback;
 120     btm_ble_adv_filt_cb.op_q.p_filt_param_cback[btm_ble_adv_filt_cb.op_q.next_idx]
 121         = p_filt_param_cback;
 122     BTM_TRACE_DEBUG("btm_ble_advfilt_enq_op_q: act_ocf:%d, action:%d, ocf:%d,cb_evt;%d, cback:%x",
 123         btm_ble_adv_filt_cb.op_q.action_ocf[btm_ble_adv_filt_cb.op_q.next_idx], action,
 124         ocf, cb_evt, p_cmpl_cback);
 125     btm_ble_adv_filt_cb.op_q.next_idx = (btm_ble_adv_filt_cb.op_q.next_idx + 1)
 126                     % BTM_BLE_PF_TYPE_MAX;
 127 }
 128
 129 /*******************************************************************************
 130 **
 131 ** Function         btm_ble_advfilt_deq_op_q
 132 **
 133 ** Description      dequeue an adv filter operation from q when command complete
 134 **                  is received
 135 **
 136 ** Returns          void
 137 **
 138 *******************************************************************************/
 139 void btm_ble_advfilt_deq_op_q(UINT8 *p_action,UINT8 *p_ocf, tBTM_BLE_FILT_CB_EVT *p_cb_evt,
 140                               tBTM_BLE_REF_VALUE *p_ref, tBTM_BLE_PF_CFG_CBACK ** p_cmpl_cback,
 141                               tBTM_BLE_PF_PARAM_CBACK  **p_filt_param_cback)
 142 {
 143     *p_ocf = (btm_ble_adv_filt_cb.op_q.action_ocf[btm_ble_adv_filt_cb.op_q.pending_idx] >> 4);
 144     *p_action = (btm_ble_adv_filt_cb.op_q.action_ocf[btm_ble_adv_filt_cb.op_q.pending_idx]
 145                 & BTM_BLE_ADV_FILT_SUBCODE_MASK);
 146     *p_ref = btm_ble_adv_filt_cb.op_q.ref_value[btm_ble_adv_filt_cb.op_q.pending_idx];
 147     *p_cb_evt = btm_ble_adv_filt_cb.op_q.cb_evt[btm_ble_adv_filt_cb.op_q.pending_idx];
 148     *p_cmpl_cback = btm_ble_adv_filt_cb.op_q.p_scan_cfg_cback[btm_ble_adv_filt_cb.op_q.pending_idx];
 149     *p_filt_param_cback =
 150         btm_ble_adv_filt_cb.op_q.p_filt_param_cback[btm_ble_adv_filt_cb.op_q.pending_idx];
 151
 152     btm_ble_adv_filt_cb.op_q.pending_idx = (btm_ble_adv_filt_cb.op_q.pending_idx + 1)
 153         % BTM_BLE_PF_TYPE_MAX;
 154     BTM_TRACE_DEBUG("btm_ble_advfilt_deq_op_q: ocf:%d, action:%d, ref_value:%d, cb_evt:%x",
 155         *p_ocf,*p_action, *p_ref, *p_cb_evt);
 156 }
 157
 158 /*******************************************************************************
 159 **
 160 ** Function         btm_ble_condtype_to_ocf
 161 **
 162 ** Description      Convert cond_type to OCF
 163 **
 164 ** Returns          Returns ocf value
 165 **
 166 *******************************************************************************/
 167 UINT8 btm_ble_condtype_to_ocf(UINT8 cond_type)
 168 {
 169     UINT8 ocf = 0;
 170
 171     switch(cond_type)
 172     {
 173         case BTM_BLE_PF_ADDR_FILTER:
 174           ocf = BTM_BLE_META_PF_ADDR;
 175           break;
 176         case BTM_BLE_PF_SRVC_UUID:
 177           ocf = BTM_BLE_META_PF_UUID;
 178           break;
 179         case BTM_BLE_PF_SRVC_SOL_UUID:
 180            ocf = BTM_BLE_META_PF_SOL_UUID;
 181            break;
 182         case BTM_BLE_PF_LOCAL_NAME:
 183            ocf = BTM_BLE_META_PF_LOCAL_NAME;
 184            break;
 185         case BTM_BLE_PF_MANU_DATA:
 186            ocf = BTM_BLE_META_PF_MANU_DATA;
 187            break;
 188         case BTM_BLE_PF_SRVC_DATA_PATTERN:
 189            ocf = BTM_BLE_META_PF_SRVC_DATA;
 190            break;
 191         case BTM_BLE_PF_TYPE_ALL:
 192            ocf = BTM_BLE_META_PF_ALL;
 193            break;
 194         default:
 195            ocf = BTM_BLE_PF_TYPE_MAX;
 196            break;
 197     }
 198     return ocf;
 199 }
 200
 201 /*******************************************************************************
 202 **
 203 ** Function         btm_ble_ocf_to_condtype
 204 **
 205 ** Description      Convert OCF to cond type
 206 **
 207 ** Returns          Returns condtype value
 208 **
 209 *******************************************************************************/
 210 UINT8 btm_ble_ocf_to_condtype(UINT8 ocf)
 211 {
 212     UINT8 cond_type = 0;
 213
 214     switch(ocf)
 215     {
 216         case BTM_BLE_META_PF_FEAT_SEL:
 217            cond_type = BTM_BLE_META_PF_FEAT_SEL;
 218            break;
 219         case BTM_BLE_META_PF_ADDR:
 220           cond_type = BTM_BLE_PF_ADDR_FILTER;
 221           break;
 222         case BTM_BLE_META_PF_UUID:
 223           cond_type = BTM_BLE_PF_SRVC_UUID;
 224           break;
 225         case BTM_BLE_META_PF_SOL_UUID:
 226            cond_type = BTM_BLE_PF_SRVC_SOL_UUID;
 227            break;
 228         case BTM_BLE_META_PF_LOCAL_NAME:
 229            cond_type = BTM_BLE_PF_LOCAL_NAME;
 230            break;
 231         case BTM_BLE_META_PF_MANU_DATA:
 232            cond_type = BTM_BLE_PF_MANU_DATA;
 233            break;
 234         case BTM_BLE_META_PF_SRVC_DATA:
 235            cond_type = BTM_BLE_PF_SRVC_DATA_PATTERN;
 236            break;
 237         case BTM_BLE_META_PF_ALL:
 238            cond_type = BTM_BLE_PF_TYPE_ALL;
 239            break;
 240         default:
 241            cond_type = BTM_BLE_PF_TYPE_MAX;
 242            break;
 243     }
 244     return cond_type;
 245 }
 246
 247 /*******************************************************************************
 248 **
 249 ** Function         btm_ble_scan_pf_cmpl_cback
 250 **
 251 ** Description      the BTM BLE customer feature VSC complete callback for ADV PF filtering
 252 **
 253 ** Returns          pointer to the counter if found; NULL otherwise.
 254 **
 255 *******************************************************************************/
 256 void btm_ble_scan_pf_cmpl_cback(tBTM_VSC_CMPL *p_params)
 257 {
 258     UINT8  status = 0;
 259     UINT8  *p = p_params->p_param_buf, op_subcode = 0, action = 0xff;
 260     UINT16  evt_len = p_params->param_len;
 261     UINT8   ocf = BTM_BLE_META_PF_ALL, cond_type = 0;
 262     UINT8   num_avail = 0, cb_evt = 0;
 263     tBTM_BLE_REF_VALUE ref_value = 0;
 264     tBTM_BLE_PF_CFG_CBACK *p_scan_cfg_cback = NULL;
 265     tBTM_BLE_PF_PARAM_CBACK *p_filt_param_cback = NULL;
 266
 267     if (evt_len < 3 || evt_len > 4)
 268     {
 269       BTM_TRACE_ERROR("%s cannot interpret APCF callback status = %d, length = %d",
 270           __func__, status, evt_len);
 271         btm_ble_advfilt_deq_op_q(&action, &ocf, &cb_evt, &ref_value, &p_scan_cfg_cback,
 272                                  &p_filt_param_cback);
 273         return;
 274     }
 275
 276     btm_ble_advfilt_deq_op_q(&action, &ocf, &cb_evt, &ref_value, &p_scan_cfg_cback,
 277                              &p_filt_param_cback);
 278
 279     STREAM_TO_UINT8(status, p);
 280     STREAM_TO_UINT8(op_subcode, p);
 281     STREAM_TO_UINT8(action, p);
 282
 283     /* Ignore the event, if it is not the same one expected */
 284     if (3 == evt_len)
 285     {
 286         if(ocf != op_subcode)
 287         {
 288              BTM_TRACE_ERROR("btm_ble_scan_pf_cmpl_cback:3-Incorrect opcode :%d, %d, %d, %d, %d, %d",
 289                                         ocf, op_subcode, action, evt_len, ref_value, status);
 290              return;
 291         }
 292         else
 293         {
 294             if(NULL != btm_ble_adv_filt_cb.p_filt_stat_cback)
 295                btm_ble_adv_filt_cb.p_filt_stat_cback(action, status, ref_value);
 296             BTM_TRACE_DEBUG("btm_ble_scan_pf_cmpl_cback enabled/disabled, %d, %d, %d, %d",
 297                                          ocf, action, status, ref_value);
 298             return;
 299         }
 300     }
 301
 302     if (4 == evt_len && ocf != op_subcode)
 303     {
 304         BTM_TRACE_ERROR("btm_ble_scan_pf_cmpl_cback:4-Incorrect opcode: %d, %d, %d, %d, %d",
 305                                 ocf, op_subcode, action, status, ref_value);
 306         return;
 307     }
 308
 309     STREAM_TO_UINT8(num_avail, p);
 310     switch (op_subcode)
 311     {
 312         case BTM_BLE_META_PF_ADDR:
 313         case BTM_BLE_META_PF_UUID:
 314         case BTM_BLE_META_PF_SOL_UUID:
 315         case BTM_BLE_META_PF_LOCAL_NAME:
 316         case BTM_BLE_META_PF_MANU_DATA:
 317         case BTM_BLE_META_PF_SRVC_DATA:
 318            cond_type = btm_ble_ocf_to_condtype(ocf);
 319            BTM_TRACE_DEBUG("btm_ble_scan_pf_cmpl_cback Recd: %d, %d, %d, %d, %d, %d", op_subcode,
 320                                         ocf, action, status, ref_value, num_avail);
 321            if (HCI_SUCCESS == status)
 322            {
 323                if (memcmp(&btm_ble_adv_filt_cb.cur_filter_target.bda, &na_bda, BD_ADDR_LEN) == 0)
 324                    btm_ble_cs_update_pf_counter(action, cond_type, NULL, num_avail);
 325                else
 326                    btm_ble_cs_update_pf_counter(action, cond_type,
 327                             &btm_ble_adv_filt_cb.cur_filter_target, num_avail);
 328            }
 329
 330            /* send ADV PF operation complete */
 331            btm_ble_adv_filt_cb.op_type = 0;
 332            break;
 333
 334         case BTM_BLE_META_PF_FEAT_SEL:
 335             BTM_TRACE_DEBUG("btm_ble_scan_pf_cmpl_cback-Feat sel event: %d, %d, %d, %d",
 336                                 action, status, ref_value, num_avail);
 337             break;
 338
 339         default:
 340             BTM_TRACE_ERROR("btm_ble_scan_pf_cmpl_cback: unknown operation: %d", op_subcode);
 341             break;
 342     }
 343
 344     switch(cb_evt)
 345     {
 346         BTM_TRACE_DEBUG("btm_ble_scan_pf_cmpl_cback: calling the cback: %d", cb_evt);
 347         case BTM_BLE_FILT_CFG:
 348             if(NULL != p_scan_cfg_cback)
 349                p_scan_cfg_cback(action, cond_type, num_avail, status, ref_value);
 350             break;
 351         case BTM_BLE_FILT_ADV_PARAM:
 352             if(NULL != p_filt_param_cback)
 353                p_filt_param_cback(action, num_avail, ref_value, status);
 354             break;
 355         default:
 356             break;
 357     }
 358 }
 359
 360 /*******************************************************************************
 361 **
 362 ** Function         btm_ble_find_addr_filter_counter
 363 **
 364 ** Description      find the per bd address ADV payload filter counter by BD_ADDR.
 365 **
 366 ** Returns          pointer to the counter if found; NULL otherwise.
 367 **
 368 *******************************************************************************/
 369 tBTM_BLE_PF_COUNT* btm_ble_find_addr_filter_counter(tBLE_BD_ADDR *p_le_bda)
 370 {
 371     UINT8               i;
 372     tBTM_BLE_PF_COUNT   *p_addr_filter = &btm_ble_adv_filt_cb.p_addr_filter_count[1];
 373
 374     if (p_le_bda == NULL)
 375         return &btm_ble_adv_filt_cb.p_addr_filter_count[0];
 376
 377     for (i = 0; i < cmn_ble_vsc_cb.max_filter; i ++, p_addr_filter ++)
 378     {
 379         if (p_addr_filter->in_use &&
 380             memcmp(p_le_bda->bda, p_addr_filter->bd_addr, BD_ADDR_LEN) == 0)
 381         {
 382             return p_addr_filter;
 383         }
 384     }
 385     return NULL;
 386 }
 387
 388 /*******************************************************************************
 389 **
 390 ** Function         btm_ble_alloc_addr_filter_counter
 391 **
 392 ** Description      allocate the per device adv payload filter counter.
 393 **
 394 ** Returns          pointer to the counter if allocation succeed; NULL otherwise.
 395 **
 396 *******************************************************************************/
 397 tBTM_BLE_PF_COUNT * btm_ble_alloc_addr_filter_counter(BD_ADDR bd_addr)
 398 {
 399     UINT8               i;
 400     tBTM_BLE_PF_COUNT   *p_addr_filter = &btm_ble_adv_filt_cb.p_addr_filter_count[1];
 401
 402     for (i = 0; i < cmn_ble_vsc_cb.max_filter; i ++, p_addr_filter ++)
 403     {
 404         if (memcmp(na_bda, p_addr_filter->bd_addr, BD_ADDR_LEN) == 0)
 405         {
 406             memcpy(p_addr_filter->bd_addr, bd_addr, BD_ADDR_LEN);
 407             p_addr_filter->in_use = TRUE;
 408             return p_addr_filter;
 409         }
 410     }
 411     return NULL;
 412 }
 413 /*******************************************************************************
 414 **
 415 ** Function         btm_ble_dealloc_addr_filter_counter
 416 **
 417 ** Description      de-allocate the per device adv payload filter counter.
 418 **
 419 ** Returns          TRUE if deallocation succeed; FALSE otherwise.
 420 **
 421 *******************************************************************************/
 422 BOOLEAN btm_ble_dealloc_addr_filter_counter(tBLE_BD_ADDR *p_bd_addr, UINT8 filter_type)
 423 {
 424     UINT8               i;
 425     tBTM_BLE_PF_COUNT   *p_addr_filter = &btm_ble_adv_filt_cb.p_addr_filter_count[1];
 426     BOOLEAN             found = FALSE;
 427
 428     if (BTM_BLE_PF_TYPE_ALL == filter_type && NULL == p_bd_addr)
 429         memset(&btm_ble_adv_filt_cb.p_addr_filter_count[0], 0, sizeof(tBTM_BLE_PF_COUNT));
 430
 431     for (i = 0; i < cmn_ble_vsc_cb.max_filter; i ++, p_addr_filter ++)
 432     {
 433         if ((p_addr_filter->in_use) && (NULL == p_bd_addr ||
 434             (NULL != p_bd_addr &&
 435             memcmp(p_bd_addr->bda, p_addr_filter->bd_addr, BD_ADDR_LEN) == 0)))
 436         {
 437             found = TRUE;
 438             memset(p_addr_filter, 0, sizeof(tBTM_BLE_PF_COUNT));
 439
 440             if (NULL != p_bd_addr) break;
 441         }
 442     }
 443     return found;
 444 }
 445
 446 /*******************************************************************************
 447 **
 448 ** Function         btm_ble_update_pf_local_name
 449 **
 450 ** Description      this function update(add,delete or clear) the adv lcoal name filtering condition.
 451 **
 452 **
 453 ** Returns          BTM_SUCCESS if sucessful,
 454 **                  BTM_ILLEGAL_VALUE if paramter is not valid.
 455 **
 456 *******************************************************************************/
 457 tBTM_STATUS btm_ble_update_pf_local_name(tBTM_BLE_SCAN_COND_OP action,
 458                                          tBTM_BLE_PF_FILT_INDEX filt_index,
 459                                          tBTM_BLE_PF_COND_PARAM *p_cond)
 460 {
 461     tBTM_BLE_PF_LOCAL_NAME_COND *p_local_name = (p_cond == NULL) ? NULL : &p_cond->local_name;
 462     UINT8       param[BTM_BLE_PF_STR_LEN_MAX + BTM_BLE_ADV_FILT_META_HDR_LENGTH],
 463                 *p = param,
 464                 len = BTM_BLE_ADV_FILT_META_HDR_LENGTH;
 465     tBTM_STATUS st = BTM_ILLEGAL_VALUE;
 466
 467     memset(param, 0, BTM_BLE_PF_STR_LEN_MAX + BTM_BLE_ADV_FILT_META_HDR_LENGTH);
 468
 469     UINT8_TO_STREAM(p, BTM_BLE_META_PF_LOCAL_NAME);
 470     UINT8_TO_STREAM(p, action);
 471
 472     /* Filter index */
 473     UINT8_TO_STREAM(p, filt_index);
 474
 475     if (BTM_BLE_SCAN_COND_ADD == action ||
 476         BTM_BLE_SCAN_COND_DELETE == action)
 477     {
 478         if (NULL == p_local_name)
 479             return st;
 480
 481         if (p_local_name->data_len > BTM_BLE_PF_STR_LEN_MAX)
 482             p_local_name->data_len = BTM_BLE_PF_STR_LEN_MAX;
 483
 484         ARRAY_TO_STREAM(p, p_local_name->p_data, p_local_name->data_len);
 485         len += p_local_name->data_len;
 486     }
 487
 488     /* send local name filter */
 489     if ((st = BTM_VendorSpecificCommand (HCI_BLE_ADV_FILTER_OCF,
 490                               len,
 491                               param,
 492                               btm_ble_scan_pf_cmpl_cback))
 493             != BTM_NO_RESOURCES)
 494     {
 495         memset(&btm_ble_adv_filt_cb.cur_filter_target, 0, sizeof(tBLE_BD_ADDR));
 496     }
 497     else
 498     {
 499         BTM_TRACE_ERROR("Local Name PF filter update failed");
 500     }
 501
 502     return st;
 503 }
 504
 505
 506 /*******************************************************************************
 507 **
 508 ** Function         btm_ble_update_srvc_data_change
 509 **
 510 ** Description      this function update(add/remove) service data change filter.
 511 **
 512 **
 513 ** Returns          BTM_SUCCESS if sucessful,
 514 **                  BTM_ILLEGAL_VALUE if paramter is not valid.
 515 **
 516 *******************************************************************************/
 517 tBTM_STATUS btm_ble_update_srvc_data_change(tBTM_BLE_SCAN_COND_OP action,
 518                                        tBTM_BLE_PF_FILT_INDEX filt_index,
 519                                        tBTM_BLE_PF_COND_PARAM *p_cond)
 520 {
 521     tBTM_STATUS st = BTM_ILLEGAL_VALUE;
 522     tBLE_BD_ADDR   *p_bd_addr = p_cond ? &p_cond->target_addr : NULL;
 523     UINT8           num_avail = (action == BTM_BLE_SCAN_COND_ADD) ? 0 : 1;
 524
 525     if (btm_ble_cs_update_pf_counter (action, BTM_BLE_PF_SRVC_DATA, p_bd_addr, num_avail)
 526                     != BTM_BLE_INVALID_COUNTER)
 527         st = BTM_SUCCESS;
 528
 529     return st;
 530 }
 531
 532 /*******************************************************************************
 533 **
 534 ** Function         btm_ble_update_pf_manu_data
 535 **
 536 ** Description      this function update(add,delete or clear) the adv manufacturer
 537 **                  data filtering condition.
 538 **
 539 **
 540 ** Returns          BTM_SUCCESS if sucessful,
 541 **                  BTM_ILLEGAL_VALUE if paramter is not valid.
 542 **
 543 *******************************************************************************/
 544 tBTM_STATUS btm_ble_update_pf_manu_data(tBTM_BLE_SCAN_COND_OP action,
 545                                         tBTM_BLE_PF_FILT_INDEX filt_index,
 546                                         tBTM_BLE_PF_COND_PARAM *p_data,
 547                                         tBTM_BLE_PF_COND_TYPE cond_type,
 548                                         tBTM_BLE_FILT_CB_EVT cb_evt,
 549                                         tBTM_BLE_REF_VALUE ref_value)
 550 {
 551     tBTM_BLE_PF_MANU_COND *p_manu_data = (p_data == NULL) ? NULL : &p_data->manu_data;
 552     tBTM_BLE_PF_SRVC_PATTERN_COND *p_srvc_data = (p_data == NULL) ? NULL : &p_data->srvc_data;
 553
 554     UINT8 param[BTM_BLE_PF_STR_LEN_MAX + BTM_BLE_PF_STR_LEN_MAX + BTM_BLE_ADV_FILT_META_HDR_LENGTH],
 555           *p = param,
 556           len = BTM_BLE_ADV_FILT_META_HDR_LENGTH;
 557     tBTM_STATUS st = BTM_ILLEGAL_VALUE;
 558
 559     if (NULL == p_data)
 560         return st;
 561
 562     memset(param, 0, BTM_BLE_PF_STR_LEN_MAX + BTM_BLE_PF_STR_LEN_MAX
 563                     + BTM_BLE_ADV_FILT_META_HDR_LENGTH);
 564
 565     if (BTM_BLE_PF_SRVC_DATA_PATTERN == cond_type)
 566     {
 567         UINT8_TO_STREAM(p, BTM_BLE_META_PF_SRVC_DATA);
 568     }
 569     else
 570     {
 571         UINT8_TO_STREAM(p, BTM_BLE_META_PF_MANU_DATA);
 572     }
 573
 574     UINT8_TO_STREAM(p, action);
 575
 576     /* Filter index */
 577     UINT8_TO_STREAM(p, filt_index);
 578
 579     if (BTM_BLE_SCAN_COND_ADD == action || BTM_BLE_SCAN_COND_DELETE == action)
 580     {
 581         if (BTM_BLE_PF_SRVC_DATA_PATTERN == cond_type)
 582         {
 583             if (NULL == p_srvc_data)
 584                 return st;
 585             if (p_srvc_data->data_len > (BTM_BLE_PF_STR_LEN_MAX - 2))
 586                 p_srvc_data->data_len = (BTM_BLE_PF_STR_LEN_MAX - 2);
 587
 588             if (p_srvc_data->data_len > 0)
 589             {
 590                 ARRAY_TO_STREAM(p, p_srvc_data->p_pattern, p_srvc_data->data_len);
 591                 len += (p_srvc_data->data_len);
 592                 ARRAY_TO_STREAM(p, p_srvc_data->p_pattern_mask, p_srvc_data->data_len);
 593             }
 594
 595             len += (p_srvc_data->data_len);
 596             BTM_TRACE_DEBUG("Service data length: %d", len);
 597         }
 598         else
 599         {
 600             if (NULL == p_manu_data)
 601             {
 602                 BTM_TRACE_ERROR("btm_ble_update_pf_manu_data - No manuf data");
 603                 return st;
 604             }
 605             BTM_TRACE_EVENT("btm_ble_update_pf_manu_data length: %d",
 606                                     p_manu_data->data_len);
 607             if (p_manu_data->data_len > (BTM_BLE_PF_STR_LEN_MAX - 2))
 608                 p_manu_data->data_len = (BTM_BLE_PF_STR_LEN_MAX - 2);
 609
 610             UINT16_TO_STREAM(p, p_manu_data->company_id);
 611             if (p_manu_data->data_len > 0 && p_manu_data->p_pattern_mask != NULL)
 612             {
 613                 ARRAY_TO_STREAM(p, p_manu_data->p_pattern, p_manu_data->data_len);
 614                 len += (p_manu_data->data_len + 2);
 615             }
 616             else
 617                 len += 2;
 618
 619             if (p_manu_data->company_id_mask != 0)
 620             {
 621                 UINT16_TO_STREAM (p, p_manu_data->company_id_mask);
 622             }
 623             else
 624             {
 625                 memset(p, 0xff, 2);
 626                 p += 2;
 627             }
 628             len += 2;
 629
 630             if (p_manu_data->data_len > 0 && p_manu_data->p_pattern_mask != NULL)
 631             {
 632                 ARRAY_TO_STREAM(p, p_manu_data->p_pattern_mask, p_manu_data->data_len);
 633                 len += (p_manu_data->data_len);
 634             }
 635
 636             BTM_TRACE_DEBUG("Manuf data length: %d", len);
 637         }
 638     }
 639
 640     /* send manufacturer*/
 641     if ((st = BTM_VendorSpecificCommand (HCI_BLE_ADV_FILTER_OCF,
 642                               len,
 643                               param,
 644                               btm_ble_scan_pf_cmpl_cback)) != BTM_NO_RESOURCES)
 645     {
 646         memset(&btm_ble_adv_filt_cb.cur_filter_target, 0, sizeof(tBLE_BD_ADDR));
 647     }
 648     else
 649     {
 650         BTM_TRACE_ERROR("manufacturer data PF filter update failed");
 651     }
 652
 653     return st;
 654 }
 655
 656 /*******************************************************************************
 657 **
 658 ** Function         btm_ble_cs_update_pf_counter
 659 **
 660 ** Description      this function is to update the adv data payload filter counter
 661 **
 662 ** Returns          current number of the counter; BTM_BLE_INVALID_COUNTER if
 663 **                  counter update failed.
 664 **
 665 *******************************************************************************/
 666 UINT8 btm_ble_cs_update_pf_counter(tBTM_BLE_SCAN_COND_OP action,
 667                                   UINT8 cond_type, tBLE_BD_ADDR *p_bd_addr,
 668                                   UINT8 num_available)
 669 {
 670     tBTM_BLE_PF_COUNT   *p_addr_filter = NULL;
 671     UINT8               *p_counter = NULL;
 672
 673     btm_ble_obtain_vsc_details();
 674
 675     if (cond_type > BTM_BLE_PF_TYPE_ALL)
 676     {
 677         BTM_TRACE_ERROR("unknown PF filter condition type %d", cond_type);
 678         return BTM_BLE_INVALID_COUNTER;
 679     }
 680
 681     /* for these three types of filter, always generic */
 682     if (BTM_BLE_PF_ADDR_FILTER == cond_type ||
 683         BTM_BLE_PF_MANU_DATA == cond_type ||
 684         BTM_BLE_PF_LOCAL_NAME == cond_type ||
 685         BTM_BLE_PF_SRVC_DATA_PATTERN == cond_type)
 686         p_bd_addr = NULL;
 687
 688     if ((p_addr_filter = btm_ble_find_addr_filter_counter(p_bd_addr)) == NULL &&
 689         BTM_BLE_SCAN_COND_ADD == action)
 690     {
 691         p_addr_filter = btm_ble_alloc_addr_filter_counter(p_bd_addr->bda);
 692     }
 693
 694     if (NULL != p_addr_filter)
 695     {
 696         /* all filter just cleared */
 697         if ((BTM_BLE_PF_TYPE_ALL == cond_type && BTM_BLE_SCAN_COND_CLEAR == action) ||
 698             /* or bd address filter been deleted */
 699             (BTM_BLE_PF_ADDR_FILTER == cond_type &&
 700              (BTM_BLE_SCAN_COND_DELETE == action || BTM_BLE_SCAN_COND_CLEAR == action)))
 701         {
 702             btm_ble_dealloc_addr_filter_counter(p_bd_addr, cond_type);
 703         }
 704         /* if not feature selection, update new addition/reduction of the filter counter */
 705         else if (cond_type != BTM_BLE_PF_TYPE_ALL)
 706         {
 707             p_counter = p_addr_filter->pf_counter;
 708             if (num_available > 0)
 709                 p_counter[cond_type] += 1;
 710
 711             BTM_TRACE_DEBUG("counter = %d, maxfilt = %d, num_avbl=%d",
 712                 p_counter[cond_type], cmn_ble_vsc_cb.max_filter, num_available);
 713             return p_counter[cond_type];
 714         }
 715     }
 716     else
 717     {
 718         BTM_TRACE_ERROR("no matching filter counter found");
 719     }
 720     /* no matching filter located and updated */
 721     return BTM_BLE_INVALID_COUNTER;
 722 }
 723
 724
 725 /*******************************************************************************
 726 **
 727 ** Function         btm_ble_update_addr_filter
 728 **
 729 ** Description      this function update(add,delete or clear) the address filter of adv.
 730 **
 731 **
 732 ** Returns          BTM_SUCCESS if sucessful,
 733 **                  BTM_ILLEGAL_VALUE if paramter is not valid.
 734 **
 735 *******************************************************************************/
 736 tBTM_STATUS btm_ble_update_addr_filter(tBTM_BLE_SCAN_COND_OP action,
 737                                        tBTM_BLE_PF_FILT_INDEX filt_index,
 738                                        tBTM_BLE_PF_COND_PARAM *p_cond)
 739 {
 740     UINT8       param[BTM_BLE_META_ADDR_LEN + BTM_BLE_ADV_FILT_META_HDR_LENGTH],
 741                 * p= param;
 742     tBTM_STATUS st = BTM_ILLEGAL_VALUE;
 743     tBLE_BD_ADDR *p_addr = (p_cond == NULL) ? NULL : &p_cond->target_addr;
 744
 745     memset(param, 0, BTM_BLE_META_ADDR_LEN + BTM_BLE_ADV_FILT_META_HDR_LENGTH);
 746
 747     UINT8_TO_STREAM(p, BTM_BLE_META_PF_ADDR);
 748     UINT8_TO_STREAM(p, action);
 749
 750     /* Filter index */
 751     UINT8_TO_STREAM(p, filt_index);
 752
 753     if (BTM_BLE_SCAN_COND_ADD == action ||
 754         BTM_BLE_SCAN_COND_DELETE == action)
 755     {
 756         if (NULL == p_addr)
 757             return st;
 758
 759         BDADDR_TO_STREAM(p, p_addr->bda);
 760         UINT8_TO_STREAM(p, p_addr->type);
 761     }
 762     /* send address filter */
 763     if ((st = BTM_VendorSpecificCommand (HCI_BLE_ADV_FILTER_OCF,
 764                               (UINT8)(BTM_BLE_ADV_FILT_META_HDR_LENGTH + BTM_BLE_META_ADDR_LEN),
 765                               param,
 766                               btm_ble_scan_pf_cmpl_cback)) != BTM_NO_RESOURCES)
 767     {
 768         memset(&btm_ble_adv_filt_cb.cur_filter_target, 0, sizeof(tBLE_BD_ADDR));
 769     }
 770     else
 771     {
 772         BTM_TRACE_ERROR("Broadcaster Address Filter Update failed");
 773     }
 774     return st;
 775 }
 776
 777 /*******************************************************************************
 778 **
 779 ** Function         btm_ble_update_uuid_filter
 780 **
 781 ** Description      this function update(add,delete or clear) service UUID filter.
 782 **
 783 **
 784 ** Returns          BTM_SUCCESS if sucessful,
 785 **                  BTM_ILLEGAL_VALUE if paramter is not valid.
 786 **
 787 *******************************************************************************/
 788 tBTM_STATUS btm_ble_update_uuid_filter(tBTM_BLE_SCAN_COND_OP action,
 789                                        tBTM_BLE_PF_FILT_INDEX filt_index,
 790                                        tBTM_BLE_PF_COND_TYPE filter_type,
 791                                        tBTM_BLE_PF_COND_PARAM *p_cond,
 792                                        tBTM_BLE_FILT_CB_EVT cb_evt,
 793                                        tBTM_BLE_REF_VALUE ref_value)
 794 {
 795     UINT8       param[BTM_BLE_META_UUID_LEN + BTM_BLE_ADV_FILT_META_HDR_LENGTH],
 796                 * p= param,
 797                 len = BTM_BLE_ADV_FILT_META_HDR_LENGTH;
 798     tBTM_STATUS st = BTM_ILLEGAL_VALUE;
 799     tBTM_BLE_PF_UUID_COND *p_uuid_cond;
 800     UINT8           evt_type;
 801
 802     memset(param, 0, BTM_BLE_META_UUID_LEN + BTM_BLE_ADV_FILT_META_HDR_LENGTH);
 803
 804     if (BTM_BLE_PF_SRVC_UUID == filter_type)
 805     {
 806         evt_type = BTM_BLE_META_PF_UUID;
 807         p_uuid_cond = p_cond ? &p_cond->srvc_uuid : NULL;
 808     }
 809     else
 810     {
 811         evt_type = BTM_BLE_META_PF_SOL_UUID;
 812         p_uuid_cond = p_cond ? &p_cond->solicitate_uuid : NULL;
 813     }
 814
 815     if (NULL == p_uuid_cond && action != BTM_BLE_SCAN_COND_CLEAR)
 816     {
 817         BTM_TRACE_ERROR("Illegal param for add/delete UUID filter");
 818         return st;
 819     }
 820
 821     /* need to add address filter first, if adding per bda UUID filter without address filter */
 822     if (BTM_BLE_SCAN_COND_ADD == action && NULL != p_uuid_cond &&
 823         p_uuid_cond->p_target_addr &&
 824         btm_ble_find_addr_filter_counter(p_uuid_cond->p_target_addr) == NULL)
 825     {
 826         UINT8_TO_STREAM(p, BTM_BLE_META_PF_ADDR);
 827         UINT8_TO_STREAM(p, action);
 828
 829         /* Filter index */
 830         UINT8_TO_STREAM(p, filt_index);
 831
 832         BDADDR_TO_STREAM(p, p_uuid_cond->p_target_addr->bda);
 833         UINT8_TO_STREAM(p, p_uuid_cond->p_target_addr->type);
 834
 835         /* send address filter */
 836         if ((st = BTM_VendorSpecificCommand (HCI_BLE_ADV_FILTER_OCF,
 837                                   (UINT8)(BTM_BLE_ADV_FILT_META_HDR_LENGTH + BTM_BLE_META_ADDR_LEN),
 838                                   param,
 839                                   btm_ble_scan_pf_cmpl_cback)) == BTM_NO_RESOURCES)
 840         {
 841             BTM_TRACE_ERROR("Update Address filter into controller failed.");
 842             return st;
 843         }
 844
 845         btm_ble_advfilt_enq_op_q(action, BTM_BLE_META_PF_ADDR, cb_evt, ref_value, NULL, NULL);
 846         BTM_TRACE_DEBUG("Updated Address filter");
 847     }
 848
 849     p = param;
 850     UINT8_TO_STREAM(p, evt_type);
 851     UINT8_TO_STREAM(p, action);
 852
 853     /* Filter index */
 854     UINT8_TO_STREAM(p, filt_index);
 855
 856     if ((BTM_BLE_SCAN_COND_ADD == action ||
 857         BTM_BLE_SCAN_COND_DELETE == action) &&
 858         NULL != p_uuid_cond)
 859     {
 860         if (p_uuid_cond->uuid.len == LEN_UUID_16)
 861         {
 862             UINT16_TO_STREAM(p, p_uuid_cond->uuid.uu.uuid16);
 863             len += LEN_UUID_16;
 864         }
 865         else if (p_uuid_cond->uuid.len == LEN_UUID_32)/*4 bytes */
 866         {
 867             UINT32_TO_STREAM(p, p_uuid_cond->uuid.uu.uuid32);
 868             len += LEN_UUID_32;
 869         }
 870         else if (p_uuid_cond->uuid.len == LEN_UUID_128)
 871         {
 872             ARRAY_TO_STREAM (p, p_uuid_cond->uuid.uu.uuid128, LEN_UUID_128);
 873             len += LEN_UUID_128;
 874         }
 875         else
 876         {
 877             BTM_TRACE_ERROR("illegal UUID length: %d", p_uuid_cond->uuid.len);
 878             return BTM_ILLEGAL_VALUE;
 879         }
 880
 881         if (NULL != p_uuid_cond->p_uuid_mask)
 882         {
 883             if (p_uuid_cond->uuid.len == LEN_UUID_16)
 884             {
 885                 UINT16_TO_STREAM(p, p_uuid_cond->p_uuid_mask->uuid16_mask);
 886                 len += LEN_UUID_16;
 887             }
 888             else if (p_uuid_cond->uuid.len == LEN_UUID_32)/*4 bytes */
 889             {
 890                 UINT32_TO_STREAM(p, p_uuid_cond->p_uuid_mask->uuid32_mask);
 891                 len += LEN_UUID_32;
 892             }
 893             else if (p_uuid_cond->uuid.len == LEN_UUID_128)
 894             {
 895                 ARRAY_TO_STREAM (p, p_uuid_cond->p_uuid_mask->uuid128_mask, LEN_UUID_128);
 896                 len += LEN_UUID_128;
 897             }
 898         }
 899         else
 900         {
 901             memset(p, 0xff, p_uuid_cond->uuid.len);
 902             len += p_uuid_cond->uuid.len;
 903         }
 904         BTM_TRACE_DEBUG("btm_ble_update_uuid_filter : %d, %d, %d, %d", filter_type, evt_type,
 905                         p_uuid_cond->uuid.len, len);
 906     }
 907
 908     /* send UUID filter update */
 909     if ((st = BTM_VendorSpecificCommand (HCI_BLE_ADV_FILTER_OCF,
 910                               len,
 911                               param,
 912                               btm_ble_scan_pf_cmpl_cback)) != BTM_NO_RESOURCES)
 913     {
 914         if (p_uuid_cond && p_uuid_cond->p_target_addr)
 915             memcpy(&btm_ble_adv_filt_cb.cur_filter_target, p_uuid_cond->p_target_addr,
 916                     sizeof(tBLE_BD_ADDR));
 917         else
 918             memset(&btm_ble_adv_filt_cb.cur_filter_target, 0, sizeof(tBLE_BD_ADDR));
 919     }
 920     else
 921     {
 922         BTM_TRACE_ERROR("UUID filter udpating failed");
 923     }
 924
 925     return st;
 926 }
 927
 928
 929 /*******************************************************************************
 930 **
 931 ** Function         btm_ble_clear_scan_pf_filter
 932 **
 933 ** Description      clear all adv payload filter by de-select all the adv pf feature bits
 934 **
 935 **
 936 ** Returns          BTM_SUCCESS if sucessful,
 937 **                  BTM_ILLEGAL_VALUE if paramter is not valid.
 938 **
 939 *******************************************************************************/
 940 tBTM_STATUS btm_ble_clear_scan_pf_filter(tBTM_BLE_SCAN_COND_OP action,
 941                                        tBTM_BLE_PF_FILT_INDEX filt_index,
 942                                        tBTM_BLE_PF_COND_PARAM *p_cond,
 943                                        tBTM_BLE_PF_CFG_CBACK *p_cmpl_cback,
 944                                        tBTM_BLE_FILT_CB_EVT cb_evt,
 945                                        tBTM_BLE_REF_VALUE ref_value)
 946 {
 947     tBLE_BD_ADDR *p_target = (p_cond == NULL)? NULL : &p_cond->target_addr;
 948     tBTM_BLE_PF_COUNT *p_bda_filter;
 949     tBTM_STATUS     st = BTM_WRONG_MODE;
 950     UINT8           param[20], *p;
 951
 952     if (BTM_BLE_SCAN_COND_CLEAR != action)
 953     {
 954         BTM_TRACE_ERROR("unable to perform action:%d for generic adv filter type", action);
 955         return BTM_ILLEGAL_VALUE;
 956     }
 957
 958     p = param;
 959     memset(param, 0, 20);
 960
 961     p_bda_filter = btm_ble_find_addr_filter_counter(p_target);
 962
 963     if (NULL == p_bda_filter ||
 964         /* not a generic filter */
 965         (p_target != NULL && p_bda_filter))
 966     {
 967         BTM_TRACE_ERROR("Error: Can not clear filter, No PF filter has been configured!");
 968         return st;
 969     }
 970
 971     /* clear the general filter entry */
 972     if (NULL == p_target)
 973     {
 974         /* clear manufactuer data filter */
 975         st = btm_ble_update_pf_manu_data(BTM_BLE_SCAN_COND_CLEAR, filt_index, NULL,
 976                                     BTM_BLE_PF_MANU_DATA, cb_evt, ref_value);
 977         if(BTM_CMD_STARTED == st)
 978            btm_ble_advfilt_enq_op_q(action, BTM_BLE_META_PF_MANU_DATA, cb_evt,
 979                                     ref_value, NULL, NULL);
 980
 981         /* clear local name filter */
 982         st = btm_ble_update_pf_local_name(BTM_BLE_SCAN_COND_CLEAR, filt_index, NULL);
 983         if(BTM_CMD_STARTED == st)
 984            btm_ble_advfilt_enq_op_q(action, BTM_BLE_META_PF_LOCAL_NAME, cb_evt,
 985                                     ref_value, NULL, NULL);
 986
 987         /* update the counter for service data */
 988         st = btm_ble_update_srvc_data_change(BTM_BLE_SCAN_COND_CLEAR, filt_index, NULL);
 989
 990         /* clear UUID filter */
 991         st = btm_ble_update_uuid_filter(BTM_BLE_SCAN_COND_CLEAR, filt_index,
 992                                    BTM_BLE_PF_SRVC_UUID, NULL, cb_evt, ref_value);
 993         if(BTM_CMD_STARTED == st)
 994            btm_ble_advfilt_enq_op_q(action, BTM_BLE_META_PF_UUID, cb_evt, ref_value, NULL, NULL);
 995
 996         st = btm_ble_update_uuid_filter(BTM_BLE_SCAN_COND_CLEAR, filt_index,
 997                                    BTM_BLE_PF_SRVC_SOL_UUID, NULL, cb_evt, ref_value);
 998         if(BTM_CMD_STARTED == st)
 999            btm_ble_advfilt_enq_op_q(action, BTM_BLE_META_PF_SOL_UUID, cb_evt,
1000                                     ref_value, NULL, NULL);
1001
1002         /* clear service data filter */
1003         st = btm_ble_update_pf_manu_data(BTM_BLE_SCAN_COND_CLEAR, filt_index, NULL,
1004                                     BTM_BLE_PF_SRVC_DATA_PATTERN, cb_evt, ref_value);
1005         if(BTM_CMD_STARTED == st)
1006            btm_ble_advfilt_enq_op_q(action, BTM_BLE_META_PF_SRVC_DATA, cb_evt,
1007                                     ref_value, NULL, NULL);
1008     }
1009
1010     /* select feature based on control block settings */
1011     UINT8_TO_STREAM(p, BTM_BLE_META_PF_FEAT_SEL);
1012     UINT8_TO_STREAM(p, BTM_BLE_SCAN_COND_CLEAR);
1013
1014     /* Filter index */
1015     UINT8_TO_STREAM(p, filt_index);
1016
1017     /* set PCF selection */
1018     UINT32_TO_STREAM(p, BTM_BLE_PF_SELECT_NONE);
1019     /* set logic condition as OR as default */
1020     UINT8_TO_STREAM(p, BTM_BLE_PF_LOGIC_OR);
1021
1022     if ((st = BTM_VendorSpecificCommand (HCI_BLE_ADV_FILTER_OCF,
1023                                (UINT8)(BTM_BLE_ADV_FILT_META_HDR_LENGTH + BTM_BLE_PF_FEAT_SEL_LEN),
1024                                 param,
1025                                 btm_ble_scan_pf_cmpl_cback))
1026             != BTM_NO_RESOURCES)
1027     {
1028         if (p_target)
1029             memcpy(&btm_ble_adv_filt_cb.cur_filter_target, p_target, sizeof(tBLE_BD_ADDR));
1030         else
1031             memset(&btm_ble_adv_filt_cb.cur_filter_target, 0, sizeof(tBLE_BD_ADDR));
1032     }
1033     return st;
1034 }
1035
1036 /*******************************************************************************
1037 **
1038 ** Function         BTM_BleAdvFilterParamSetup
1039 **
1040 ** Description      This function is called to setup the adv data payload filter
1041 **                  condition.
1042 **
1043 ** Parameters       action - Type of action to be performed
1044 **                       filt_index - Filter index
1045 **                       p_filt_params - Filter parameters
1046 **                       p_target - Target device
1047 **                       p_cmpl_back - Callback pointer
1048 **                       ref_value - reference value
1049 **
1050 ** Returns          void
1051 **
1052 *******************************************************************************/
1053 tBTM_STATUS BTM_BleAdvFilterParamSetup(int action, tBTM_BLE_PF_FILT_INDEX filt_index,
1054                                 tBTM_BLE_PF_FILT_PARAMS *p_filt_params,
1055                                 tBLE_BD_ADDR *p_target, tBTM_BLE_PF_PARAM_CBACK *p_cmpl_cback,
1056                                 tBTM_BLE_REF_VALUE ref_value)
1057 {
1058     tBTM_STATUS st = BTM_WRONG_MODE;
1059     tBTM_BLE_PF_COUNT *p_bda_filter = NULL;
1060     UINT8 len = BTM_BLE_ADV_FILT_META_HDR_LENGTH + BTM_BLE_ADV_FILT_FEAT_SELN_LEN +
1061                 BTM_BLE_ADV_FILT_TRACK_NUM;
1062     UINT8 param[len], *p;
1063
1064     if (BTM_SUCCESS  != btm_ble_obtain_vsc_details())
1065         return st;
1066
1067     p = param;
1068     memset(param, 0, len);
1069     BTM_TRACE_EVENT (" BTM_BleAdvFilterParamSetup");
1070
1071     if (BTM_BLE_SCAN_COND_ADD == action)
1072     {
1073         p_bda_filter = btm_ble_find_addr_filter_counter(p_target);
1074         if (NULL == p_bda_filter)
1075         {
1076            BTM_TRACE_ERROR("BD Address not found!");
1077            return st;
1078         }
1079
1080         BTM_TRACE_DEBUG("BTM_BleAdvFilterParamSetup : Feat mask:%d", p_filt_params->feat_seln);
1081         /* select feature based on control block settings */
1082         UINT8_TO_STREAM(p, BTM_BLE_META_PF_FEAT_SEL);
1083         UINT8_TO_STREAM(p, BTM_BLE_SCAN_COND_ADD);
1084
1085         /* Filter index */
1086         UINT8_TO_STREAM(p, filt_index);
1087
1088         /* set PCF selection */
1089         UINT16_TO_STREAM(p, p_filt_params->feat_seln);
1090         /* set logic type */
1091         UINT16_TO_STREAM(p, p_filt_params->logic_type);
1092         /* set logic condition */
1093         UINT8_TO_STREAM(p, p_filt_params->filt_logic_type);
1094         /* set RSSI high threshold */
1095         UINT8_TO_STREAM(p, p_filt_params->rssi_high_thres);
1096         /* set delivery mode */
1097         UINT8_TO_STREAM(p, p_filt_params->dely_mode);
1098
1099         if (0x01 == p_filt_params->dely_mode)
1100         {
1101             /* set onfound timeout */
1102             UINT16_TO_STREAM(p, p_filt_params->found_timeout);
1103             /* set onfound timeout count*/
1104             UINT8_TO_STREAM(p, p_filt_params->found_timeout_cnt);
1105             /* set RSSI low threshold */
1106             UINT8_TO_STREAM(p, p_filt_params->rssi_low_thres);
1107             /* set onlost timeout */
1108             UINT16_TO_STREAM(p, p_filt_params->lost_timeout);
1109             /* set num_of_track_entries for firmware greater than L-release version */
1110             if (cmn_ble_vsc_cb.version_supported > BTM_VSC_CHIP_CAPABILITY_L_VERSION)
1111                 UINT16_TO_STREAM(p, p_filt_params->num_of_tracking_entries);
1112         }
1113
1114         if (cmn_ble_vsc_cb.version_supported == BTM_VSC_CHIP_CAPABILITY_L_VERSION)
1115             len = BTM_BLE_ADV_FILT_META_HDR_LENGTH + BTM_BLE_ADV_FILT_FEAT_SELN_LEN;
1116         else
1117             len = BTM_BLE_ADV_FILT_META_HDR_LENGTH + BTM_BLE_ADV_FILT_FEAT_SELN_LEN +
1118                   BTM_BLE_ADV_FILT_TRACK_NUM;
1119
1120         if ((st = BTM_VendorSpecificCommand (HCI_BLE_ADV_FILTER_OCF,
1121                                 (UINT8)len,
1122                                  param,
1123                                  btm_ble_scan_pf_cmpl_cback))
1124                == BTM_NO_RESOURCES)
1125         {
1126             return st;
1127         }
1128         btm_ble_advfilt_enq_op_q(action, BTM_BLE_META_PF_FEAT_SEL, BTM_BLE_FILT_ADV_PARAM,
1129                                  ref_value, NULL, p_cmpl_cback);
1130     }
1131     else
1132     if (BTM_BLE_SCAN_COND_DELETE == action)
1133     {
1134         /* select feature based on control block settings */
1135         UINT8_TO_STREAM(p, BTM_BLE_META_PF_FEAT_SEL);
1136         UINT8_TO_STREAM(p, BTM_BLE_SCAN_COND_DELETE);
1137         /* Filter index */
1138         UINT8_TO_STREAM(p, filt_index);
1139
1140         if ((st = BTM_VendorSpecificCommand (HCI_BLE_ADV_FILTER_OCF,
1141                                 (UINT8)(BTM_BLE_ADV_FILT_META_HDR_LENGTH),
1142                                  param,
1143                                  btm_ble_scan_pf_cmpl_cback))
1144                == BTM_NO_RESOURCES)
1145         {
1146             return st;
1147         }
1148         btm_ble_advfilt_enq_op_q(action, BTM_BLE_META_PF_FEAT_SEL,  BTM_BLE_FILT_ADV_PARAM,
1149                                  ref_value, NULL, p_cmpl_cback);
1150     }
1151     else
1152     if (BTM_BLE_SCAN_COND_CLEAR == action)
1153     {
1154         /* Deallocate all filters here */
1155         btm_ble_dealloc_addr_filter_counter(NULL, BTM_BLE_PF_TYPE_ALL);
1156
1157         /* select feature based on control block settings */
1158         UINT8_TO_STREAM(p, BTM_BLE_META_PF_FEAT_SEL);
1159         UINT8_TO_STREAM(p, BTM_BLE_SCAN_COND_CLEAR);
1160
1161         if ((st = BTM_VendorSpecificCommand (HCI_BLE_ADV_FILTER_OCF,
1162                                 (UINT8)(BTM_BLE_ADV_FILT_META_HDR_LENGTH-1),
1163                                  param,
1164                                  btm_ble_scan_pf_cmpl_cback))
1165                == BTM_NO_RESOURCES)
1166         {
1167             return st;
1168         }
1169         btm_ble_advfilt_enq_op_q(action, BTM_BLE_META_PF_FEAT_SEL,  BTM_BLE_FILT_ADV_PARAM,
1170                                  ref_value, NULL, p_cmpl_cback);
1171     }
1172
1173     return st;
1174 }
1175
1176 /*******************************************************************************
1177 **
1178 ** Function         BTM_BleEnableDisableFilterFeature
1179 **
1180 ** Description      This function is called to enable / disable the APCF feature
1181 **
1182 ** Parameters  enable the generic scan condition.
1183 **                  enable: enable or disable the filter condition
1184 **                  p_stat_cback - Status callback pointer
1185 **                  ref_value   - Ref value
1186 ** Returns          void
1187 **
1188 *******************************************************************************/
1189 tBTM_STATUS BTM_BleEnableDisableFilterFeature(UINT8 enable,
1190                                      tBTM_BLE_PF_STATUS_CBACK *p_stat_cback,
1191                                      tBTM_BLE_REF_VALUE ref_value)
1192 {
1193     UINT8           param[20], *p;
1194     tBTM_STATUS     st = BTM_WRONG_MODE;
1195
1196     if (BTM_SUCCESS  != btm_ble_obtain_vsc_details())
1197        return st;
1198
1199     p = param;
1200     memset(param, 0, 20);
1201
1202     /* enable the content filter in controller */
1203     p = param;
1204     UINT8_TO_STREAM(p, BTM_BLE_META_PF_ENABLE);
1205     /* enable adv data payload filtering */
1206     UINT8_TO_STREAM(p, enable);
1207
1208     if ((st = BTM_VendorSpecificCommand (HCI_BLE_ADV_FILTER_OCF,
1209                               BTM_BLE_PCF_ENABLE_LEN, param,
1210                               btm_ble_scan_pf_cmpl_cback)) == BTM_CMD_STARTED)
1211     {
1212          btm_ble_adv_filt_cb.p_filt_stat_cback = p_stat_cback;
1213          btm_ble_advfilt_enq_op_q(enable, BTM_BLE_META_PF_ENABLE, BTM_BLE_FILT_ENABLE_DISABLE,
1214                                   ref_value, NULL, NULL);
1215     }
1216     return st;
1217 }
1218
1219 /*******************************************************************************
1220 **
1221 ** Function         BTM_BleCfgFilterCondition
1222 **
1223 ** Description      This function is called to configure the adv data payload filter
1224 **                  condition.
1225 **
1226 ** Parameters       action: to read/write/clear
1227 **                  cond_type: filter condition type.
1228 **                  filt_index - Filter index
1229 **                  p_cond: filter condition parameter
1230 **                  p_cmpl_cback  - Config callback pointer
1231 **                  ref_value - Reference value
1232 **
1233 ** Returns          void
1234 **
1235 *******************************************************************************/
1236 tBTM_STATUS BTM_BleCfgFilterCondition(tBTM_BLE_SCAN_COND_OP action,
1237                                       tBTM_BLE_PF_COND_TYPE cond_type,
1238                                       tBTM_BLE_PF_FILT_INDEX filt_index,
1239                                       tBTM_BLE_PF_COND_PARAM *p_cond,
1240                                       tBTM_BLE_PF_CFG_CBACK *p_cmpl_cback,
1241                                       tBTM_BLE_REF_VALUE ref_value)
1242 {
1243     tBTM_STATUS     st = BTM_ILLEGAL_VALUE;
1244     UINT8 ocf = 0;
1245     BTM_TRACE_EVENT (" BTM_BleCfgFilterCondition action:%d, cond_type:%d, index:%d", action,
1246                         cond_type, filt_index);
1247
1248     if (BTM_SUCCESS  != btm_ble_obtain_vsc_details())
1249         return st;
1250
1251     switch (cond_type)
1252     {
1253         /* write service data filter */
1254         case BTM_BLE_PF_SRVC_DATA_PATTERN:
1255         /* write manufacturer data filter */
1256         case BTM_BLE_PF_MANU_DATA:
1257             st = btm_ble_update_pf_manu_data(action, filt_index, p_cond, cond_type, 0, ref_value);
1258             break;
1259
1260         /* write local name filter */
1261         case BTM_BLE_PF_LOCAL_NAME:
1262             st = btm_ble_update_pf_local_name(action, filt_index, p_cond);
1263             break;
1264
1265         /* filter on advertiser address */
1266         case BTM_BLE_PF_ADDR_FILTER:
1267             st = btm_ble_update_addr_filter(action, filt_index, p_cond);
1268             break;
1269
1270         /* filter on service/solicitated UUID */
1271         case BTM_BLE_PF_SRVC_UUID:
1272         case BTM_BLE_PF_SRVC_SOL_UUID:
1273             st = btm_ble_update_uuid_filter(action, filt_index, cond_type, p_cond, 0, ref_value);
1274             break;
1275
1276         case BTM_BLE_PF_SRVC_DATA:
1277             st = btm_ble_update_srvc_data_change(action, filt_index, p_cond);
1278             break;
1279
1280         case BTM_BLE_PF_TYPE_ALL: /* only used to clear filter */
1281             st = btm_ble_clear_scan_pf_filter(action, filt_index, p_cond, p_cmpl_cback,
1282                                               0, ref_value);
1283             break;
1284
1285         default:
1286             BTM_TRACE_WARNING("condition type [%d] not supported currently.", cond_type);
1287             break;
1288     }
1289
1290     if(BTM_CMD_STARTED == st && cond_type != BTM_BLE_PF_TYPE_ALL)
1291     {
1292        ocf = btm_ble_condtype_to_ocf(cond_type);
1293        btm_ble_advfilt_enq_op_q(action, ocf, BTM_BLE_FILT_CFG, ref_value, p_cmpl_cback, NULL);
1294     }
1295     else
1296     if(BTM_CMD_STARTED == st && BTM_BLE_PF_TYPE_ALL == cond_type)
1297     {
1298        btm_ble_advfilt_enq_op_q(action, BTM_BLE_META_PF_FEAT_SEL, BTM_BLE_FILT_CFG,
1299                                 ref_value, p_cmpl_cback, NULL);
1300     }
1301     return st;
1302 }
1303
1304 /*******************************************************************************
1305 **
1306 ** Function         btm_ble_adv_filter_init
1307 **
1308 ** Description      This function initializes the adv filter control block
1309 **
1310 ** Parameters
1311 **
1312 ** Returns          status
1313 **
1314 *******************************************************************************/
1315 void btm_ble_adv_filter_init(void)
1316 {
1317     memset(&btm_ble_adv_filt_cb, 0, sizeof(tBTM_BLE_MULTI_ADV_CB));
1318     if (BTM_SUCCESS != btm_ble_obtain_vsc_details())
1319        return;
1320
1321     if (cmn_ble_vsc_cb.max_filter > 0)
1322     {
1323         btm_ble_adv_filt_cb.p_addr_filter_count =
1324             (tBTM_BLE_PF_COUNT*) GKI_getbuf( sizeof(tBTM_BLE_PF_COUNT) * cmn_ble_vsc_cb.max_filter);
1325     }
1326 }
1327
1328 /*******************************************************************************
1329 **
1330 ** Function         btm_ble_adv_filter_cleanup
1331 **
1332 ** Description      This function de-initializes the adv filter control block
1333 **
1334 ** Parameters
1335 **
1336 ** Returns          status
1337 **
1338 *******************************************************************************/
1339 void btm_ble_adv_filter_cleanup(void)
1340 {
1341     if (btm_ble_adv_filt_cb.p_addr_filter_count)
1342         GKI_freebuf (btm_ble_adv_filt_cb.p_addr_filter_count);
1343 }
1344
1345 #endif