stack/btm/btm_ble_gap.c

   1 /******************************************************************************
   2  *
   3  *  Copyright (C) 2008-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 /******************************************************************************
  20  *
  21  *  This file contains functions for BLE GAP.
  22  *
  23  ******************************************************************************/
  24
  25 #include <string.h>
  26 #include <stdio.h>
  27 #include <stddef.h>
  28
  29 #include "bt_types.h"
  30 #include "bt_utils.h"
  31 #include "btm_int.h"
  32 #include "btm_ble_api.h"
  33 #include "btu.h"
  34 #include "hcimsgs.h"
  35 #if (GAP_INCLUDED == TRUE)
  36 #include "gap_api.h"
  37 #endif
  38
  39 #if BLE_INCLUDED == TRUE
  40 #include "l2c_int.h"
  41 #include "vendor_ble.h"
  42
  43 #include "gattdefs.h"
  44 #include "gatt_int.h"
  45
  46 #include "btm_ble_int.h"
  47
  48 #define BTM_BLE_NAME_SHORT                  0x01
  49 #define BTM_BLE_NAME_CMPL                   0x02
  50
  51 #define BTM_BLE_FILTER_TARGET_UNKNOWN       0xff
  52 #define BTM_BLE_POLICY_UNKNOWN              0xff
  53
  54 #define BTM_EXT_BLE_RMT_NAME_TIMEOUT        30
  55 #define MIN_ADV_LENGTH                       2
  56
  57 #if BLE_VND_INCLUDED == TRUE
  58 static tBTM_BLE_CTRL_FEATURES_CBACK    *p_ctrl_le_feature_rd_cmpl_cback = NULL;
  59 #endif
  60
  61 /*******************************************************************************
  62 **  Local functions
  63 *******************************************************************************/
  64 static void btm_ble_update_adv_flag(UINT8 flag);
  65 static void btm_ble_process_adv_pkt_cont(BD_ADDR bda, UINT8 addr_type, UINT8 evt_type, UINT8 *p);
  66 UINT8 *btm_ble_build_adv_data(tBTM_BLE_AD_MASK *p_data_mask, UINT8 **p_dst,
  67                               tBTM_BLE_ADV_DATA *p_data);
  68 static UINT8 btm_set_conn_mode_adv_init_addr(tBTM_BLE_INQ_CB *p_cb,
  69                                      BD_ADDR_PTR p_addr_ptr,
  70                                      tBLE_ADDR_TYPE *p_init_addr_type,
  71                                      tBLE_ADDR_TYPE *p_own_addr_type);
  72 static void btm_ble_stop_observe(void);
  73
  74 #define BTM_BLE_INQ_RESULT          0x01
  75 #define BTM_BLE_OBS_RESULT          0x02
  76 #define BTM_BLE_SEL_CONN_RESULT     0x04
  77
  78 /* LE states combo bit to check */
  79 const UINT8 btm_le_state_combo_tbl[BTM_BLE_STATE_MAX][BTM_BLE_STATE_MAX][2] =
  80 {
  81     {/* single state support */
  82         {HCI_SUPP_LE_STATES_CONN_ADV_MASK, HCI_SUPP_LE_STATES_CONN_ADV_OFF},  /* conn_adv */
  83         {HCI_SUPP_LE_STATES_INIT_MASK, HCI_SUPP_LE_STATES_INIT_OFF}, /* init */
  84         {HCI_SUPP_LE_STATES_INIT_MASK, HCI_SUPP_LE_STATES_INIT_OFF}, /* master */
  85         {HCI_SUPP_LE_STATES_SLAVE_MASK, HCI_SUPP_LE_STATES_SLAVE_OFF}, /* slave */
  86         {0, 0},                   /* todo: lo du dir adv, not covered ? */
  87         {HCI_SUPP_LE_STATES_HI_DUTY_DIR_ADV_MASK, HCI_SUPP_LE_STATES_HI_DUTY_DIR_ADV_OFF}, /* hi duty dir adv */
  88         {HCI_SUPP_LE_STATES_NON_CONN_ADV_MASK, HCI_SUPP_LE_STATES_NON_CONN_ADV_OFF},  /* non connectable adv */
  89         {HCI_SUPP_LE_STATES_PASS_SCAN_MASK, HCI_SUPP_LE_STATES_PASS_SCAN_OFF},   /*  passive scan */
  90         {HCI_SUPP_LE_STATES_ACTIVE_SCAN_MASK, HCI_SUPP_LE_STATES_ACTIVE_SCAN_OFF},  /*   active scan */
  91         {HCI_SUPP_LE_STATES_SCAN_ADV_MASK, HCI_SUPP_LE_STATESSCAN_ADV_OFF}   /* scanable adv */
  92     },
  93     {    /* conn_adv =0 */
  94         {0, 0},                                                                           /* conn_adv */
  95         {HCI_SUPP_LE_STATES_CONN_ADV_INIT_MASK, HCI_SUPP_LE_STATES_CONN_ADV_INIT_OFF},      /* init: 32 */
  96         {HCI_SUPP_LE_STATES_CONN_ADV_MASTER_MASK, HCI_SUPP_LE_STATES_CONN_ADV_MASTER_OFF},  /* master: 35 */
  97         {HCI_SUPP_LE_STATES_CONN_ADV_SLAVE_MASK, HCI_SUPP_LE_STATES_CONN_ADV_SLAVE_OFF}, /* slave: 38,*/
  98         {0, 0},                                                                           /* lo du dir adv */
  99         {0, 0},                                                                            /* hi duty dir adv */
 100         {0, 0},  /* non connectable adv */
 101         {HCI_SUPP_LE_STATES_CONN_ADV_PASS_SCAN_MASK, HCI_SUPP_LE_STATES_CONN_ADV_PASS_SCAN_OFF},   /*  passive scan */
 102         {HCI_SUPP_LE_STATES_CONN_ADV_ACTIVE_SCAN_MASK, HCI_SUPP_LE_STATES_CONN_ADV_ACTIVE_SCAN_OFF},  /*   active scan */
 103         {0, 0}   /* scanable adv */
 104     },
 105     {   /* init */
 106         {HCI_SUPP_LE_STATES_CONN_ADV_INIT_MASK, HCI_SUPP_LE_STATES_CONN_ADV_INIT_OFF},      /* conn_adv: 32 */
 107         {0, 0},                                                                             /* init */
 108         {HCI_SUPP_LE_STATES_INIT_MASTER_MASK, HCI_SUPP_LE_STATES_INIT_MASTER_OFF},          /* master 28 */
 109         {HCI_SUPP_LE_STATES_INIT_MASTER_SLAVE_MASK, HCI_SUPP_LE_STATES_INIT_MASTER_SLAVE_OFF}, /* slave 41 */
 110         {HCI_SUPP_LE_STATES_LO_DUTY_DIR_ADV_INIT_MASK, HCI_SUPP_LE_STATES_LO_DUTY_DIR_ADV_INIT_OFF} ,/* lo du dir adv 34 */
 111         {HCI_SUPP_LE_STATES_HI_DUTY_DIR_ADV_INIT_MASK, HCI_SUPP_LE_STATES_HI_DUTY_DIR_ADV_INIT_OFF},     /* hi duty dir adv 33 */
 112         {HCI_SUPP_LE_STATES_NON_CONN_INIT_MASK, HCI_SUPP_LE_STATES_NON_CONN_INIT_OFF},  /*  non connectable adv */
 113         {HCI_SUPP_LE_STATES_PASS_SCAN_INIT_MASK, HCI_SUPP_LE_STATES_PASS_SCAN_INIT_OFF},   /* passive scan */
 114         {HCI_SUPP_LE_STATES_ACTIVE_SCAN_INIT_MASK, HCI_SUPP_LE_STATES_ACTIVE_SCAN_INIT_OFF},  /*  active scan */
 115         {HCI_SUPP_LE_STATES_SCAN_ADV_INIT_MASK, HCI_SUPP_LE_STATES_SCAN_ADV_INIT_OFF}   /* scanable adv */
 116
 117     },
 118     {   /* master */
 119         {HCI_SUPP_LE_STATES_CONN_ADV_MASTER_MASK, HCI_SUPP_LE_STATES_CONN_ADV_MASTER_OFF},  /* conn_adv: 35 */
 120         {HCI_SUPP_LE_STATES_INIT_MASTER_MASK, HCI_SUPP_LE_STATES_INIT_MASTER_OFF},          /* init 28 */
 121         {HCI_SUPP_LE_STATES_INIT_MASTER_MASK, HCI_SUPP_LE_STATES_INIT_MASTER_OFF},          /* master 28 */
 122         {HCI_SUPP_LE_STATES_CONN_ADV_INIT_MASK, HCI_SUPP_LE_STATES_CONN_ADV_INIT_OFF},      /* slave: 32 */
 123         {HCI_SUPP_LE_STATES_LO_DUTY_DIR_ADV_MASTER_MASK, HCI_SUPP_LE_STATES_LO_DUTY_DIR_ADV_MASTER_OFF},  /* lo duty cycle adv 37 */
 124         {HCI_SUPP_LE_STATES_HI_DUTY_DIR_ADV_MASTER_MASK, HCI_SUPP_LE_STATES_HI_DUTY_DIR_ADV_MASTER_OFF},   /* hi duty cycle adv 36 */
 125         {HCI_SUPP_LE_STATES_NON_CONN_ADV_MASTER_MASK, HCI_SUPP_LE_STATES_NON_CONN_ADV_MASTER_OFF},  /*  non connectable adv */
 126         {HCI_SUPP_LE_STATES_PASS_SCAN_MASTER_MASK, HCI_SUPP_LE_STATES_PASS_SCAN_MASTER_OFF},   /*  passive scan */
 127         {HCI_SUPP_LE_STATES_ACTIVE_SCAN_MASTER_MASK, HCI_SUPP_LE_STATES_ACTIVE_SCAN_MASTER_OFF},  /*   active scan */
 128         {HCI_SUPP_LE_STATES_SCAN_ADV_MASTER_MASK, HCI_SUPP_LE_STATES_SCAN_ADV_MASTER_OFF}   /*  scanable adv */
 129
 130     },
 131     { /* slave */
 132         {HCI_SUPP_LE_STATES_CONN_ADV_SLAVE_MASK, HCI_SUPP_LE_STATES_CONN_ADV_SLAVE_OFF}, /* conn_adv: 38,*/
 133         {HCI_SUPP_LE_STATES_INIT_MASTER_SLAVE_MASK, HCI_SUPP_LE_STATES_INIT_MASTER_SLAVE_OFF}, /* init 41 */
 134         {HCI_SUPP_LE_STATES_INIT_MASTER_SLAVE_MASK, HCI_SUPP_LE_STATES_INIT_MASTER_SLAVE_OFF}, /* master 41 */
 135         {HCI_SUPP_LE_STATES_CONN_ADV_SLAVE_MASK, HCI_SUPP_LE_STATES_CONN_ADV_SLAVE_OFF},        /* slave: 38,*/
 136         {HCI_SUPP_LE_STATES_LO_DUTY_DIR_ADV_SLAVE_MASK, HCI_SUPP_LE_STATES_LO_DUTY_DIR_ADV_SLAVE_OFF},  /* lo duty cycle adv 40 */
 137         {HCI_SUPP_LE_STATES_HI_DUTY_DIR_ADV_SLAVE_MASK, HCI_SUPP_LE_STATES_HI_DUTY_DIR_ADV_SLAVE_OFF},   /* hi duty cycle adv 39 */
 138         {HCI_SUPP_LE_STATES_NON_CONN_ADV_SLAVE_MASK, HCI_SUPP_LE_STATES_NON_CONN_ADV_SLAVE_OFF},  /* non connectable adv */
 139         {HCI_SUPP_LE_STATES_PASS_SCAN_SLAVE_MASK, HCI_SUPP_LE_STATES_PASS_SCAN_SLAVE_OFF},   /* passive scan */
 140         {HCI_SUPP_LE_STATES_ACTIVE_SCAN_SLAVE_MASK, HCI_SUPP_LE_STATES_ACTIVE_SCAN_SLAVE_OFF},  /*  active scan */
 141         {HCI_SUPP_LE_STATES_SCAN_ADV_SLAVE_MASK, HCI_SUPP_LE_STATES_SCAN_ADV_SLAVE_OFF}   /* scanable adv */
 142
 143     },
 144     { /* lo duty cycle adv */
 145         {0, 0}, /* conn_adv: 38,*/
 146         {HCI_SUPP_LE_STATES_LO_DUTY_DIR_ADV_INIT_MASK, HCI_SUPP_LE_STATES_LO_DUTY_DIR_ADV_INIT_OFF} ,/* init 34 */
 147         {HCI_SUPP_LE_STATES_LO_DUTY_DIR_ADV_MASTER_MASK, HCI_SUPP_LE_STATES_LO_DUTY_DIR_ADV_MASTER_OFF}, /* master 37 */
 148         {HCI_SUPP_LE_STATES_LO_DUTY_DIR_ADV_SLAVE_MASK, HCI_SUPP_LE_STATES_LO_DUTY_DIR_ADV_SLAVE_OFF}, /* slave: 40 */
 149         {0, 0},  /* lo duty cycle adv 40 */
 150         {0, 0},   /* hi duty cycle adv 39 */
 151         {0, 0},  /*  non connectable adv */
 152         {0, 0},   /* TODO: passive scan, not covered? */
 153         {0, 0},  /* TODO:  active scan, not covered? */
 154         {0, 0}   /*  scanable adv */
 155     },
 156     { /* hi duty cycle adv */
 157         {0, 0}, /* conn_adv: 38,*/
 158         {HCI_SUPP_LE_STATES_HI_DUTY_DIR_ADV_INIT_MASK, HCI_SUPP_LE_STATES_HI_DUTY_DIR_ADV_INIT_OFF}, /* init 33 */
 159         {HCI_SUPP_LE_STATES_HI_DUTY_DIR_ADV_MASTER_MASK, HCI_SUPP_LE_STATES_HI_DUTY_DIR_ADV_MASTER_OFF}, /* master 36 */
 160         {HCI_SUPP_LE_STATES_HI_DUTY_DIR_ADV_SLAVE_MASK, HCI_SUPP_LE_STATES_HI_DUTY_DIR_ADV_SLAVE_OFF},   /* slave: 39*/
 161         {0, 0},  /* lo duty cycle adv 40 */
 162         {0, 0},   /* hi duty cycle adv 39 */
 163         {0, 0},  /* non connectable adv */
 164         {HCI_SUPP_LE_STATES_HI_DUTY_DIR_ADV_PASS_SCAN_MASK, HCI_SUPP_LE_STATES_HI_DUTY_DIR_ADV_PASS_SCAN_OFF},   /* passive scan */
 165         {HCI_SUPP_LE_STATES_HI_DUTY_DIR_ADV_ACTIVE_SCAN_MASK, HCI_SUPP_LE_STATES_HI_DUTY_DIR_ADV_ACTIVE_SCAN_OFF},  /* active scan */
 166         {0, 0}   /* scanable adv */
 167     },
 168     { /* non connectable adv */
 169         {0, 0}, /* conn_adv: */
 170         {HCI_SUPP_LE_STATES_NON_CONN_INIT_MASK, HCI_SUPP_LE_STATES_NON_CONN_INIT_OFF}, /* init  */
 171         {HCI_SUPP_LE_STATES_NON_CONN_ADV_MASTER_MASK, HCI_SUPP_LE_STATES_NON_CONN_ADV_MASTER_OFF}, /* master  */
 172         {HCI_SUPP_LE_STATES_NON_CONN_ADV_SLAVE_MASK, HCI_SUPP_LE_STATES_NON_CONN_ADV_SLAVE_OFF},   /* slave: */
 173         {0, 0},  /* lo duty cycle adv */
 174         {0, 0},   /* hi duty cycle adv */
 175         {0, 0},  /* non connectable adv */
 176         {HCI_SUPP_LE_STATES_NON_CONN_ADV_PASS_SCAN_MASK, HCI_SUPP_LE_STATES_NON_CONN_ADV_PASS_SCAN_OFF},   /* passive scan */
 177         {HCI_SUPP_LE_STATES_NON_CONN_ADV_ACTIVE_SCAN_MASK, HCI_SUPP_LE_STATES_NON_CONN_ADV_ACTIVE_SCAN_OFF},  /*  active scan */
 178         {0, 0}   /* scanable adv */
 179     },
 180     { /* passive scan */
 181         {HCI_SUPP_LE_STATES_CONN_ADV_PASS_SCAN_MASK, HCI_SUPP_LE_STATES_CONN_ADV_PASS_SCAN_OFF}, /* conn_adv: */
 182         {HCI_SUPP_LE_STATES_PASS_SCAN_INIT_MASK, HCI_SUPP_LE_STATES_PASS_SCAN_INIT_OFF}, /* init  */
 183         {HCI_SUPP_LE_STATES_PASS_SCAN_MASTER_MASK, HCI_SUPP_LE_STATES_PASS_SCAN_MASTER_OFF}, /* master  */
 184         {HCI_SUPP_LE_STATES_PASS_SCAN_SLAVE_MASK, HCI_SUPP_LE_STATES_PASS_SCAN_SLAVE_OFF},   /* slave: */
 185         {0, 0},  /* lo duty cycle adv */
 186         {HCI_SUPP_LE_STATES_HI_DUTY_DIR_ADV_PASS_SCAN_MASK, HCI_SUPP_LE_STATES_HI_DUTY_DIR_ADV_PASS_SCAN_OFF},   /* hi duty cycle adv */
 187         {HCI_SUPP_LE_STATES_NON_CONN_ADV_PASS_SCAN_MASK, HCI_SUPP_LE_STATES_NON_CONN_ADV_PASS_SCAN_OFF},  /*  non connectable adv */
 188         {0, 0},   /* passive scan */
 189         {0, 0},  /* active scan */
 190          {HCI_SUPP_LE_STATES_SCAN_ADV_PASS_SCAN_MASK, HCI_SUPP_LE_STATES_SCAN_ADV_PASS_SCAN_OFF}   /* scanable adv */
 191     },
 192     { /* active scan */
 193         {HCI_SUPP_LE_STATES_CONN_ADV_ACTIVE_SCAN_MASK, HCI_SUPP_LE_STATES_CONN_ADV_ACTIVE_SCAN_OFF}, /* conn_adv: */
 194         {HCI_SUPP_LE_STATES_ACTIVE_SCAN_INIT_MASK, HCI_SUPP_LE_STATES_ACTIVE_SCAN_INIT_OFF}, /* init  */
 195         {HCI_SUPP_LE_STATES_ACTIVE_SCAN_MASTER_MASK, HCI_SUPP_LE_STATES_ACTIVE_SCAN_MASTER_OFF}, /* master  */
 196         {HCI_SUPP_LE_STATES_ACTIVE_SCAN_SLAVE_MASK, HCI_SUPP_LE_STATES_ACTIVE_SCAN_SLAVE_OFF},   /* slave: */
 197         {0, 0},  /* lo duty cycle adv */
 198         {HCI_SUPP_LE_STATES_HI_DUTY_DIR_ADV_ACTIVE_SCAN_MASK, HCI_SUPP_LE_STATES_HI_DUTY_DIR_ADV_ACTIVE_SCAN_OFF},   /* hi duty cycle adv */
 199         {HCI_SUPP_LE_STATES_NON_CONN_ADV_ACTIVE_SCAN_MASK, HCI_SUPP_LE_STATES_NON_CONN_ADV_ACTIVE_SCAN_OFF},  /*  non connectable adv */
 200         {0, 0},   /* TODO: passive scan */
 201         {0, 0},  /* TODO:  active scan */
 202         {HCI_SUPP_LE_STATES_SCAN_ADV_ACTIVE_SCAN_MASK, HCI_SUPP_LE_STATES_SCAN_ADV_ACTIVE_SCAN_OFF}   /*  scanable adv */
 203     },
 204     { /* scanable adv */
 205         {0, 0}, /* conn_adv: */
 206         {HCI_SUPP_LE_STATES_SCAN_ADV_INIT_MASK, HCI_SUPP_LE_STATES_SCAN_ADV_INIT_OFF}, /* init  */
 207         {HCI_SUPP_LE_STATES_SCAN_ADV_MASTER_MASK, HCI_SUPP_LE_STATES_SCAN_ADV_MASTER_OFF}, /* master  */
 208         {HCI_SUPP_LE_STATES_SCAN_ADV_SLAVE_MASK, HCI_SUPP_LE_STATES_SCAN_ADV_SLAVE_OFF},   /* slave: */
 209         {0, 0},  /* lo duty cycle adv */
 210         {0, 0},   /* hi duty cycle adv */
 211         {0, 0},  /* non connectable adv */
 212         {HCI_SUPP_LE_STATES_SCAN_ADV_PASS_SCAN_MASK, HCI_SUPP_LE_STATES_SCAN_ADV_PASS_SCAN_OFF},   /*  passive scan */
 213         {HCI_SUPP_LE_STATES_SCAN_ADV_ACTIVE_SCAN_MASK, HCI_SUPP_LE_STATES_SCAN_ADV_ACTIVE_SCAN_OFF},  /*  active scan */
 214         {0, 0}   /* scanable adv */
 215     }
 216
 217 };
 218 /* check LE combo state supported */
 219 #define BTM_LE_STATES_SUPPORTED(x, y, z)      ((x)[(z)] & (y))
 220
 221
 222 /*******************************************************************************
 223 **
 224 ** Function         BTM_BleUpdateAdvWhitelist
 225 **
 226 ** Description      Add or remove device from advertising white list
 227 **
 228 ** Returns          void
 229 **
 230 *******************************************************************************/
 231 BOOLEAN BTM_BleUpdateAdvWhitelist(BOOLEAN add_remove, BD_ADDR remote_bda)
 232 {
 233     UNUSED(add_remove);
 234     UNUSED(remote_bda);
 235
 236     return FALSE;
 237 }
 238
 239 /*******************************************************************************
 240 **
 241 ** Function         BTM_BleUpdateAdvFilterPolicy
 242 **
 243 ** Description      This function update the filter policy of advertiser.
 244 **
 245 ** Parameter        adv_policy: advertising filter policy
 246 **
 247 ** Return           void
 248 *******************************************************************************/
 249 void BTM_BleUpdateAdvFilterPolicy(tBTM_BLE_AFP adv_policy)
 250 {
 251     tBTM_BLE_INQ_CB *p_cb = &btm_cb.ble_ctr_cb.inq_var;
 252     tBLE_ADDR_TYPE   init_addr_type = BLE_ADDR_PUBLIC;
 253     BD_ADDR          p_addr_ptr= {0};
 254     UINT8            adv_mode = p_cb->adv_mode;
 255
 256     BTM_TRACE_EVENT ("BTM_BleUpdateAdvFilterPolicy");
 257
 258     if (!HCI_LE_HOST_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_1]))
 259         return;
 260
 261     if (p_cb->afp != adv_policy)
 262     {
 263         p_cb->afp = adv_policy;
 264
 265         /* if adv active, stop and restart */
 266         btm_ble_stop_adv ();
 267
 268         if (p_cb->connectable_mode & BTM_BLE_CONNECTABLE)
 269             p_cb->evt_type = btm_set_conn_mode_adv_init_addr(p_cb, p_addr_ptr, &init_addr_type,
 270                                                               &p_cb->adv_addr_type);
 271
 272         btsnd_hcic_ble_write_adv_params ((UINT16)(p_cb->adv_interval_min ? p_cb->adv_interval_min :
 273                                          BTM_BLE_GAP_ADV_SLOW_INT),
 274                                          (UINT16)(p_cb->adv_interval_max ? p_cb->adv_interval_max :
 275                                          BTM_BLE_GAP_ADV_SLOW_INT),
 276                                          p_cb->evt_type,
 277                                          p_cb->adv_addr_type,
 278                                          init_addr_type,
 279                                          p_addr_ptr,
 280                                          p_cb->adv_chnl_map,
 281                                          p_cb->afp);
 282
 283         if (adv_mode == BTM_BLE_ADV_ENABLE)
 284             btm_ble_start_adv ();
 285
 286     }
 287 }
 288 /*******************************************************************************
 289 **
 290 ** Function         BTM_BleObserve
 291 **
 292 ** Description      This procedure keep the device listening for advertising
 293 **                  events from a broadcast device.
 294 **
 295 ** Parameters       start: start or stop observe.
 296 **                  white_list: use white list in observer mode or not.
 297 **
 298 ** Returns          void
 299 **
 300 *******************************************************************************/
 301 tBTM_STATUS BTM_BleObserve(BOOLEAN start, UINT8 duration,
 302                            tBTM_INQ_RESULTS_CB *p_results_cb, tBTM_CMPL_CB *p_cmpl_cb)
 303 {
 304     tBTM_BLE_INQ_CB *p_inq = &btm_cb.ble_ctr_cb.inq_var;
 305     tBTM_STATUS     status = BTM_WRONG_MODE;
 306
 307     BTM_TRACE_EVENT ("BTM_BleObserve : scan_type:%d",btm_cb.btm_inq_vars.scan_type);
 308
 309     if (!HCI_LE_HOST_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_1]))
 310         return BTM_ILLEGAL_VALUE;
 311
 312     if (start)
 313     {
 314         /* shared inquiry database, do not allow observe if any inquiry is active */
 315         if (BTM_BLE_IS_OBS_ACTIVE(btm_cb.ble_ctr_cb.scan_activity))
 316         {
 317             BTM_TRACE_ERROR("Observe Already Active");
 318             return status;
 319         }
 320
 321         btm_cb.ble_ctr_cb.p_obs_results_cb = p_results_cb;
 322         btm_cb.ble_ctr_cb.p_obs_cmpl_cb = p_cmpl_cb;
 323         status = BTM_CMD_STARTED;
 324
 325         /* scan is not started */
 326         if (!BTM_BLE_IS_SCAN_ACTIVE(btm_cb.ble_ctr_cb.scan_activity))
 327         {
 328             p_inq->scan_type = (p_inq->scan_type == BTM_BLE_SCAN_MODE_NONE) ? BTM_BLE_SCAN_MODE_ACTI: p_inq->scan_type;
 329             /* allow config scanning type */
 330             btsnd_hcic_ble_set_scan_params (p_inq->scan_type,
 331                                             (UINT16)(!p_inq->scan_interval ? BTM_BLE_GAP_DISC_SCAN_INT : p_inq->scan_interval),
 332                                             (UINT16)(!p_inq->scan_window ? BTM_BLE_GAP_DISC_SCAN_WIN : p_inq->scan_window),
 333                                             btm_cb.ble_ctr_cb.addr_mgnt_cb.own_addr_type,
 334                                             BTM_BLE_DEFAULT_SFP); /* assume observe always not using white list */
 335
 336 #if (defined BLE_PRIVACY_SPT && BLE_PRIVACY_SPT == TRUE)
 337             /* enable IRK list */
 338             btm_ble_vendor_irk_list_known_dev (TRUE);
 339 #endif
 340             status = btm_ble_start_scan(BTM_BLE_DUPLICATE_DISABLE);
 341         }
 342         if (status == BTM_CMD_STARTED)
 343         {
 344             btm_cb.ble_ctr_cb.scan_activity |= BTM_LE_OBSERVE_ACTIVE;
 345
 346             if (duration != 0)
 347                 /* start observer timer */
 348                 btu_start_timer (&btm_cb.ble_ctr_cb.obs_timer_ent, BTU_TTYPE_BLE_OBSERVE, duration);
 349         }
 350     }
 351     else if (BTM_BLE_IS_OBS_ACTIVE(btm_cb.ble_ctr_cb.scan_activity))
 352     {
 353         status = BTM_CMD_STARTED;
 354         btm_ble_stop_observe();
 355     }
 356     else
 357     {
 358         BTM_TRACE_ERROR("Observe not active");
 359     }
 360
 361     return status;
 362
 363 }
 364
 365 /*******************************************************************************
 366 **
 367 ** Function         BTM_BleBroadcast
 368 **
 369 ** Description      This function is to start or stop broadcasting.
 370 **
 371 ** Parameters       start: start or stop broadcasting.
 372 **
 373 ** Returns          status.
 374 **
 375 *******************************************************************************/
 376 tBTM_STATUS BTM_BleBroadcast(BOOLEAN start)
 377 {
 378     tBTM_STATUS status = BTM_NO_RESOURCES;
 379     tBTM_LE_RANDOM_CB *p_addr_cb = &btm_cb.ble_ctr_cb.addr_mgnt_cb;
 380     tBTM_BLE_INQ_CB *p_cb = &btm_cb.ble_ctr_cb.inq_var;
 381     UINT8 evt_type = p_cb->scan_rsp ? BTM_BLE_DISCOVER_EVT: BTM_BLE_NON_CONNECT_EVT;
 382
 383     if (!HCI_LE_HOST_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_1]))
 384         return BTM_ILLEGAL_VALUE;
 385
 386 #ifdef  BTM_BLE_PC_ADV_TEST_MODE
 387     if (BTM_BLE_PC_ADV_TEST_MODE)
 388     {
 389         evt_type = p_cb->scan_rsp ? BTM_BLE_CONNECT_EVT: BTM_BLE_NON_CONNECT_EVT;
 390     }
 391 #endif
 392
 393     if (start && p_cb->adv_mode == BTM_BLE_ADV_DISABLE)
 394     {
 395         /* update adv params */
 396         if (!btsnd_hcic_ble_write_adv_params ((UINT16)(p_cb->adv_interval_min ? p_cb->adv_interval_min :
 397                                               BTM_BLE_GAP_ADV_INT),
 398                                               (UINT16)(p_cb->adv_interval_max ? p_cb->adv_interval_max :
 399                                               BTM_BLE_GAP_ADV_INT),
 400                                               evt_type,
 401                                               p_addr_cb->own_addr_type,
 402                                               p_cb->direct_bda.type,
 403                                               p_cb->direct_bda.bda,
 404                                               p_cb->adv_chnl_map,
 405                                               p_cb->afp))
 406
 407             status = BTM_NO_RESOURCES;
 408         else
 409             p_cb->evt_type = evt_type;
 410
 411         status = btm_ble_start_adv ();
 412     }
 413     else if (!start)
 414     {
 415         status = btm_ble_stop_adv();
 416     }
 417     else
 418     {
 419         status = BTM_WRONG_MODE;
 420         BTM_TRACE_ERROR("Can not %s Broadcast, device %s in Broadcast mode",
 421             (start ? "Start" : "Stop"), (start ? "already" :"not"));
 422     }
 423     return status;
 424 }
 425
 426 #if BLE_VND_INCLUDED == TRUE
 427 /*******************************************************************************
 428 **
 429 ** Function         btm_vsc_brcm_features_complete
 430 **
 431 ** Description      Command Complete callback for HCI_BLE_VENDOR_CAP_OCF
 432 **
 433 ** Returns          void
 434 **
 435 *******************************************************************************/
 436 static void btm_ble_vendor_capability_vsc_cmpl_cback (tBTM_VSC_CMPL *p_vcs_cplt_params)
 437 {
 438     UINT8  status = 0xFF, *p;
 439
 440     BTM_TRACE_DEBUG("btm_ble_vendor_capability_vsc_cmpl_cback");
 441
 442     /* Check status of command complete event */
 443     if ((p_vcs_cplt_params->opcode == HCI_BLE_VENDOR_CAP_OCF) &&(p_vcs_cplt_params->param_len > 0))
 444     {
 445         p = p_vcs_cplt_params->p_param_buf;
 446         STREAM_TO_UINT8  (status, p);
 447     }
 448
 449     if (status == HCI_SUCCESS)
 450     {
 451         STREAM_TO_UINT8  (btm_cb.cmn_ble_vsc_cb.adv_inst_max, p);
 452         STREAM_TO_UINT8  (btm_cb.cmn_ble_vsc_cb.rpa_offloading, p);
 453         STREAM_TO_UINT16 (btm_cb.cmn_ble_vsc_cb.tot_scan_results_strg, p);
 454         STREAM_TO_UINT8  (btm_cb.cmn_ble_vsc_cb.max_irk_list_sz, p);
 455         STREAM_TO_UINT8  (btm_cb.cmn_ble_vsc_cb.filter_support, p);
 456         STREAM_TO_UINT8  (btm_cb.cmn_ble_vsc_cb.max_filter, p);
 457         STREAM_TO_UINT8  (btm_cb.cmn_ble_vsc_cb.energy_support, p);
 458         btm_cb.cmn_ble_vsc_cb.values_read = TRUE;
 459     }
 460
 461     BTM_TRACE_DEBUG("btm_ble_vnd_cap_vsc_cmpl_cback: stat=%d, irk=%d, ADV ins:%d, rpa=%d, ener=%d",
 462          status, btm_ble_vendor_cb.irk_avail_size, btm_cb.cmn_ble_vsc_cb.adv_inst_max,
 463          btm_cb.cmn_ble_vsc_cb.rpa_offloading, btm_cb.cmn_ble_vsc_cb.energy_support);
 464
 465     if (BTM_BleMaxMultiAdvInstanceCount() > 0)
 466         btm_ble_multi_adv_init();
 467
 468     if (btm_cb.cmn_ble_vsc_cb.max_filter > 0)
 469     {
 470         btm_ble_adv_filter_init();
 471     }
 472
 473     if (btm_cb.cmn_ble_vsc_cb.max_irk_list_sz > 0)
 474     {
 475         btm_ble_vendor_init(btm_cb.cmn_ble_vsc_cb.max_irk_list_sz);
 476     }
 477
 478     if (btm_cb.cmn_ble_vsc_cb.tot_scan_results_strg > 0)
 479         btm_ble_batchscan_init();
 480
 481     if (p_ctrl_le_feature_rd_cmpl_cback != NULL)
 482         p_ctrl_le_feature_rd_cmpl_cback(status);
 483 }
 484 #endif
 485
 486 /*******************************************************************************
 487 **
 488 ** Function         BTM_BleGetVendorCapabilities
 489 **
 490 ** Description      This function reads local LE features
 491 **
 492 ** Parameters       p_cmn_vsc_cb : Locala LE capability structure
 493 **
 494 ** Returns          void
 495 **
 496 *******************************************************************************/
 497 BTM_API extern void BTM_BleGetVendorCapabilities(tBTM_BLE_VSC_CB *p_cmn_vsc_cb)
 498 {
 499     BTM_TRACE_DEBUG("BTM_BleGetVendorCapabilities");
 500
 501     if (NULL != p_cmn_vsc_cb)
 502     {
 503         *p_cmn_vsc_cb = btm_cb.cmn_ble_vsc_cb;
 504     }
 505 }
 506
 507 /******************************************************************************
 508 **
 509 ** Function         BTM_BleReadControllerFeatures
 510 **
 511 ** Description      Reads BLE specific controller features
 512 **
 513 ** Parameters:      tBTM_BLE_CTRL_FEATURES_CBACK : Callback to notify when features are read
 514 **
 515 ** Returns          void
 516 **
 517 *******************************************************************************/
 518 BTM_API extern void BTM_BleReadControllerFeatures(tBTM_BLE_CTRL_FEATURES_CBACK  *p_vsc_cback)
 519 {
 520     if (TRUE == btm_cb.cmn_ble_vsc_cb.values_read)
 521         return;
 522
 523 #if BLE_VND_INCLUDED == TRUE
 524     BTM_TRACE_DEBUG("BTM_BleReadControllerFeatures");
 525
 526     p_ctrl_le_feature_rd_cmpl_cback = p_vsc_cback;
 527     if ( BTM_VendorSpecificCommand (HCI_BLE_VENDOR_CAP_OCF,
 528                                     0,
 529                                     NULL,
 530                                     btm_ble_vendor_capability_vsc_cmpl_cback)
 531                                     != BTM_CMD_STARTED)
 532     {
 533         BTM_TRACE_ERROR("LE Get_Vendor Capabilities Command Failed.");
 534     }
 535 #else
 536     UNUSED(p_vsc_cback);
 537 #endif
 538     return ;
 539 }
 540
 541 /*******************************************************************************
 542 **
 543 ** Function         BTM_RegisterScanReqEvt
 544 **
 545 ** Description      This function is called to register a scan request callback
 546 **                  on the advertiser.
 547 **
 548 ** Parameters       p_scan_req_cback: scan request callback.  If NULL, remove the
 549 **                                    registration.
 550 **
 551 ** Returns          void
 552 **
 553 *******************************************************************************/
 554 void BTM_RegisterScanReqEvt(tBTM_BLE_SCAN_REQ_CBACK   *p_scan_req_cback)
 555 {
 556 #ifdef BTM_BLE_PC_ADV_TEST_MODE /* For general stack code (e.g. BTInsight testing), we simply do not define it to exclude or set it to TRUE to include */
 557     if (BTM_BLE_PC_ADV_TEST_MODE)   /* For stack component, it is always defined and maps to a global variable g_bDraculaAdvertisingMode */
 558     {
 559         tBTM_BLE_CB *p_cb = &btm_cb.ble_ctr_cb;
 560         p_cb->p_scan_req_cback = p_scan_req_cback;
 561     }
 562 #else
 563     UNUSED(p_scan_req_cback);
 564 #endif
 565 }
 566
 567 /*******************************************************************************
 568 **
 569 ** Function         BTM_BleConfigPrivacy
 570 **
 571 ** Description      This function is called to enable or disable the privacy in
 572 **                   LE channel of the local device.
 573 **
 574 ** Parameters       enable: TRUE to enable it; FALSE to disable it.
 575 **
 576 ** Returns          void
 577 **
 578 *******************************************************************************/
 579 void BTM_BleConfigPrivacy(BOOLEAN enable)
 580 {
 581     tBTM_BLE_CB     *p_cb = &btm_cb.ble_ctr_cb;
 582
 583     BTM_TRACE_EVENT (" BTM_BleConfigPrivacy");
 584
 585     if (p_cb->privacy != enable)
 586     {
 587         p_cb->privacy = enable;
 588
 589         if (p_cb->privacy)
 590         {
 591             /* generate resolvable private address */
 592             btm_gen_resolvable_private_addr((void*)btm_gen_resolve_paddr_low);
 593         }
 594         else /* if privacy disabled, always use public address */
 595         {
 596             p_cb->addr_mgnt_cb.own_addr_type = BLE_ADDR_PUBLIC;
 597         }
 598
 599         if (BTM_BleMaxMultiAdvInstanceCount() > 0)
 600             btm_ble_multi_adv_enb_privacy(p_cb->privacy);
 601     }
 602 }
 603
 604 /*******************************************************************************
 605 **
 606 ** Function          BTM_BleMaxMultiAdvInstanceCount
 607 **
 608 ** Description        Returns max number of multi adv instances supported by controller
 609 **
 610 ** Returns          Max multi adv instance count
 611 **
 612 *******************************************************************************/
 613 BTM_API extern UINT8  BTM_BleMaxMultiAdvInstanceCount()
 614 {
 615     return btm_cb.cmn_ble_vsc_cb.adv_inst_max < BTM_BLE_MULTI_ADV_MAX ?
 616         btm_cb.cmn_ble_vsc_cb.adv_inst_max : BTM_BLE_MULTI_ADV_MAX;
 617 }
 618
 619 #if BLE_PRIVACY_SPT == TRUE
 620 /*******************************************************************************
 621 **
 622 ** Function         btm_ble_resolve_random_addr_on_adv
 623 **
 624 ** Description      resolve random address complete callback.
 625 **
 626 ** Returns          void
 627 **
 628 *******************************************************************************/
 629 static void btm_ble_resolve_random_addr_on_adv(void * p_rec, void *p)
 630 {
 631     tBTM_SEC_DEV_REC    *match_rec = (tBTM_SEC_DEV_REC *) p_rec;
 632     UINT8       addr_type = BLE_ADDR_RANDOM;
 633     BD_ADDR     bda;
 634     UINT8       *pp = (UINT8 *)p + 1;
 635     UINT8           evt_type;
 636
 637     BTM_TRACE_EVENT ("btm_ble_resolve_random_addr_on_adv ");
 638
 639     STREAM_TO_UINT8    (evt_type, pp);
 640     STREAM_TO_UINT8    (addr_type, pp);
 641     STREAM_TO_BDADDR   (bda, pp);
 642
 643     if (match_rec)
 644     {
 645         BTM_TRACE_DEBUG("Random match");
 646         match_rec->ble.active_addr_type = BTM_BLE_ADDR_RRA;
 647         memcpy(match_rec->ble.cur_rand_addr, bda, BD_ADDR_LEN);
 648         memcpy(bda, match_rec->bd_addr, BD_ADDR_LEN);
 649         addr_type = match_rec->ble.ble_addr_type;
 650     }
 651
 652     btm_ble_process_adv_pkt_cont(bda, addr_type, evt_type, pp);
 653
 654     return;
 655 }
 656 #endif
 657
 658 /*******************************************************************************
 659 **
 660 ** Function         BTM_BleLocalPrivacyEnabled
 661 **
 662 ** Description        Checks if local device supports private address
 663 **
 664 ** Returns          Return TRUE if local privacy is enabled else FALSE
 665 **
 666 *******************************************************************************/
 667 BOOLEAN BTM_BleLocalPrivacyEnabled()
 668 {
 669 #if BLE_PRIVACY_SPT == TRUE
 670     return btm_cb.ble_ctr_cb.privacy;
 671 #else
 672     return false;
 673 #endif
 674 }
 675
 676 /*******************************************************************************
 677 **
 678 ** Function         BTM_BleSetBgConnType
 679 **
 680 ** Description      This function is called to set BLE connectable mode for a
 681 **                  peripheral device.
 682 **
 683 ** Parameters       bg_conn_type: it can be auto connection, or selective connection.
 684 **                  p_select_cback: callback function when selective connection procedure
 685 **                              is being used.
 686 **
 687 ** Returns          void
 688 **
 689 *******************************************************************************/
 690 BOOLEAN BTM_BleSetBgConnType(tBTM_BLE_CONN_TYPE   bg_conn_type,
 691                              tBTM_BLE_SEL_CBACK   *p_select_cback)
 692 {
 693     BOOLEAN started = TRUE;
 694
 695     BTM_TRACE_EVENT ("BTM_BleSetBgConnType ");
 696     if (!HCI_LE_HOST_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_1]))
 697         return FALSE;
 698
 699     if (btm_cb.ble_ctr_cb.bg_conn_type != bg_conn_type)
 700     {
 701         switch (bg_conn_type)
 702         {
 703             case BTM_BLE_CONN_AUTO:
 704                 btm_ble_start_auto_conn(TRUE);
 705                 break;
 706
 707             case BTM_BLE_CONN_SELECTIVE:
 708                 if (btm_cb.ble_ctr_cb.bg_conn_type == BTM_BLE_CONN_AUTO)
 709                 {
 710                     btm_ble_start_auto_conn(FALSE);
 711                 }
 712                 started = btm_ble_start_select_conn(TRUE, p_select_cback);
 713                 break;
 714
 715             case BTM_BLE_CONN_NONE:
 716                 if (btm_cb.ble_ctr_cb.bg_conn_type == BTM_BLE_CONN_AUTO)
 717                 {
 718                     btm_ble_start_auto_conn(FALSE);
 719                 }
 720                 else if (btm_cb.ble_ctr_cb.bg_conn_type == BTM_BLE_CONN_SELECTIVE)
 721                 {
 722                     btm_ble_start_select_conn(FALSE, NULL);
 723                 }
 724                 started = TRUE;
 725                 break;
 726
 727             default:
 728                 BTM_TRACE_ERROR("invalid bg connection type : %d ", bg_conn_type);
 729                 started = FALSE;
 730                 break;
 731         }
 732
 733         if (started)
 734             btm_cb.ble_ctr_cb.bg_conn_type = bg_conn_type;
 735     }
 736     return started;
 737 }
 738
 739 /*******************************************************************************
 740 **
 741 ** Function         BTM_BleClearBgConnDev
 742 **
 743 ** Description      This function is called to clear the whitelist,
 744 **                  end any pending whitelist connections,
 745 *                   and reset the local bg device list.
 746 **
 747 ** Parameters       void
 748 **
 749 ** Returns          void
 750 **
 751 *******************************************************************************/
 752 void BTM_BleClearBgConnDev(void)
 753 {
 754     btm_ble_start_auto_conn(FALSE);
 755     btm_ble_clear_white_list();
 756     gatt_reset_bgdev_list();
 757 }
 758
 759 /*******************************************************************************
 760 **
 761 ** Function         BTM_BleUpdateBgConnDev
 762 **
 763 ** Description      This function is called to add or remove a device into/from
 764 **                  background connection procedure. The background connection
 765 *                   procedure is decided by the background connection type, it can be
 766 *                   auto connection, or selective connection.
 767 **
 768 ** Parameters       add_remove: TRUE to add; FALSE to remove.
 769 **                  remote_bda: device address to add/remove.
 770 **
 771 ** Returns          void
 772 **
 773 *******************************************************************************/
 774 BOOLEAN BTM_BleUpdateBgConnDev(BOOLEAN add_remove, BD_ADDR   remote_bda)
 775 {
 776     BOOLEAN ret = TRUE;
 777     BTM_TRACE_EVENT (" BTM_BleUpdateBgConnDev");
 778
 779     /* update white list */
 780     ret = btm_update_bg_conn_list(add_remove, remote_bda);
 781
 782     btm_update_dev_to_white_list(add_remove, remote_bda);
 783
 784     return ret;
 785 }
 786
 787 /*******************************************************************************
 788 **
 789 ** Function         BTM_BleSetConnMode
 790 **
 791 ** Description      This function is called to set BLE connectable mode for a
 792 **                  peripheral device.
 793 **
 794 ** Parameters       directed: is directed connectable mode, or non-directed.
 795 **                  p_dir_bda: connectable direct initiator's LE device address
 796 **
 797 ** Returns          void
 798 **
 799 *******************************************************************************/
 800 tBTM_STATUS BTM_BleSetConnMode(BOOLEAN is_directed)
 801 {
 802     tBTM_BLE_INQ_CB *p_cb = &btm_cb.ble_ctr_cb.inq_var;
 803
 804     BTM_TRACE_EVENT ("BTM_BleSetConnMode is_directed = %d ", is_directed);
 805     if (!HCI_LE_HOST_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_1]))
 806         return BTM_ILLEGAL_VALUE;
 807
 808     p_cb->directed_conn = is_directed;
 809     return btm_ble_set_connectability( p_cb->connectable_mode);
 810
 811 }
 812
 813 /*******************************************************************************
 814 **
 815 ** Function         btm_set_conn_mode_adv_init_addr
 816 **
 817 ** Description      set initator address type and local address type based on adv
 818 **                  mode.
 819 **
 820 **
 821 *******************************************************************************/
 822 static UINT8 btm_set_conn_mode_adv_init_addr(tBTM_BLE_INQ_CB *p_cb,
 823                                      BD_ADDR_PTR p_addr_ptr,
 824                                      tBLE_ADDR_TYPE *p_init_addr_type,
 825                                      tBLE_ADDR_TYPE *p_own_addr_type)
 826 {
 827     UINT8 evt_type;
 828
 829     UNUSED(p_own_addr_type);
 830
 831     if ( p_cb->directed_conn)
 832     {
 833         /*  direct adv mode does not have privacy if privacy
 834         is not enabled or no reconn addr config */
 835
 836         *p_init_addr_type  = p_cb->direct_bda.type;
 837          memcpy(p_addr_ptr, p_cb->direct_bda.bda, BD_ADDR_LEN);
 838         evt_type = BTM_BLE_CONNECT_DIR_EVT;
 839     }
 840     else /* undirect adv mode */
 841     {
 842         evt_type = BTM_BLE_CONNECT_EVT;
 843
 844         /* may need to reset random address if privacy is enabled */
 845         if (btm_cb.ble_ctr_cb.privacy && /* own addr_type is random */
 846             !BTM_BLE_IS_RESOLVE_BDA(btm_cb.ble_ctr_cb.addr_mgnt_cb.private_addr))
 847         {
 848             /* need to generate RRA and update random addresss in controller */
 849             btm_gen_resolvable_private_addr((void *)btm_gen_resolve_paddr_low);
 850         }
 851     }
 852
 853     return evt_type;
 854
 855 }
 856
 857 /*******************************************************************************
 858 **
 859 ** Function         BTM_BleSetAdvParams
 860 **
 861 ** Description      This function is called to set advertising parameters.
 862 **
 863 ** Parameters       adv_int_min: minimum advertising interval
 864 **                  adv_int_max: maximum advertising interval
 865 **                  p_dir_bda: connectable direct initiator's LE device address
 866 **                  chnl_map: advertising channel map.
 867 **
 868 ** Returns          void
 869 **
 870 *******************************************************************************/
 871 tBTM_STATUS BTM_BleSetAdvParams(UINT16 adv_int_min, UINT16 adv_int_max,
 872                                 tBLE_BD_ADDR *p_dir_bda,
 873                                 tBTM_BLE_ADV_CHNL_MAP chnl_map)
 874 {
 875     tBTM_LE_RANDOM_CB *p_addr_cb = &btm_cb.ble_ctr_cb.addr_mgnt_cb;
 876     tBTM_BLE_INQ_CB *p_cb = &btm_cb.ble_ctr_cb.inq_var;
 877     tBTM_STATUS status = BTM_SUCCESS;
 878     BD_ADDR     p_addr_ptr =  {0};
 879     tBLE_ADDR_TYPE   init_addr_type = BLE_ADDR_PUBLIC;
 880     tBLE_ADDR_TYPE   own_addr_type = p_addr_cb->own_addr_type;
 881     UINT8            adv_mode = p_cb->adv_mode;
 882
 883     BTM_TRACE_EVENT ("BTM_BleSetAdvParams");
 884
 885     if (!HCI_LE_HOST_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_1]))
 886         return BTM_ILLEGAL_VALUE;
 887
 888     if (!BTM_BLE_VALID_PRAM(adv_int_min, BTM_BLE_ADV_INT_MIN, BTM_BLE_ADV_INT_MAX) ||
 889         !BTM_BLE_VALID_PRAM(adv_int_max, BTM_BLE_ADV_INT_MIN, BTM_BLE_ADV_INT_MAX))
 890     {
 891         return BTM_ILLEGAL_VALUE;
 892     }
 893
 894     p_cb->adv_interval_min = adv_int_min;
 895     p_cb->adv_interval_max = adv_int_max;
 896     p_cb->adv_chnl_map = chnl_map;
 897
 898     if (p_dir_bda)
 899     {
 900         memcpy(&p_cb->direct_bda, p_dir_bda, sizeof(tBLE_BD_ADDR));
 901     }
 902
 903     BTM_TRACE_EVENT ("update params for an active adv");
 904
 905     btm_ble_stop_adv();
 906
 907     if (p_cb->connectable_mode & BTM_BLE_CONNECTABLE)
 908         p_cb->evt_type = btm_set_conn_mode_adv_init_addr(p_cb, p_addr_ptr, &init_addr_type, &own_addr_type);
 909
 910     /* update adv params */
 911     btsnd_hcic_ble_write_adv_params (p_cb->adv_interval_min,
 912                                      p_cb->adv_interval_max,
 913                                      p_cb->evt_type,
 914                                      own_addr_type,
 915                                      init_addr_type,
 916                                      p_addr_ptr,
 917                                      p_cb->adv_chnl_map,
 918                                      p_cb->afp);
 919
 920     if (adv_mode == BTM_BLE_ADV_ENABLE)
 921         btm_ble_start_adv();
 922
 923     return status;
 924 }
 925
 926 /*******************************************************************************
 927 **
 928 ** Function         BTM_BleReadAdvParams
 929 **
 930 ** Description      This function is called to set advertising parameters.
 931 **
 932 ** Parameters       adv_int_min: minimum advertising interval
 933 **                  adv_int_max: maximum advertising interval
 934 **                  p_dir_bda: connectable direct initiator's LE device address
 935 **                  chnl_map: advertising channel map.
 936 **
 937 ** Returns          void
 938 **
 939 *******************************************************************************/
 940 void BTM_BleReadAdvParams (UINT16 *adv_int_min, UINT16 *adv_int_max,
 941                            tBLE_BD_ADDR *p_dir_bda, tBTM_BLE_ADV_CHNL_MAP *p_chnl_map)
 942 {
 943     tBTM_BLE_INQ_CB *p_cb = &btm_cb.ble_ctr_cb.inq_var;
 944
 945     BTM_TRACE_EVENT ("BTM_BleReadAdvParams ");
 946     if (!HCI_LE_HOST_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_1]))
 947         return ;
 948
 949     *adv_int_min = p_cb->adv_interval_min;
 950     *adv_int_max = p_cb->adv_interval_max;
 951     *p_chnl_map = p_cb->adv_chnl_map;
 952
 953     if (p_dir_bda != NULL)
 954     {
 955         memcpy(p_dir_bda, &p_cb->direct_bda, sizeof(tBLE_BD_ADDR));
 956     }
 957 }
 958
 959 /*******************************************************************************
 960 **
 961 ** Function         BTM_BleSetScanParams
 962 **
 963 ** Description      This function is called to set Scan parameters.
 964 **
 965 ** Parameters       adv_int_min: minimum advertising interval
 966 **                  adv_int_max: maximum advertising interval
 967 **                  p_dir_bda: connectable direct initiator's LE device address
 968 **                  chnl_map: advertising channel map.
 969 **                  scan_type: active scan or passive scan
 970 **
 971 ** Returns          void
 972 **
 973 *******************************************************************************/
 974 void BTM_BleSetScanParams(UINT16 scan_interval, UINT16 scan_window, tBTM_BLE_SCAN_MODE scan_mode)
 975 {
 976     tBTM_BLE_INQ_CB *p_cb = &btm_cb.ble_ctr_cb.inq_var;
 977
 978     BTM_TRACE_EVENT (" BTM_BleSetScanParams");
 979     if (!HCI_LE_HOST_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_1]))
 980         return ;
 981
 982     if (BTM_BLE_VALID_PRAM(scan_interval, BTM_BLE_SCAN_INT_MIN, BTM_BLE_SCAN_INT_MAX) &&
 983         BTM_BLE_VALID_PRAM(scan_window, BTM_BLE_SCAN_WIN_MIN, BTM_BLE_SCAN_WIN_MAX) &&
 984         (scan_mode == BTM_BLE_SCAN_MODE_ACTI || scan_mode == BTM_BLE_SCAN_MODE_PASS))
 985     {
 986         p_cb->scan_type     = scan_mode;
 987
 988         if (BTM_BLE_CONN_PARAM_UNDEF != scan_interval)
 989             p_cb->scan_interval = scan_interval;
 990
 991         if (BTM_BLE_CONN_PARAM_UNDEF != scan_window)
 992             p_cb->scan_window   = scan_window;
 993     }
 994     else
 995     {
 996         BTM_TRACE_ERROR("Illegal params: scan_interval = %d scan_window = %d",
 997                         scan_interval, scan_window);
 998     }
 999
1000 }
1001
1002 /*******************************************************************************
1003 **
1004 ** Function         BTM_BleWriteScanRsp
1005 **
1006 ** Description      This function is called to write LE scan response.
1007 **
1008 ** Parameters:      p_scan_rsp: scan response information.
1009 **
1010 ** Returns          void
1011 **
1012 *******************************************************************************/
1013 tBTM_STATUS BTM_BleWriteScanRsp(tBTM_BLE_AD_MASK data_mask, tBTM_BLE_ADV_DATA *p_data)
1014 {
1015     tBTM_STATUS     status = BTM_NO_RESOURCES;
1016     UINT8   rsp_data[BTM_BLE_AD_DATA_LEN],
1017             *p = rsp_data;
1018
1019     BTM_TRACE_EVENT (" BTM_BleWriteScanRsp");
1020
1021     if (!HCI_LE_HOST_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_1]))
1022         return BTM_ILLEGAL_VALUE;
1023
1024     memset(rsp_data, 0, BTM_BLE_AD_DATA_LEN);
1025     btm_ble_build_adv_data(&data_mask, &p, p_data);
1026
1027     if (btsnd_hcic_ble_set_scan_rsp_data((UINT8)(p - rsp_data), rsp_data))
1028     {
1029         status = BTM_SUCCESS;
1030
1031         if (data_mask != 0)
1032             btm_cb.ble_ctr_cb.inq_var.scan_rsp = TRUE;
1033         else
1034             btm_cb.ble_ctr_cb.inq_var.scan_rsp = FALSE;
1035     }
1036     else
1037         status = BTM_ILLEGAL_VALUE;
1038
1039     return status;
1040 }
1041
1042 /*******************************************************************************
1043 **
1044 ** Function         BTM_BleWriteAdvData
1045 **
1046 ** Description      This function is called to write advertising data.
1047 **
1048 ** Parameters:       None.
1049 **
1050 ** Returns          void
1051 **
1052 *******************************************************************************/
1053 tBTM_STATUS BTM_BleWriteAdvData(tBTM_BLE_AD_MASK data_mask, tBTM_BLE_ADV_DATA *p_data)
1054 {
1055     tBTM_BLE_LOCAL_ADV_DATA *p_cb_data = &btm_cb.ble_ctr_cb.inq_var.adv_data;
1056     UINT8  *p;
1057     tBTM_BLE_AD_MASK   mask = data_mask;
1058
1059     BTM_TRACE_EVENT ("BTM_BleWriteAdvData ");
1060
1061     if (!HCI_LE_HOST_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_1]))
1062         return BTM_ILLEGAL_VALUE;
1063
1064     memset(p_cb_data, 0, sizeof(tBTM_BLE_LOCAL_ADV_DATA));
1065     p = p_cb_data->ad_data;
1066     p_cb_data->data_mask = data_mask;
1067
1068     p_cb_data->p_flags = btm_ble_build_adv_data(&mask, &p, p_data);
1069
1070     p_cb_data->p_pad = p;
1071
1072     if (mask != 0)
1073     {
1074         BTM_TRACE_ERROR("Partial data write into ADV");
1075     }
1076
1077     p_cb_data->data_mask &= ~mask;
1078
1079     if (btsnd_hcic_ble_set_adv_data((UINT8)(p_cb_data->p_pad - p_cb_data->ad_data),
1080                                     p_cb_data->ad_data))
1081         return BTM_SUCCESS;
1082     else
1083         return BTM_NO_RESOURCES;
1084
1085 }
1086
1087 /*******************************************************************************
1088 **
1089 ** Function         BTM_CheckAdvData
1090 **
1091 ** Description      This function is called to get ADV data for a specific type.
1092 **
1093 ** Parameters       p_adv - pointer of ADV data
1094 **                  type   - finding ADV data type
1095 **                  p_length - return the length of ADV data not including type
1096 **
1097 ** Returns          pointer of ADV data
1098 **
1099 *******************************************************************************/
1100 UINT8 *BTM_CheckAdvData( UINT8 *p_adv, UINT8 type, UINT8 *p_length)
1101 {
1102     UINT8 *p = p_adv;
1103     UINT8 length;
1104     UINT8 adv_type;
1105     BTM_TRACE_API("BTM_CheckAdvData type=0x%02X", type);
1106
1107     STREAM_TO_UINT8(length, p);
1108
1109     while ( length && (p - p_adv <= BTM_BLE_CACHE_ADV_DATA_MAX))
1110     {
1111         STREAM_TO_UINT8(adv_type, p);
1112
1113         if ( adv_type == type )
1114         {
1115             /* length doesn't include itself */
1116             *p_length = length - 1; /* minus the length of type */
1117             return p;
1118         }
1119         p += length - 1; /* skip the length of data */
1120         STREAM_TO_UINT8(length, p);
1121     }
1122
1123     *p_length = 0;
1124     return NULL;
1125 }
1126
1127 /*******************************************************************************
1128 **
1129 ** Function         btm_ble_build_adv_data
1130 **
1131 ** Description      This function is called build the adv data and rsp data.
1132 *******************************************************************************/
1133 UINT8 *btm_ble_build_adv_data(tBTM_BLE_AD_MASK *p_data_mask, UINT8 **p_dst,
1134                               tBTM_BLE_ADV_DATA *p_data)
1135 {
1136     UINT32 data_mask = *p_data_mask;
1137     UINT8   *p = *p_dst,
1138     *p_flag = NULL;
1139     UINT16  len = BTM_BLE_AD_DATA_LEN, cp_len = 0;
1140     UINT8   i = 0;
1141     tBTM_BLE_PROP_ELEM      *p_elem;
1142
1143     BTM_TRACE_EVENT (" btm_ble_build_adv_data");
1144
1145     /* build the adv data structure and build the data string */
1146     if (data_mask)
1147     {
1148         /* flags */
1149         if (data_mask & BTM_BLE_AD_BIT_FLAGS)
1150         {
1151             *p++ = MIN_ADV_LENGTH;
1152             *p++ = BTM_BLE_AD_TYPE_FLAG;
1153             p_flag = p;
1154             if (p_data)
1155                 *p++ = p_data->flag;
1156             else
1157                 *p++ = 0;
1158
1159             len -= 3;
1160
1161             data_mask &= ~BTM_BLE_AD_BIT_FLAGS;
1162         }
1163         /* appearance data */
1164         if (len > 3 && data_mask & BTM_BLE_AD_BIT_APPEARANCE)
1165         {
1166             *p++ = 3; /* length */
1167             *p++ = BTM_BLE_AD_TYPE_APPEARANCE;
1168             UINT16_TO_STREAM(p, p_data->appearance);
1169             len -= 4;
1170
1171             data_mask &= ~BTM_BLE_AD_BIT_APPEARANCE;
1172         }
1173         /* device name */
1174 #if BTM_MAX_LOC_BD_NAME_LEN > 0
1175         if (len > MIN_ADV_LENGTH && data_mask & BTM_BLE_AD_BIT_DEV_NAME)
1176         {
1177             if (strlen(btm_cb.cfg.bd_name) > (UINT16)(len - MIN_ADV_LENGTH))
1178             {
1179                 *p++ = len - MIN_ADV_LENGTH + 1;
1180                 *p++ = BTM_BLE_AD_TYPE_NAME_SHORT;
1181                 ARRAY_TO_STREAM(p, btm_cb.cfg.bd_name, len - MIN_ADV_LENGTH);
1182             }
1183             else
1184             {
1185                 cp_len = (UINT16)strlen(btm_cb.cfg.bd_name);
1186                 *p++ = cp_len + 1;
1187                 *p++ = BTM_BLE_AD_TYPE_NAME_CMPL;
1188                 ARRAY_TO_STREAM(p, btm_cb.cfg.bd_name, cp_len);
1189             }
1190             len -= (cp_len + MIN_ADV_LENGTH);
1191             data_mask &= ~BTM_BLE_AD_BIT_DEV_NAME;
1192         }
1193 #endif
1194         /* manufacturer data */
1195         if (len > MIN_ADV_LENGTH && data_mask & BTM_BLE_AD_BIT_MANU &&
1196             p_data && p_data->p_manu &&
1197             p_data->p_manu->len != 0 && p_data->p_manu->p_val)
1198         {
1199             if (p_data->p_manu->len > (len - MIN_ADV_LENGTH))
1200                 cp_len = len - MIN_ADV_LENGTH;
1201             else
1202                 cp_len = p_data->p_manu->len;
1203
1204             *p++ = cp_len + 1;
1205             *p++ = BTM_BLE_AD_TYPE_MANU;
1206             ARRAY_TO_STREAM(p, p_data->p_manu->p_val, cp_len);
1207
1208             len -= (cp_len + MIN_ADV_LENGTH);
1209             data_mask &= ~BTM_BLE_AD_BIT_MANU;
1210         }
1211         /* TX power */
1212         if (len > MIN_ADV_LENGTH && data_mask & BTM_BLE_AD_BIT_TX_PWR)
1213         {
1214             *p++ = MIN_ADV_LENGTH;
1215             *p++ = BTM_BLE_AD_TYPE_TX_PWR;
1216             if (p_data->tx_power > BTM_BLE_ADV_TX_POWER_MAX)
1217                 p_data->tx_power = BTM_BLE_ADV_TX_POWER_MAX;
1218             *p++ = btm_ble_map_adv_tx_power(p_data->tx_power);
1219             len -= 3;
1220             data_mask &= ~BTM_BLE_AD_BIT_TX_PWR;
1221         }
1222         /* 16 bits services */
1223         if (len > MIN_ADV_LENGTH && data_mask & BTM_BLE_AD_BIT_SERVICE &&
1224             p_data && p_data->p_services &&
1225             p_data->p_services->num_service != 0 &&
1226             p_data->p_services->p_uuid)
1227         {
1228             if (p_data->p_services->num_service * LEN_UUID_16 > (len - MIN_ADV_LENGTH))
1229             {
1230                 cp_len = (len - MIN_ADV_LENGTH)/LEN_UUID_16;
1231                 *p ++ = 1 + cp_len * LEN_UUID_16;
1232                 *p++ = BTM_BLE_AD_TYPE_16SRV_PART;
1233             }
1234             else
1235             {
1236                 cp_len = p_data->p_services->num_service;
1237                 *p++ = 1 + cp_len * LEN_UUID_16;
1238                 *p++ = BTM_BLE_AD_TYPE_16SRV_CMPL;
1239             }
1240             for (i = 0; i < cp_len; i ++)
1241             {
1242                 UINT16_TO_STREAM(p, *(p_data->p_services->p_uuid + i));
1243             }
1244
1245             len -= (cp_len * MIN_ADV_LENGTH + MIN_ADV_LENGTH);
1246             data_mask &= ~BTM_BLE_AD_BIT_SERVICE;
1247         }
1248         /* 32 bits service uuid */
1249         if (len > MIN_ADV_LENGTH && data_mask & BTM_BLE_AD_BIT_SERVICE_32 &&
1250             p_data && p_data->p_service_32b &&
1251             p_data->p_service_32b->num_service != 0 &&
1252             p_data->p_service_32b->p_uuid)
1253         {
1254             if ((p_data->p_service_32b->num_service * LEN_UUID_32) > (len - MIN_ADV_LENGTH))
1255             {
1256                 cp_len = (len - MIN_ADV_LENGTH)/LEN_UUID_32;
1257                 *p ++ = 1 + cp_len * LEN_UUID_32;
1258                 *p++ = BTM_BLE_AD_TYPE_32SRV_PART;
1259             }
1260             else
1261             {
1262                 cp_len = p_data->p_service_32b->num_service;
1263                 *p++ = 1 + cp_len * LEN_UUID_32;
1264                 *p++ = BTM_BLE_AD_TYPE_32SRV_CMPL;
1265             }
1266             for (i = 0; i < cp_len; i ++)
1267             {
1268                 UINT32_TO_STREAM(p, *(p_data->p_service_32b->p_uuid + i));
1269             }
1270
1271             len -= (cp_len * LEN_UUID_32 + MIN_ADV_LENGTH);
1272             data_mask &= ~BTM_BLE_AD_BIT_SERVICE_32;
1273         }
1274         /* 128 bits services */
1275         if (len >= (MAX_UUID_SIZE + 2) && data_mask & BTM_BLE_AD_BIT_SERVICE_128 &&
1276             p_data && p_data->p_services_128b)
1277         {
1278             *p ++ = 1 + MAX_UUID_SIZE;
1279             if (!p_data->p_services_128b->list_cmpl)
1280                 *p++ = BTM_BLE_AD_TYPE_128SRV_PART;
1281             else
1282                 *p++ = BTM_BLE_AD_TYPE_128SRV_CMPL;
1283
1284             ARRAY_TO_STREAM(p, p_data->p_services_128b->uuid128, MAX_UUID_SIZE);
1285
1286             len -= (MAX_UUID_SIZE + MIN_ADV_LENGTH);
1287             data_mask &= ~BTM_BLE_AD_BIT_SERVICE_128;
1288         }
1289         /* 32 bits Service Solicitation UUIDs */
1290         if (len > MIN_ADV_LENGTH && data_mask & BTM_BLE_AD_BIT_SERVICE_32SOL &&
1291             p_data && p_data->p_sol_service_32b &&
1292             p_data->p_sol_service_32b->num_service != 0 &&
1293             p_data->p_sol_service_32b->p_uuid)
1294         {
1295             if ((p_data->p_sol_service_32b->num_service * LEN_UUID_32) > (len - MIN_ADV_LENGTH))
1296             {
1297                 cp_len = (len - MIN_ADV_LENGTH)/LEN_UUID_32;
1298                 *p ++ = 1 + cp_len * LEN_UUID_32;
1299             }
1300             else
1301             {
1302                 cp_len = p_data->p_sol_service_32b->num_service;
1303                 *p++ = 1 + cp_len * LEN_UUID_32;
1304             }
1305
1306             *p++ = BTM_BLE_AD_TYPE_32SOL_SRV_UUID;
1307             for (i = 0; i < cp_len; i ++)
1308             {
1309                 UINT32_TO_STREAM(p, *(p_data->p_sol_service_32b->p_uuid + i));
1310             }
1311
1312             len -= (cp_len * LEN_UUID_32 + MIN_ADV_LENGTH);
1313             data_mask &= ~BTM_BLE_AD_BIT_SERVICE_32SOL;
1314         }
1315         /* 128 bits Solicitation services UUID */
1316         if (len >= (MAX_UUID_SIZE + MIN_ADV_LENGTH) && data_mask & BTM_BLE_AD_BIT_SERVICE_128SOL &&
1317             p_data && p_data->p_sol_service_128b)
1318         {
1319             *p ++ = 1 + MAX_UUID_SIZE;
1320             *p++ = BTM_BLE_AD_TYPE_128SOL_SRV_UUID;
1321             ARRAY_TO_STREAM(p, p_data->p_sol_service_128b->uuid128, MAX_UUID_SIZE);
1322             len -= (MAX_UUID_SIZE + MIN_ADV_LENGTH);
1323             data_mask &= ~BTM_BLE_AD_BIT_SERVICE_128SOL;
1324         }
1325         /* 16bits/32bits/128bits Service Data */
1326         if (len > MIN_ADV_LENGTH && data_mask & BTM_BLE_AD_BIT_SERVICE_DATA &&
1327             p_data && p_data->p_service_data->len != 0 && p_data->p_service_data->p_val)
1328         {
1329             if (len  > (p_data->p_service_data->service_uuid.len + MIN_ADV_LENGTH))
1330             {
1331                 if (p_data->p_service_data->len > (len - MIN_ADV_LENGTH))
1332                     cp_len = len - MIN_ADV_LENGTH- p_data->p_service_data->service_uuid.len;
1333                 else
1334                     cp_len = p_data->p_service_data->len;
1335
1336                 *p++ = cp_len + 1 + p_data->p_service_data->service_uuid.len;
1337                 if (p_data->p_service_data->service_uuid.len == LEN_UUID_16)
1338                 {
1339                     *p++ = BTM_BLE_AD_TYPE_SERVICE_DATA;
1340                     UINT16_TO_STREAM(p, p_data->p_service_data->service_uuid.uu.uuid16);
1341                 }
1342                 else if (p_data->p_service_data->service_uuid.len == LEN_UUID_32)
1343                 {
1344                     *p++ = BTM_BLE_AD_TYPE_32SERVICE_DATA;
1345                     UINT32_TO_STREAM(p, p_data->p_service_data->service_uuid.uu.uuid32);
1346                 }
1347                 else
1348                 {
1349                     *p++ = BTM_BLE_AD_TYPE_128SERVICE_DATA;
1350                     ARRAY_TO_STREAM(p, p_data->p_service_data->service_uuid.uu.uuid128,
1351                                     LEN_UUID_128);
1352                 }
1353
1354                 ARRAY_TO_STREAM(p, p_data->p_service_data->p_val, cp_len);
1355
1356                 len -= (cp_len + MIN_ADV_LENGTH + p_data->p_service_data->service_uuid.len);
1357                 data_mask &= ~BTM_BLE_AD_BIT_SERVICE_DATA;
1358             }
1359             else
1360             {
1361                 BTM_TRACE_WARNING("service data does not fit");
1362             }
1363         }
1364
1365         if (len >= 6 && data_mask & BTM_BLE_AD_BIT_INT_RANGE &&
1366             p_data)
1367         {
1368             *p++ = 5;
1369             *p++ = BTM_BLE_AD_TYPE_INT_RANGE;
1370             UINT16_TO_STREAM(p, p_data->int_range.low);
1371             UINT16_TO_STREAM(p, p_data->int_range.hi);
1372             len -= 6;
1373             data_mask &= ~BTM_BLE_AD_BIT_INT_RANGE;
1374         }
1375         if (data_mask & BTM_BLE_AD_BIT_PROPRIETARY && p_data && p_data->p_proprietary)
1376         {
1377             for (i = 0; i < p_data->p_proprietary->num_elem ; i ++)
1378             {
1379                 p_elem = p_data->p_proprietary->p_elem  + i;
1380
1381                 if (len >= (MIN_ADV_LENGTH + p_elem->len))/* len byte(1) + ATTR type(1) + Uuid len(2)
1382                                                           + value length */
1383                 {
1384                     *p ++ = p_elem->len + 1; /* Uuid len + value length */
1385                     *p ++ = p_elem->adv_type;
1386                     ARRAY_TO_STREAM(p, p_elem->p_val, p_elem->len);
1387
1388                     len -= (MIN_ADV_LENGTH + p_elem->len);
1389                 }
1390                 else
1391                 {
1392                     BTM_TRACE_WARNING("data exceed max adv packet length");
1393                     break;
1394                 }
1395             }
1396             data_mask &= ~BTM_BLE_AD_BIT_PROPRIETARY;
1397         }
1398     }
1399
1400     *p_data_mask = data_mask;
1401     *p_dst = p;
1402
1403     return p_flag;
1404 }
1405 /*******************************************************************************
1406 **
1407 ** Function         btm_ble_select_adv_interval
1408 **
1409 ** Description      select adv interval based on device mode
1410 **
1411 ** Returns          void
1412 **
1413 *******************************************************************************/
1414 void btm_ble_select_adv_interval(tBTM_BLE_INQ_CB *p_cb, UINT8 evt_type, UINT16 *p_adv_int_min, UINT16 *p_adv_int_max)
1415 {
1416     if (p_cb->adv_interval_min && p_cb->adv_interval_max)
1417     {
1418         *p_adv_int_min = p_cb->adv_interval_min;
1419         *p_adv_int_max = p_cb->adv_interval_max;
1420     }
1421     else
1422     {
1423         switch (evt_type)
1424         {
1425         case BTM_BLE_CONNECT_EVT:
1426             *p_adv_int_min = *p_adv_int_max = BTM_BLE_GAP_ADV_FAST_INT_1;
1427             break;
1428
1429         case BTM_BLE_NON_CONNECT_EVT:
1430         case BTM_BLE_DISCOVER_EVT:
1431             *p_adv_int_min = *p_adv_int_max = BTM_BLE_GAP_ADV_FAST_INT_2;
1432             break;
1433         /* connectable directed event */
1434         case BTM_BLE_CONNECT_DIR_EVT:
1435             *p_adv_int_min = BTM_BLE_GAP_ADV_DIR_MIN_INT;
1436             *p_adv_int_max = BTM_BLE_GAP_ADV_DIR_MAX_INT;
1437             break;
1438
1439         default:
1440             *p_adv_int_min = *p_adv_int_max = BTM_BLE_GAP_ADV_SLOW_INT;
1441             break;
1442         }
1443     }
1444     return;
1445 }
1446 /*******************************************************************************
1447 **
1448 ** Function         btm_ble_set_adv_flag
1449 **
1450 ** Description      Set adv flag in adv data.
1451 **
1452 ** Returns          void
1453 **
1454 *******************************************************************************/
1455 void btm_ble_set_adv_flag(UINT16 connect_mode, UINT16 disc_mode)
1456 {
1457     UINT8 flag = 0, old_flag = 0;
1458     tBTM_BLE_LOCAL_ADV_DATA *p_adv_data = &btm_cb.ble_ctr_cb.inq_var.adv_data;
1459
1460     if (p_adv_data->p_flags != NULL)
1461         flag = old_flag = *(p_adv_data->p_flags);
1462
1463     /* BR/EDR non-discoverable , non-connectable */
1464     if ((disc_mode & BTM_DISCOVERABLE_MASK) == 0 &&
1465         (connect_mode & BTM_CONNECTABLE_MASK) == 0)
1466         flag |= BTM_BLE_BREDR_NOT_SPT;
1467     else
1468         flag &= ~BTM_BLE_BREDR_NOT_SPT;
1469
1470     /* if local controller support, mark both controller and host support in flag */
1471     if (HCI_SIMUL_LE_BREDR_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_0]))
1472         flag |= (BTM_BLE_DMT_CONTROLLER_SPT|BTM_BLE_DMT_HOST_SPT);
1473     else
1474         flag &= ~(BTM_BLE_DMT_CONTROLLER_SPT|BTM_BLE_DMT_HOST_SPT);
1475
1476     BTM_TRACE_DEBUG("disc_mode %04x", disc_mode);
1477     /* update discoverable flag */
1478     if (disc_mode & BTM_BLE_LIMITED_DISCOVERABLE)
1479     {
1480         flag &= ~BTM_BLE_GEN_DISC_FLAG;
1481         flag |= BTM_BLE_LIMIT_DISC_FLAG ;
1482     }
1483     else if (disc_mode & BTM_BLE_GENERAL_DISCOVERABLE)
1484     {
1485         flag |= BTM_BLE_GEN_DISC_FLAG;
1486         flag &= ~BTM_BLE_LIMIT_DISC_FLAG;
1487     }
1488     else /* remove all discoverable flags */
1489     {
1490         flag &= ~(BTM_BLE_LIMIT_DISC_FLAG|BTM_BLE_GEN_DISC_FLAG);
1491     }
1492
1493     if (flag != old_flag)
1494     {
1495         btm_ble_update_adv_flag(flag);
1496     }
1497 }
1498 /*******************************************************************************
1499 **
1500 ** Function         btm_ble_set_discoverability
1501 **
1502 ** Description      This function is called to set BLE discoverable mode.
1503 **
1504 ** Parameters:      combined_mode: discoverability mode.
1505 **
1506 ** Returns          BTM_SUCCESS is status set successfully; otherwise failure.
1507 **
1508 *******************************************************************************/
1509 tBTM_STATUS btm_ble_set_discoverability(UINT16 combined_mode)
1510 {
1511     tBTM_LE_RANDOM_CB   *p_addr_cb = &btm_cb.ble_ctr_cb.addr_mgnt_cb;
1512     tBTM_BLE_INQ_CB     *p_cb = &btm_cb.ble_ctr_cb.inq_var;
1513     UINT16              mode = (combined_mode &  BTM_BLE_DISCOVERABLE_MASK);
1514     UINT8               new_mode = BTM_BLE_ADV_ENABLE;
1515     UINT8               evt_type = (p_cb->connectable_mode == BTM_BLE_NON_CONNECTABLE) ? \
1516                                    ((p_cb->scan_rsp) ? BTM_BLE_DISCOVER_EVT : BTM_BLE_NON_CONNECT_EVT )\
1517                                    : BTM_BLE_CONNECT_EVT;
1518     tBTM_STATUS         status = BTM_SUCCESS;
1519     BD_ADDR             p_addr_ptr= {0};
1520     tBLE_ADDR_TYPE      init_addr_type = BLE_ADDR_PUBLIC,
1521                         own_addr_type = p_addr_cb->own_addr_type;
1522     UINT16              adv_int_min, adv_int_max;
1523
1524     BTM_TRACE_EVENT ("btm_ble_set_discoverability mode=0x%0x combined_mode=0x%x", mode, combined_mode);
1525
1526     /*** Check mode parameter ***/
1527     if (mode > BTM_BLE_MAX_DISCOVERABLE)
1528         return(BTM_ILLEGAL_VALUE);
1529
1530     btm_ble_set_adv_flag (btm_cb.btm_inq_vars.connectable_mode, combined_mode);
1531
1532     evt_type = btm_set_conn_mode_adv_init_addr(p_cb, p_addr_ptr, &init_addr_type, &own_addr_type);
1533
1534     if (p_cb->connectable_mode == BTM_BLE_NON_CONNECTABLE && mode == BTM_BLE_NON_DISCOVERABLE)
1535         new_mode = BTM_BLE_ADV_DISABLE;
1536
1537     btm_ble_select_adv_interval(p_cb, evt_type, &adv_int_min, &adv_int_max);
1538
1539     btu_stop_timer(&p_cb->fast_adv_timer);
1540
1541     /* update adv params if start advertising */
1542     BTM_TRACE_EVENT ("evt_type=0x%x p-cb->evt_type=0x%x ", evt_type, p_cb->evt_type);
1543
1544     if (new_mode == BTM_BLE_ADV_ENABLE &&
1545         (evt_type != p_cb->evt_type ||p_cb->adv_addr_type != own_addr_type || !p_cb->fast_adv_on))
1546     {
1547         btm_ble_stop_adv();
1548
1549         /* update adv params */
1550         if (!btsnd_hcic_ble_write_adv_params (adv_int_min,
1551                                               adv_int_max,
1552                                               evt_type,
1553                                               own_addr_type,
1554                                               init_addr_type,
1555                                               p_addr_ptr,
1556                                               p_cb->adv_chnl_map,
1557                                               p_cb->afp))
1558
1559             status = BTM_NO_RESOURCES;
1560         else
1561         {
1562             p_cb->evt_type = evt_type;
1563             p_cb->adv_addr_type = own_addr_type;
1564         }
1565
1566     }
1567
1568     if (status == BTM_SUCCESS && p_cb->adv_mode != new_mode)
1569     {
1570         if (new_mode == BTM_BLE_ADV_ENABLE)
1571             status = btm_ble_start_adv();
1572         else
1573             status = btm_ble_stop_adv();
1574     }
1575     if (p_cb->adv_mode == BTM_BLE_ADV_ENABLE)
1576     {
1577         p_cb->fast_adv_on = TRUE;
1578         /* start initial GAP mode adv timer */
1579         btu_start_timer (&p_cb->fast_adv_timer, BTU_TTYPE_BLE_GAP_FAST_ADV,
1580                           BTM_BLE_GAP_FAST_ADV_TOUT);
1581     }
1582
1583     /* set up stop advertising timer */
1584     if (status == BTM_SUCCESS && mode == BTM_BLE_LIMITED_DISCOVERABLE)
1585     {
1586         BTM_TRACE_EVENT ("start timer for limited disc mode duration=%d (180 secs)", BTM_BLE_GAP_LIM_TOUT);
1587         /* start Tgap(lim_timeout) */
1588         btu_start_timer (&p_cb->inq_timer_ent, BTU_TTYPE_BLE_GAP_LIM_DISC,
1589                          BTM_BLE_GAP_LIM_TOUT);
1590     }
1591     return status;
1592 }
1593
1594 /*******************************************************************************
1595 **
1596 ** Function         btm_ble_set_connectability
1597 **
1598 ** Description      This function is called to set BLE connectability mode.
1599 **
1600 ** Parameters:      combined_mode: connectability mode.
1601 **
1602 ** Returns          BTM_SUCCESS is status set successfully; otherwise failure.
1603 **
1604 *******************************************************************************/
1605 tBTM_STATUS btm_ble_set_connectability(UINT16 combined_mode)
1606 {
1607     tBTM_LE_RANDOM_CB       *p_addr_cb = &btm_cb.ble_ctr_cb.addr_mgnt_cb;
1608     tBTM_BLE_INQ_CB         *p_cb = &btm_cb.ble_ctr_cb.inq_var;
1609     UINT16                  mode = (combined_mode & BTM_BLE_CONNECTABLE_MASK);
1610     UINT8                   new_mode = BTM_BLE_ADV_ENABLE;
1611     UINT8                   evt_type = (p_cb->scan_rsp) ? BTM_BLE_DISCOVER_EVT: BTM_BLE_NON_CONNECT_EVT;
1612     tBTM_STATUS             status = BTM_SUCCESS;
1613     BD_ADDR                 p_addr_ptr =  {0};
1614     tBLE_ADDR_TYPE          init_addr_type = BLE_ADDR_PUBLIC,
1615                             own_addr_type = p_addr_cb->own_addr_type;
1616     UINT16                  adv_int_min, adv_int_max;
1617
1618     BTM_TRACE_EVENT ("btm_ble_set_connectability mode=0x%0x combined_mode=0x%x", mode, combined_mode);
1619
1620     /*** Check mode parameter ***/
1621     if (mode > BTM_BLE_MAX_CONNECTABLE)
1622         return(BTM_ILLEGAL_VALUE);
1623
1624     p_cb->connectable_mode = mode;
1625
1626     btm_ble_set_adv_flag (combined_mode,  btm_cb.btm_inq_vars.discoverable_mode);
1627
1628     evt_type = btm_set_conn_mode_adv_init_addr(p_cb, p_addr_ptr, &init_addr_type, &own_addr_type);
1629
1630     if (mode == BTM_BLE_NON_CONNECTABLE && p_cb->discoverable_mode == BTM_BLE_NON_DISCOVERABLE)
1631         new_mode = BTM_BLE_ADV_DISABLE;
1632
1633     btm_ble_select_adv_interval(p_cb, evt_type, &adv_int_min, &adv_int_max);
1634
1635     btu_stop_timer(&p_cb->fast_adv_timer);
1636     /* update adv params if needed */
1637     if ((p_cb->evt_type != evt_type || p_cb->adv_addr_type != p_addr_cb->own_addr_type || !p_cb->fast_adv_on))
1638     {
1639         btm_ble_stop_adv();
1640
1641         if (!btsnd_hcic_ble_write_adv_params (adv_int_min,
1642                                               adv_int_max,
1643                                               evt_type,
1644                                               own_addr_type,
1645                                               init_addr_type,
1646                                               p_addr_ptr,
1647                                               p_cb->adv_chnl_map,
1648                                               p_cb->afp))
1649             status = BTM_NO_RESOURCES;
1650         else
1651         {
1652             p_cb->evt_type = evt_type;
1653             p_cb->adv_addr_type = own_addr_type;
1654         }
1655     }
1656
1657     /* update advertising mode */
1658     if (status == BTM_SUCCESS && new_mode != p_cb->adv_mode)
1659     {
1660         if (new_mode == BTM_BLE_ADV_ENABLE)
1661             status = btm_ble_start_adv();
1662         else
1663             status = btm_ble_stop_adv();
1664     }
1665     if (p_cb->adv_mode == BTM_BLE_ADV_ENABLE)
1666     {
1667         p_cb->fast_adv_on = TRUE;
1668         /* start initial GAP mode adv timer */
1669         btu_start_timer (&p_cb->fast_adv_timer, BTU_TTYPE_BLE_GAP_FAST_ADV,
1670                              BTM_BLE_GAP_FAST_ADV_TOUT);
1671     }
1672     return status;
1673 }
1674
1675
1676 /*******************************************************************************
1677 **
1678 ** Function         btm_ble_start_inquiry
1679 **
1680 ** Description      This function is called to start BLE inquiry procedure.
1681 **                  If the duration is zero, the periodic inquiry mode is cancelled.
1682 **
1683 ** Parameters:      mode - GENERAL or LIMITED inquiry
1684 **                  p_inq_params - pointer to the BLE inquiry parameter.
1685 **                  p_results_cb - callback returning pointer to results (tBTM_INQ_RESULTS)
1686 **                  p_cmpl_cb - callback indicating the end of an inquiry
1687 **
1688 **
1689 **
1690 ** Returns          BTM_CMD_STARTED if successfully started
1691 **                  BTM_NO_RESOURCES if could not allocate a message buffer
1692 **                  BTM_BUSY - if an inquiry is already active
1693 **
1694 *******************************************************************************/
1695 tBTM_STATUS btm_ble_start_inquiry (UINT8 mode, UINT8   duration)
1696 {
1697     tBTM_STATUS status = BTM_CMD_STARTED;
1698     tBTM_BLE_CB *p_ble_cb = &btm_cb.ble_ctr_cb;
1699     tBTM_INQUIRY_VAR_ST      *p_inq = &btm_cb.btm_inq_vars;
1700
1701     BTM_TRACE_DEBUG("btm_ble_start_inquiry: mode = %02x inq_active = 0x%02x", mode, btm_cb.btm_inq_vars.inq_active);
1702
1703     /* if selective connection is active, or inquiry is already active, reject it */
1704     if (BTM_BLE_IS_INQ_ACTIVE(p_ble_cb->scan_activity) ||
1705         BTM_BLE_IS_SEL_CONN_ACTIVE (p_ble_cb->scan_activity))
1706     {
1707         BTM_TRACE_ERROR("LE Inquiry is active, can not start inquiry");
1708         return(BTM_BUSY);
1709     }
1710
1711     if (!BTM_BLE_IS_SCAN_ACTIVE(p_ble_cb->scan_activity))
1712     {
1713         btm_update_scanner_filter_policy(SP_ADV_ALL);
1714
1715 #if (defined BLE_PRIVACY_SPT && BLE_PRIVACY_SPT == TRUE)
1716         /* enable IRK list */
1717         btm_ble_vendor_irk_list_known_dev (TRUE);
1718 #endif
1719         status = btm_ble_start_scan(BTM_BLE_DUPLICATE_DISABLE);
1720     }
1721
1722     if (status == BTM_CMD_STARTED)
1723     {
1724         p_inq->inq_active |= mode;
1725         p_ble_cb->scan_activity |= mode;
1726
1727         BTM_TRACE_DEBUG("btm_ble_start_inquiry inq_active = 0x%02x", p_inq->inq_active);
1728
1729         if (duration != 0)
1730         {
1731             /* start inquiry timer */
1732             btu_start_timer (&p_inq->inq_timer_ent, BTU_TTYPE_BLE_INQUIRY, duration);
1733         }
1734     }
1735
1736     return status;
1737
1738 }
1739
1740 /*******************************************************************************
1741 **
1742 ** Function         btm_ble_read_remote_name_cmpl
1743 **
1744 ** Description      This function is called when BLE remote name is received.
1745 **
1746 ** Returns          void
1747 **
1748 *******************************************************************************/
1749 void btm_ble_read_remote_name_cmpl(BOOLEAN status, BD_ADDR bda, UINT16 length, char *p_name)
1750 {
1751     UINT8   hci_status = HCI_SUCCESS;
1752     BD_NAME bd_name;
1753
1754     memset(bd_name, 0, (BD_NAME_LEN + 1));
1755     if (length > BD_NAME_LEN)
1756     {
1757         length = BD_NAME_LEN;
1758     }
1759     memcpy((UINT8*)bd_name, p_name, length);
1760
1761     if ((!status) || (length==0))
1762     {
1763         hci_status = HCI_ERR_HOST_TIMEOUT;
1764     }
1765
1766     btm_process_remote_name(bda, bd_name, length +1, hci_status);
1767     btm_sec_rmt_name_request_complete (bda, (UINT8 *)p_name, hci_status);
1768 }
1769
1770 /*******************************************************************************
1771 **
1772 ** Function         btm_ble_read_remote_name
1773 **
1774 ** Description      This function read remote LE device name using GATT read
1775 **                  procedure.
1776 **
1777 ** Parameters:       None.
1778 **
1779 ** Returns          void
1780 **
1781 *******************************************************************************/
1782 tBTM_STATUS btm_ble_read_remote_name(BD_ADDR remote_bda, tBTM_INQ_INFO *p_cur, tBTM_CMPL_CB *p_cb)
1783 {
1784     tBTM_INQUIRY_VAR_ST      *p_inq = &btm_cb.btm_inq_vars;
1785
1786     if (!HCI_LE_HOST_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_1]))
1787         return BTM_ERR_PROCESSING;
1788
1789     if (p_cur &&
1790         p_cur->results.ble_evt_type != BTM_BLE_EVT_CONN_ADV &&
1791         p_cur->results.ble_evt_type != BTM_BLE_EVT_CONN_DIR_ADV)
1792     {
1793         BTM_TRACE_DEBUG("name request to non-connectable device failed.");
1794         return BTM_ERR_PROCESSING;
1795     }
1796
1797     /* read remote device name using GATT procedure */
1798     if (p_inq->remname_active)
1799         return BTM_BUSY;
1800
1801     if (!GAP_BleReadPeerDevName(remote_bda, btm_ble_read_remote_name_cmpl))
1802         return BTM_BUSY;
1803
1804     p_inq->p_remname_cmpl_cb = p_cb;
1805     p_inq->remname_active = TRUE;
1806
1807     memcpy(p_inq->remname_bda, remote_bda, BD_ADDR_LEN);
1808
1809     btu_start_timer (&p_inq->rmt_name_timer_ent,
1810                      BTU_TTYPE_BTM_RMT_NAME,
1811                      BTM_EXT_BLE_RMT_NAME_TIMEOUT);
1812
1813     return BTM_CMD_STARTED;
1814 }
1815
1816 /*******************************************************************************
1817 **
1818 ** Function         btm_ble_cancel_remote_name
1819 **
1820 ** Description      This function cancel read remote LE device name.
1821 **
1822 ** Parameters:       None.
1823 **
1824 ** Returns          void
1825 **
1826 *******************************************************************************/
1827 BOOLEAN btm_ble_cancel_remote_name(BD_ADDR remote_bda)
1828 {
1829     tBTM_INQUIRY_VAR_ST      *p_inq = &btm_cb.btm_inq_vars;
1830     BOOLEAN     status;
1831
1832     status = GAP_BleCancelReadPeerDevName(remote_bda);
1833
1834     p_inq->remname_active = FALSE;
1835     memset(p_inq->remname_bda, 0, BD_ADDR_LEN);
1836     btu_stop_timer(&p_inq->rmt_name_timer_ent);
1837
1838     return status;
1839 }
1840
1841 /*******************************************************************************
1842 **
1843 ** Function         btm_ble_update_adv_flag
1844 **
1845 ** Description      This function update the limited discoverable flag in the adv
1846 **                  data.
1847 **
1848 ** Parameters:       None.
1849 **
1850 ** Returns          void
1851 **
1852 *******************************************************************************/
1853 static void btm_ble_update_adv_flag(UINT8 flag)
1854 {
1855     tBTM_BLE_LOCAL_ADV_DATA *p_adv_data = &btm_cb.ble_ctr_cb.inq_var.adv_data;
1856     UINT8   *p;
1857
1858     BTM_TRACE_DEBUG ("btm_ble_update_adv_flag new=0x%x", flag);
1859
1860     if (p_adv_data->p_flags != NULL)
1861     {
1862         BTM_TRACE_DEBUG ("btm_ble_update_adv_flag old=0x%x",   *p_adv_data->p_flags);
1863         *p_adv_data->p_flags = flag;
1864     }
1865     else /* no FLAGS in ADV data*/
1866     {
1867         p = (p_adv_data->p_pad == NULL) ? p_adv_data->ad_data : p_adv_data->p_pad;
1868         /* need 3 bytes space to stuff in the flags, if not */
1869         /* erase all written data, just for flags */
1870         if ((BTM_BLE_AD_DATA_LEN - (p - p_adv_data->ad_data)) < 3)
1871         {
1872             p = p_adv_data->p_pad = p_adv_data->ad_data;
1873             memset(p_adv_data->ad_data, 0, BTM_BLE_AD_DATA_LEN);
1874         }
1875
1876         *p++ = 2;
1877         *p++ = BTM_BLE_AD_TYPE_FLAG;
1878         p_adv_data->p_flags = p;
1879         *p++ = flag;
1880         p_adv_data->p_pad = p;
1881     }
1882
1883     if (btsnd_hcic_ble_set_adv_data((UINT8)(p_adv_data->p_pad - p_adv_data->ad_data),
1884                                     p_adv_data->ad_data))
1885         p_adv_data->data_mask |= BTM_BLE_AD_BIT_FLAGS;
1886
1887 }
1888
1889 #if 0
1890 /*******************************************************************************
1891 **
1892 ** Function         btm_ble_parse_adv_data
1893 **
1894 ** Description      This function parse the adv data into a structure.
1895 **
1896 ** Returns          pointer to entry, or NULL if not found
1897 **
1898 *******************************************************************************/
1899 static void btm_ble_parse_adv_data(tBTM_INQ_INFO *p_info, UINT8 *p_data,
1900                                    UINT8 len, tBTM_BLE_INQ_DATA *p_adv_data, UINT8 *p_buf)
1901 {
1902     UINT8   *p_cur = p_data;
1903     UINT8   ad_len, ad_type, ad_flag;
1904
1905     BTM_TRACE_EVENT (" btm_ble_parse_adv_data");
1906
1907     while (len > 0)
1908     {
1909         BTM_TRACE_DEBUG("btm_ble_parse_adv_data: len = %d", len);
1910         if ((ad_len = *p_cur ++) == 0)
1911             break;
1912
1913         ad_type = *p_cur ++;
1914
1915         BTM_TRACE_DEBUG("     ad_type = %02x ad_len = %d", ad_type, ad_len);
1916
1917         switch (ad_type)
1918         {
1919             case BTM_BLE_AD_TYPE_NAME_SHORT:
1920
1921             case BTM_BLE_AD_TYPE_NAME_CMPL:
1922                 p_adv_data->ad_mask |= BTM_BLE_AD_BIT_DEV_NAME;
1923                 if (p_info)
1924                 {
1925                     p_info->remote_name_type =(ad_type == BTM_BLE_AD_TYPE_NAME_SHORT) ?
1926                                               BTM_BLE_NAME_SHORT: BTM_BLE_NAME_CMPL;
1927                     memcpy(p_info->remote_name, p_cur, ad_len -1);
1928                     p_info->remote_name[ad_len] = 0;
1929                     p_adv_data->p_remote_name = p_info->remote_name;
1930                     p_info->remote_name_len = p_adv_data->remote_name_len = ad_len - 1;
1931                     BTM_TRACE_DEBUG("BTM_BLE_AD_TYPE_NAME name = %s",p_adv_data->p_remote_name);
1932                 }
1933                 p_cur += (ad_len -1);
1934
1935                 break;
1936
1937             case BTM_BLE_AD_TYPE_FLAG:
1938                 p_adv_data->ad_mask |= BTM_BLE_AD_BIT_FLAGS;
1939                 ad_flag = *p_cur ++;
1940                 p_adv_data->flag = (UINT8)(ad_flag & BTM_BLE_ADV_FLAG_MASK) ;
1941                 BTM_TRACE_DEBUG("BTM_BLE_AD_TYPE_FLAG flag = %s | %s | %s",
1942                                  (p_adv_data->flag & BTM_BLE_LIMIT_DISC_FLAG)? "LE_LIMIT_DISC" : "",
1943                                  (p_adv_data->flag & BTM_BLE_GEN_DISC_FLAG)? "LE_GENERAL_DISC" : "",
1944                                  (p_adv_data->flag & BTM_BLE_BREDR_NOT_SPT)? "LE Only device" : "");
1945                 break;
1946
1947             case BTM_BLE_AD_TYPE_TX_PWR:
1948                 p_adv_data->ad_mask |= BTM_BLE_AD_BIT_TX_PWR;
1949                 p_adv_data->tx_power_level = (INT8)*p_cur ++;
1950                 BTM_TRACE_DEBUG("BTM_BLE_AD_TYPE_TX_PWR tx_level = %d", p_adv_data->tx_power_level);
1951                 break;
1952
1953             case BTM_BLE_AD_TYPE_MANU:
1954
1955             case BTM_BLE_AD_TYPE_16SRV_PART:
1956             case BTM_BLE_AD_TYPE_16SRV_CMPL:
1957                 p_adv_data->ad_mask |= BTM_BLE_AD_BIT_SERVICE;
1958                 /* need allocate memory to store UUID list */
1959                 p_adv_data->service.num_service = (ad_len - 1)/2;
1960                 BTM_TRACE_DEBUG("service UUID list, num = %d", p_adv_data->service.num_service);
1961                 p_cur += (ad_len - 1);
1962                 break;
1963
1964             case BTM_BLE_AD_TYPE_SOL_SRV_UUID:
1965                 p_adv_data->ad_mask |= BTM_BLE_AD_BIT_SERVICE_SOL;
1966                 /* need allocate memory to store UUID list */
1967                 p_adv_data->service.num_service = (ad_len - 1)/2;
1968                 BTM_TRACE_DEBUG("service UUID list, num = %d", p_adv_data->service.num_service);
1969                 p_cur += (ad_len - 1);
1970                 break;
1971
1972             case BTM_BLE_AD_TYPE_128SOL_SRV_UUID:
1973                 p_adv_data->ad_mask |= BTM_BLE_AD_BIT_SERVICE_128SOL;
1974                 /* need allocate memory to store UUID list */
1975                 p_adv_data->service.num_service = (ad_len - 1)/16;
1976                 BTM_TRACE_DEBUG("service UUID list, num = %d", p_adv_data->service.num_service);
1977                 p_cur += (ad_len - 1);
1978                 break;
1979
1980             case BTM_BLE_AD_TYPE_APPEARANCE:
1981             case BTM_BLE_AD_TYPE_PUBLIC_TARGET:
1982             case BTM_BLE_AD_TYPE_RANDOM_TARGET:
1983             default:
1984                 break;
1985         }
1986         len -= (ad_len + 1);
1987     }
1988 }
1989 #endif
1990
1991 /*******************************************************************************
1992 **
1993 ** Function         btm_ble_cache_adv_data
1994 **
1995 ** Description      Update advertising cache data.
1996 **
1997 ** Returns          void
1998 **
1999 *******************************************************************************/
2000 void btm_ble_cache_adv_data(tBTM_INQ_RESULTS *p_cur, UINT8 data_len, UINT8 *p, UINT8 evt_type)
2001 {
2002     tBTM_BLE_INQ_CB     *p_le_inq_cb = &btm_cb.ble_ctr_cb.inq_var;
2003     UINT8 *p_cache;
2004     UINT8 length;
2005     UNUSED(p_cur);
2006
2007     /* cache adv report/scan response data */
2008     if (evt_type != BTM_BLE_SCAN_RSP_EVT)
2009     {
2010         p_le_inq_cb->adv_len = 0;
2011         memset(p_le_inq_cb->adv_data_cache, 0, BTM_BLE_CACHE_ADV_DATA_MAX);
2012     }
2013
2014     if (data_len > 0)
2015     {
2016         p_cache = &p_le_inq_cb->adv_data_cache[p_le_inq_cb->adv_len];
2017         STREAM_TO_UINT8(length, p);
2018         while ( length && ((p_le_inq_cb->adv_len + length + 1) <= BTM_BLE_CACHE_ADV_DATA_MAX))
2019         {
2020             /* copy from the length byte & data into cache */
2021             memcpy(p_cache, p-1, length+1);
2022             /* advance the cache pointer past data */
2023             p_cache += length+1;
2024             /* increment cache length */
2025             p_le_inq_cb->adv_len += length+1;
2026             /* skip the length of data */
2027             p += length;
2028             STREAM_TO_UINT8(length, p);
2029         }
2030     }
2031
2032     /* parse service UUID from adv packet and save it in inq db eir_uuid */
2033     /* TODO */
2034 }
2035
2036 /*******************************************************************************
2037 **
2038 ** Function         btm_ble_is_discoverable
2039 **
2040 ** Description      check ADV flag to make sure device is discoverable and match
2041 **                  the search condition
2042 **
2043 ** Parameters
2044 **
2045 ** Returns          void
2046 **
2047 *******************************************************************************/
2048 UINT8 btm_ble_is_discoverable(BD_ADDR bda, UINT8 evt_type, UINT8 *p)
2049 {
2050     UINT8               *p_flag, flag = 0, rt = 0;
2051     UINT8                data_len;
2052     tBTM_INQ_PARMS      *p_cond = &btm_cb.btm_inq_vars.inqparms;
2053     tBTM_BLE_INQ_CB     *p_le_inq_cb = &btm_cb.ble_ctr_cb.inq_var;
2054
2055     UNUSED(p);
2056
2057     /* for observer, always "discoverable */
2058     if (BTM_BLE_IS_OBS_ACTIVE(btm_cb.ble_ctr_cb.scan_activity))
2059         rt |= BTM_BLE_OBS_RESULT;
2060
2061     if (BTM_BLE_IS_SEL_CONN_ACTIVE(btm_cb.ble_ctr_cb.scan_activity) &&
2062         (evt_type == BTM_BLE_CONNECT_EVT || evt_type == BTM_BLE_CONNECT_DIR_EVT))
2063         rt |= BTM_BLE_SEL_CONN_RESULT;
2064
2065     /* does not match filter condition */
2066     if (p_cond->filter_cond_type == BTM_FILTER_COND_BD_ADDR &&
2067         memcmp(bda, p_cond->filter_cond.bdaddr_cond, BD_ADDR_LEN) != 0)
2068     {
2069         BTM_TRACE_DEBUG("BD ADDR does not meet filter condition");
2070         return rt;
2071     }
2072
2073     if (p_le_inq_cb->adv_len != 0)
2074     {
2075         if ((p_flag = BTM_CheckAdvData(p_le_inq_cb->adv_data_cache,
2076             BTM_BLE_AD_TYPE_FLAG, &data_len)) != NULL)
2077         {
2078             flag = * p_flag;
2079
2080             if ((btm_cb.btm_inq_vars.inq_active & BTM_BLE_GENERAL_INQUIRY) &&
2081                 (flag & (BTM_BLE_LIMIT_DISC_FLAG|BTM_BLE_GEN_DISC_FLAG)) != 0)
2082             {
2083                 BTM_TRACE_DEBUG("Find Generable Discoverable device");
2084                 rt |= BTM_BLE_INQ_RESULT;
2085             }
2086
2087             else if (btm_cb.btm_inq_vars.inq_active & BTM_BLE_LIMITED_INQUIRY &&
2088                      (flag & BTM_BLE_LIMIT_DISC_FLAG) != 0)
2089             {
2090                 BTM_TRACE_DEBUG("Find limited discoverable device");
2091                 rt |= BTM_BLE_INQ_RESULT;
2092             }
2093         }
2094     }
2095     return rt;
2096 }
2097
2098 static void btm_ble_appearance_to_cod(UINT16 appearance, UINT8 *dev_class)
2099 {
2100     dev_class[0] = 0;
2101
2102     switch (appearance)
2103     {
2104         case BTM_BLE_APPEARANCE_GENERIC_PHONE:
2105             dev_class[1] = BTM_COD_MAJOR_PHONE;
2106             dev_class[2] = BTM_COD_MINOR_UNCLASSIFIED;
2107             break;
2108         case BTM_BLE_APPEARANCE_GENERIC_COMPUTER:
2109             dev_class[1] = BTM_COD_MAJOR_COMPUTER;
2110             dev_class[2] = BTM_COD_MINOR_UNCLASSIFIED;
2111             break;
2112         case BTM_BLE_APPEARANCE_GENERIC_REMOTE:
2113             dev_class[1] = BTM_COD_MAJOR_PERIPHERAL;
2114             dev_class[2] = BTM_COD_MINOR_REMOTE_CONTROL;
2115             break;
2116         case BTM_BLE_APPEARANCE_GENERIC_THERMOMETER:
2117         case BTM_BLE_APPEARANCE_THERMOMETER_EAR:
2118             dev_class[1] = BTM_COD_MAJOR_HEALTH;
2119             dev_class[2] = BTM_COD_MINOR_THERMOMETER;
2120             break;
2121         case BTM_BLE_APPEARANCE_GENERIC_HEART_RATE:
2122         case BTM_BLE_APPEARANCE_HEART_RATE_BELT:
2123             dev_class[1] = BTM_COD_MAJOR_HEALTH;
2124             dev_class[2] = BTM_COD_MINOR_HEART_PULSE_MONITOR;
2125             break;
2126         case BTM_BLE_APPEARANCE_GENERIC_BLOOD_PRESSURE:
2127         case BTM_BLE_APPEARANCE_BLOOD_PRESSURE_ARM:
2128         case BTM_BLE_APPEARANCE_BLOOD_PRESSURE_WRIST:
2129             dev_class[1] = BTM_COD_MAJOR_HEALTH;
2130             dev_class[2] = BTM_COD_MINOR_BLOOD_MONITOR;
2131             break;
2132         case BTM_BLE_APPEARANCE_GENERIC_PULSE_OXIMETER:
2133         case BTM_BLE_APPEARANCE_PULSE_OXIMETER_FINGERTIP:
2134         case BTM_BLE_APPEARANCE_PULSE_OXIMETER_WRIST:
2135             dev_class[1] = BTM_COD_MAJOR_HEALTH;
2136             dev_class[2] = BTM_COD_MINOR_PULSE_OXIMETER;
2137             break;
2138         case BTM_BLE_APPEARANCE_GENERIC_GLUCOSE:
2139             dev_class[1] = BTM_COD_MAJOR_HEALTH;
2140             dev_class[2] = BTM_COD_MINOR_GLUCOSE_METER;
2141             break;
2142         case BTM_BLE_APPEARANCE_GENERIC_WEIGHT:
2143             dev_class[1] = BTM_COD_MAJOR_HEALTH;
2144             dev_class[2] = BTM_COD_MINOR_WEIGHING_SCALE;
2145             break;
2146         case BTM_BLE_APPEARANCE_GENERIC_WALKING:
2147         case BTM_BLE_APPEARANCE_WALKING_IN_SHOE:
2148         case BTM_BLE_APPEARANCE_WALKING_ON_SHOE:
2149         case BTM_BLE_APPEARANCE_WALKING_ON_HIP:
2150             dev_class[1] = BTM_COD_MAJOR_HEALTH;
2151             dev_class[2] = BTM_COD_MINOR_STEP_COUNTER;
2152             break;
2153         case BTM_BLE_APPEARANCE_GENERIC_WATCH:
2154         case BTM_BLE_APPEARANCE_SPORTS_WATCH:
2155             dev_class[1] = BTM_COD_MAJOR_WEARABLE;
2156             dev_class[2] = BTM_COD_MINOR_WRIST_WATCH;
2157             break;
2158         case BTM_BLE_APPEARANCE_GENERIC_EYEGLASSES:
2159             dev_class[1] = BTM_COD_MAJOR_WEARABLE;
2160             dev_class[2] = BTM_COD_MINOR_GLASSES;
2161             break;
2162         case BTM_BLE_APPEARANCE_GENERIC_DISPLAY:
2163             dev_class[1] = BTM_COD_MAJOR_IMAGING;
2164             dev_class[2] = BTM_COD_MINOR_DISPLAY;
2165             break;
2166         case BTM_BLE_APPEARANCE_GENERIC_MEDIA_PLAYER:
2167             dev_class[1] = BTM_COD_MAJOR_AUDIO;
2168             dev_class[2] = BTM_COD_MINOR_UNCLASSIFIED;
2169             break;
2170         case BTM_BLE_APPEARANCE_GENERIC_BARCODE_SCANNER:
2171         case BTM_BLE_APPEARANCE_HID_BARCODE_SCANNER:
2172         case BTM_BLE_APPEARANCE_GENERIC_HID:
2173             dev_class[1] = BTM_COD_MAJOR_PERIPHERAL;
2174             dev_class[2] = BTM_COD_MINOR_UNCLASSIFIED;
2175             break;
2176         case BTM_BLE_APPEARANCE_HID_KEYBOARD:
2177             dev_class[1] = BTM_COD_MAJOR_PERIPHERAL;
2178             dev_class[2] = BTM_COD_MINOR_KEYBOARD;
2179             break;
2180         case BTM_BLE_APPEARANCE_HID_MOUSE:
2181             dev_class[1] = BTM_COD_MAJOR_PERIPHERAL;
2182             dev_class[2] = BTM_COD_MINOR_POINTING;
2183             break;
2184         case BTM_BLE_APPEARANCE_HID_JOYSTICK:
2185             dev_class[1] = BTM_COD_MAJOR_PERIPHERAL;
2186             dev_class[2] = BTM_COD_MINOR_JOYSTICK;
2187             break;
2188         case BTM_BLE_APPEARANCE_HID_GAMEPAD:
2189             dev_class[1] = BTM_COD_MAJOR_PERIPHERAL;
2190             dev_class[2] = BTM_COD_MINOR_GAMEPAD;
2191             break;
2192         case BTM_BLE_APPEARANCE_HID_DIGITIZER_TABLET:
2193             dev_class[1] = BTM_COD_MAJOR_PERIPHERAL;
2194             dev_class[2] = BTM_COD_MINOR_DIGITIZING_TABLET;
2195             break;
2196         case BTM_BLE_APPEARANCE_HID_CARD_READER:
2197             dev_class[1] = BTM_COD_MAJOR_PERIPHERAL;
2198             dev_class[2] = BTM_COD_MINOR_CARD_READER;
2199             break;
2200         case BTM_BLE_APPEARANCE_HID_DIGITAL_PEN:
2201             dev_class[1] = BTM_COD_MAJOR_PERIPHERAL;
2202             dev_class[2] = BTM_COD_MINOR_DIGITAL_PAN;
2203             break;
2204         case BTM_BLE_APPEARANCE_UKNOWN:
2205         case BTM_BLE_APPEARANCE_GENERIC_CLOCK:
2206         case BTM_BLE_APPEARANCE_GENERIC_TAG:
2207         case BTM_BLE_APPEARANCE_GENERIC_KEYRING:
2208         case BTM_BLE_APPEARANCE_GENERIC_CYCLING:
2209         case BTM_BLE_APPEARANCE_CYCLING_COMPUTER:
2210         case BTM_BLE_APPEARANCE_CYCLING_SPEED:
2211         case BTM_BLE_APPEARANCE_CYCLING_CADENCE:
2212         case BTM_BLE_APPEARANCE_CYCLING_POWER:
2213         case BTM_BLE_APPEARANCE_CYCLING_SPEED_CADENCE:
2214         case BTM_BLE_APPEARANCE_GENERIC_OUTDOOR_SPORTS:
2215         case BTM_BLE_APPEARANCE_OUTDOOR_SPORTS_LOCATION:
2216         case BTM_BLE_APPEARANCE_OUTDOOR_SPORTS_LOCATION_AND_NAV:
2217         case BTM_BLE_APPEARANCE_OUTDOOR_SPORTS_LOCATION_POD:
2218         case BTM_BLE_APPEARANCE_OUTDOOR_SPORTS_LOCATION_POD_AND_NAV:
2219         default:
2220             dev_class[1] = BTM_COD_MAJOR_UNCLASSIFIED;
2221             dev_class[2] = BTM_COD_MINOR_UNCLASSIFIED;
2222     };
2223 }
2224
2225 /*******************************************************************************
2226 **
2227 ** Function         btm_ble_update_inq_result
2228 **
2229 ** Description      Update adv packet information into inquiry result.
2230 **
2231 ** Parameters
2232 **
2233 ** Returns          void
2234 **
2235 *******************************************************************************/
2236 BOOLEAN btm_ble_update_inq_result(tINQ_DB_ENT *p_i, UINT8 addr_type, UINT8 evt_type, UINT8 *p)
2237 {
2238     BOOLEAN             to_report = TRUE;
2239     tBTM_INQ_RESULTS     *p_cur = &p_i->inq_info.results;
2240     UINT8               len;
2241     UINT8               *p_flag;
2242     tBTM_INQUIRY_VAR_ST  *p_inq = &btm_cb.btm_inq_vars;
2243     UINT8                data_len, rssi;
2244     tBTM_BLE_INQ_CB     *p_le_inq_cb = &btm_cb.ble_ctr_cb.inq_var;
2245     UINT8 *p1;
2246     UINT8               *p_uuid16;
2247
2248     STREAM_TO_UINT8    (data_len, p);
2249
2250     if (data_len > BTM_BLE_ADV_DATA_LEN_MAX)
2251     {
2252         BTM_TRACE_WARNING("EIR data too long %d. discard", data_len);
2253         return FALSE;
2254     }
2255     btm_ble_cache_adv_data(p_cur, data_len, p, evt_type);
2256
2257     p1 = (p + data_len);
2258     STREAM_TO_UINT8 (rssi, p1);
2259
2260     /* Save the info */
2261     p_cur->inq_result_type = BTM_INQ_RESULT_BLE;
2262     p_cur->ble_addr_type    = addr_type;
2263     p_cur->rssi = rssi;
2264
2265     /* active scan, always wait until get scan_rsp to report the result */
2266     if ((btm_cb.ble_ctr_cb.inq_var.scan_type == BTM_BLE_SCAN_MODE_ACTI &&
2267          (evt_type == BTM_BLE_CONNECT_EVT || evt_type == BTM_BLE_DISCOVER_EVT)))
2268     {
2269         BTM_TRACE_DEBUG("btm_ble_update_inq_result scan_rsp=false, to_report=false,\
2270                               scan_type_active=%d", btm_cb.ble_ctr_cb.inq_var.scan_type);
2271         p_i->scan_rsp = FALSE;
2272         to_report = FALSE;
2273     }
2274     else
2275         p_i->scan_rsp = TRUE;
2276
2277     if (p_i->inq_count != p_inq->inq_counter)
2278         p_cur->device_type = BT_DEVICE_TYPE_BLE;
2279     else
2280         p_cur->device_type |= BT_DEVICE_TYPE_BLE;
2281
2282     if (evt_type != BTM_BLE_SCAN_RSP_EVT)
2283         p_cur->ble_evt_type     = evt_type;
2284
2285     p_i->inq_count = p_inq->inq_counter;   /* Mark entry for current inquiry */
2286
2287     if (p_le_inq_cb->adv_len != 0)
2288     {
2289         if ((p_flag = BTM_CheckAdvData(p_le_inq_cb->adv_data_cache, BTM_BLE_AD_TYPE_FLAG, &len)) != NULL)
2290             p_cur->flag = * p_flag;
2291     }
2292
2293     if (p_le_inq_cb->adv_len != 0)
2294     {
2295         /* Check to see the BLE device has the Appearance UUID in the advertising data.  If it does
2296          * then try to convert the appearance value to a class of device value Bluedroid can use.
2297          * Otherwise fall back to trying to infer if it is a HID device based on the service class.
2298          */
2299         p_uuid16 = BTM_CheckAdvData(p_le_inq_cb->adv_data_cache, BTM_BLE_AD_TYPE_APPEARANCE, &len);
2300         if (p_uuid16 && len == 2)
2301         {
2302             btm_ble_appearance_to_cod((UINT16)p_uuid16[0] | (p_uuid16[1] << 8), p_cur->dev_class);
2303         }
2304         else
2305         {
2306             if ((p_uuid16 = BTM_CheckAdvData(p_le_inq_cb->adv_data_cache,
2307                                              BTM_BLE_AD_TYPE_16SRV_CMPL, &len)) != NULL)
2308             {
2309                 UINT8 i;
2310                 for (i = 0; i + 2 <= len; i = i + 2)
2311                 {
2312                     /* if this BLE device support HID over LE, set HID Major in class of device */
2313                     if ((p_uuid16[i] | (p_uuid16[i+1] << 8)) == UUID_SERVCLASS_LE_HID)
2314                     {
2315                         p_cur->dev_class[0] = 0;
2316                         p_cur->dev_class[1] = BTM_COD_MAJOR_PERIPHERAL;
2317                         p_cur->dev_class[2] = 0;
2318                         break;
2319                     }
2320                 }
2321             }
2322         }
2323     }
2324
2325     /* if BR/EDR not supported is not set, assume is a DUMO device */
2326     if ((p_cur->flag & BTM_BLE_BREDR_NOT_SPT) == 0 &&
2327          evt_type != BTM_BLE_CONNECT_DIR_EVT)
2328     {
2329         if (p_cur->ble_addr_type != BLE_ADDR_RANDOM)
2330         {
2331             BTM_TRACE_DEBUG("BR/EDR NOT support bit not set, treat as DUMO");
2332             p_cur->device_type |= BT_DEVICE_TYPE_DUMO;
2333         } else {
2334             BTM_TRACE_DEBUG("Random address, treating device as LE only");
2335         }
2336     }
2337     else
2338     {
2339         BTM_TRACE_DEBUG("BR/EDR NOT SUPPORT bit set, LE only device");
2340     }
2341
2342     return to_report;
2343
2344 }
2345
2346 /*******************************************************************************
2347 **
2348 ** Function         btm_send_sel_conn_callback
2349 **
2350 ** Description      send selection connection request callback.
2351 **
2352 ** Parameters
2353 **
2354 ** Returns          void
2355 **
2356 *******************************************************************************/
2357 void btm_send_sel_conn_callback(BD_ADDR remote_bda, UINT8 evt_type, UINT8 *p_data, UINT8 addr_type)
2358 {
2359     UINT8   data_len, len;
2360     UINT8   *p_dev_name, remname[31] = {0};
2361     UNUSED(addr_type);
2362
2363     if (btm_cb.ble_ctr_cb.p_select_cback == NULL ||
2364         /* non-connectable device */
2365         (evt_type != BTM_BLE_EVT_CONN_ADV && evt_type != BTM_BLE_EVT_CONN_DIR_ADV))
2366         return;
2367
2368     STREAM_TO_UINT8    (data_len, p_data);
2369
2370     /* get the device name if exist in ADV data */
2371     if (data_len != 0)
2372     {
2373         p_dev_name = BTM_CheckAdvData(p_data, BTM_BLE_AD_TYPE_NAME_CMPL, &len);
2374
2375         if (p_dev_name == NULL)
2376             p_dev_name = BTM_CheckAdvData(p_data, BTM_BLE_AD_TYPE_NAME_SHORT, &len);
2377
2378         if (p_dev_name)
2379             memcpy(remname, p_dev_name, len);
2380     }
2381     /* allow connection */
2382     if ((* btm_cb.ble_ctr_cb.p_select_cback)(remote_bda, remname))
2383     {
2384         /* terminate selective connection, initiate connection */
2385         btm_ble_initiate_select_conn(remote_bda);
2386     }
2387 }
2388
2389 /*******************************************************************************
2390 **
2391 ** Function         btm_ble_process_adv_pkt
2392 **
2393 ** Description      This function is called when adv packet report events are
2394 **                  received from the device. It updates the inquiry database.
2395 **                  If the inquiry database is full, the oldest entry is discarded.
2396 **
2397 ** Parameters
2398 **
2399 ** Returns          void
2400 **
2401 *******************************************************************************/
2402 void btm_ble_process_adv_pkt (UINT8 *p_data)
2403 {
2404     BD_ADDR             bda;
2405     UINT8               evt_type = 0, *p = p_data;
2406     UINT8               addr_type = 0;
2407     UINT8               num_reports;
2408     UINT8               data_len;
2409 #if (defined BLE_PRIVACY_SPT && BLE_PRIVACY_SPT == TRUE)
2410     BOOLEAN             match = FALSE;
2411 #endif
2412
2413     /* Extract the number of reports in this event. */
2414     STREAM_TO_UINT8(num_reports, p);
2415
2416     while (num_reports--)
2417     {
2418         /* Extract inquiry results */
2419         STREAM_TO_UINT8    (evt_type, p);
2420         STREAM_TO_UINT8    (addr_type, p);
2421         STREAM_TO_BDADDR   (bda, p);
2422
2423 #ifdef BTM_BLE_PC_ADV_TEST_MODE /* For general stack code (e.g. BTInsight testing), we simply do not define it to exclude or set it to TRUE to include */
2424         if (BTM_BLE_PC_ADV_TEST_MODE)   /* For stack component, it is always defined and maps to a global variable g_bDraculaAdvertisingMode */
2425         {
2426             if (btm_cb.ble_ctr_cb.p_scan_req_cback)
2427                 (*btm_cb.ble_ctr_cb.p_scan_req_cback)(bda, addr_type, evt_type);
2428         }
2429 #endif
2430
2431 #if (defined BLE_PRIVACY_SPT && BLE_PRIVACY_SPT == TRUE)
2432     /* map address to security record */
2433     btm_public_addr_to_random_pseudo(bda, &addr_type);
2434     BTM_TRACE_DEBUG("new address: %02x:%02x:%02x:%02x:%02x:%02x",
2435                      bda[0], bda[1], bda[2], bda[3], bda[4], bda[5]);
2436 #endif
2437
2438         /* Only process the results if the inquiry is still active */
2439         if (!BTM_BLE_IS_SCAN_ACTIVE(btm_cb.ble_ctr_cb.scan_activity))
2440             return;
2441
2442     BTM_TRACE_DEBUG("btm_ble_process_adv_pkt:bda= %0x:%0x:%0x:%0x:%0x:%0x",
2443                                      bda[0],bda[1],bda[2],bda[3],bda[4],bda[5]);
2444 #if (defined BLE_PRIVACY_SPT && BLE_PRIVACY_SPT == TRUE)
2445 #if SMP_INCLUDED == TRUE
2446         /* always do RRA resolution on host */
2447         if (!match && BTM_BLE_IS_RESOLVE_BDA(bda))
2448         {
2449             btm_ble_resolve_random_addr(bda, btm_ble_resolve_random_addr_on_adv, p_data);
2450         }
2451         else
2452 #endif
2453 #endif
2454         {
2455             btm_ble_process_adv_pkt_cont(bda, addr_type, evt_type, p);
2456         }
2457
2458         STREAM_TO_UINT8(data_len, p);
2459
2460         /* Advance to the next event data_len + rssi byte */
2461         p += data_len + 1;
2462     }
2463 }
2464
2465 /*******************************************************************************
2466 **
2467 ** Function         btm_ble_process_adv_pkt_cont
2468 **
2469 ** Description      This function is called after random address resolution is
2470 **                  done, and proceed to process adv packet.
2471 **
2472 ** Parameters
2473 **
2474 ** Returns          void
2475 **
2476 *******************************************************************************/
2477 static void btm_ble_process_adv_pkt_cont(BD_ADDR bda, UINT8 addr_type, UINT8 evt_type, UINT8 *p)
2478 {
2479     tINQ_DB_ENT          *p_i;
2480     tBTM_INQUIRY_VAR_ST  *p_inq = &btm_cb.btm_inq_vars;
2481     tBTM_INQ_RESULTS_CB  *p_inq_results_cb = p_inq->p_inq_results_cb;
2482     tBTM_INQ_RESULTS_CB  *p_obs_results_cb = btm_cb.ble_ctr_cb.p_obs_results_cb;
2483     tBTM_BLE_INQ_CB      *p_le_inq_cb = &btm_cb.ble_ctr_cb.inq_var;
2484     BOOLEAN     update = TRUE;
2485     UINT8       result = 0;
2486
2487     p_i = btm_inq_db_find (bda);
2488
2489     /* Check if this address has already been processed for this inquiry */
2490     if (btm_inq_find_bdaddr(bda))
2491     {
2492         /* never been report as an LE device */
2493         if (p_i &&
2494             (!(p_i->inq_info.results.device_type & BT_DEVICE_TYPE_BLE) ||
2495               /* scan repsonse to be updated */
2496               (!p_i->scan_rsp)))
2497         {
2498             update = TRUE;
2499         }
2500         else if (BTM_BLE_IS_OBS_ACTIVE(btm_cb.ble_ctr_cb.scan_activity))
2501         {
2502             update = FALSE;
2503         }
2504         else
2505         {
2506             /* if yes, skip it */
2507             return; /* assumption: one result per event */
2508         }
2509     }
2510     /* If existing entry, use that, else get  a new one (possibly reusing the oldest) */
2511     if (p_i == NULL)
2512     {
2513         if ((p_i = btm_inq_db_new (bda)) != NULL)
2514         {
2515             p_inq->inq_cmpl_info.num_resp++;
2516         }
2517         else
2518             return;
2519     }
2520     else if (p_i->inq_count != p_inq->inq_counter) /* first time seen in this inquiry */
2521     {
2522         p_inq->inq_cmpl_info.num_resp++;
2523     }
2524     /* update the LE device information in inquiry database */
2525     if (!btm_ble_update_inq_result(p_i, addr_type, evt_type, p))
2526         return;
2527
2528     if ((result = btm_ble_is_discoverable(bda, evt_type, p)) == 0)
2529     {
2530         BTM_TRACE_ERROR("discard adv pkt");
2531         return;
2532     }
2533     if (!update)
2534         result &= ~BTM_BLE_INQ_RESULT;
2535 #if BTM_USE_INQ_RESULTS_FILTER == TRUE
2536     /* If the number of responses found and limited, issue a cancel inquiry */
2537     if (p_inq->inqparms.max_resps &&
2538         p_inq->inq_cmpl_info.num_resp == p_inq->inqparms.max_resps)
2539     {
2540         /* new device */
2541         if (p_i == NULL ||
2542             (/* assume a DUMO device, BR/EDR inquiry is always active */
2543              p_i && p_i->inq_info.results.device_type == BT_DEVICE_TYPE_BLE && p_i->scan_rsp))
2544         {
2545             BTM_TRACE_WARNING("INQ RES: Extra Response Received...cancelling inquiry..");
2546
2547             /* if is non-periodic inquiry active, cancel now */
2548             if ((p_inq->inq_active & BTM_BR_INQ_ACTIVE_MASK) != 0 &&
2549                 (p_inq->inq_active & BTM_PERIODIC_INQUIRY_ACTIVE) == 0)
2550                 btsnd_hcic_inq_cancel();
2551
2552             btm_ble_stop_inquiry();
2553
2554 #if BTM_BUSY_LEVEL_CHANGE_INCLUDED == TRUE
2555             btm_acl_update_busy_level (BTM_BLI_INQ_DONE_EVT);
2556 #endif
2557         }
2558     }
2559 #endif
2560     /* background connection in selective connection mode */
2561     if (btm_cb.ble_ctr_cb.bg_conn_type == BTM_BLE_CONN_SELECTIVE)
2562     {
2563         if (result & BTM_BLE_SEL_CONN_RESULT)
2564             btm_send_sel_conn_callback(bda, evt_type, p, addr_type);
2565         else
2566         {
2567             BTM_TRACE_DEBUG("None LE device, can not initiate selective connection");
2568         }
2569     }
2570     else
2571     {
2572         if (p_inq_results_cb && (result & BTM_BLE_INQ_RESULT))
2573         {
2574             (p_inq_results_cb)((tBTM_INQ_RESULTS *) &p_i->inq_info.results, p_le_inq_cb->adv_data_cache);
2575         }
2576         if (p_obs_results_cb && (result & BTM_BLE_OBS_RESULT))
2577         {
2578             (p_obs_results_cb)((tBTM_INQ_RESULTS *) &p_i->inq_info.results, p_le_inq_cb->adv_data_cache);
2579         }
2580     }
2581 }
2582
2583 /*******************************************************************************
2584 **
2585 ** Function         btm_ble_start_scan
2586 **
2587 ** Description      Start the BLE scan.
2588 **
2589 ** Returns          void
2590 **
2591 *******************************************************************************/
2592 tBTM_STATUS btm_ble_start_scan (UINT8 filter_enable)
2593 {
2594     tBTM_BLE_INQ_CB *p_inq = &btm_cb.ble_ctr_cb.inq_var;
2595     tBTM_STATUS status = BTM_CMD_STARTED;
2596
2597     /* start scan, disable duplicate filtering */
2598     if (!btsnd_hcic_ble_set_scan_enable (BTM_BLE_SCAN_ENABLE, filter_enable)) {
2599         status = BTM_NO_RESOURCES;
2600         btm_cb.ble_ctr_cb.wl_state &= ~BTM_BLE_WL_SCAN;
2601     }
2602     else
2603     {
2604         btm_cb.ble_ctr_cb.wl_state |= BTM_BLE_WL_SCAN;
2605         if (p_inq->scan_type == BTM_BLE_SCAN_MODE_ACTI)
2606             btm_ble_set_topology_mask(BTM_BLE_STATE_ACTIVE_SCAN_BIT);
2607         else
2608             btm_ble_set_topology_mask(BTM_BLE_STATE_PASSIVE_SCAN_BIT);
2609     }
2610     return status;
2611 }
2612
2613 /*******************************************************************************
2614 **
2615 ** Function         btm_ble_stop_scan
2616 **
2617 ** Description      Stop the BLE scan.
2618 **
2619 ** Returns          void
2620 **
2621 *******************************************************************************/
2622 void btm_ble_stop_scan(void)
2623 {
2624     BTM_TRACE_EVENT ("btm_ble_stop_scan ");
2625
2626     /* Clear the inquiry callback if set */
2627     btm_cb.ble_ctr_cb.inq_var.scan_type = BTM_BLE_SCAN_MODE_NONE;
2628
2629     /* stop discovery now */
2630     btsnd_hcic_ble_set_scan_enable (BTM_BLE_SCAN_DISABLE, BTM_BLE_DUPLICATE_ENABLE);
2631
2632     btm_update_scanner_filter_policy(SP_ADV_ALL);
2633
2634     btm_cb.ble_ctr_cb.wl_state &= ~BTM_BLE_WL_SCAN;
2635 }
2636 /*******************************************************************************
2637 **
2638 ** Function         btm_ble_stop_inquiry
2639 **
2640 ** Description      Stop the BLE Inquiry.
2641 **
2642 ** Returns          void
2643 **
2644 *******************************************************************************/
2645 void btm_ble_stop_inquiry(void)
2646 {
2647     tBTM_INQUIRY_VAR_ST *p_inq = &btm_cb.btm_inq_vars;
2648     tBTM_BLE_CB *p_ble_cb = &btm_cb.ble_ctr_cb;
2649
2650     btu_stop_timer (&p_ble_cb->inq_var.inq_timer_ent);
2651
2652     p_ble_cb->scan_activity &=  ~BTM_BLE_INQUIRY_MASK;
2653
2654     /* If no more scan activity, stop LE scan now */
2655     if (!BTM_BLE_IS_SCAN_ACTIVE(p_ble_cb->scan_activity))
2656         btm_ble_stop_scan();
2657
2658     /* If we have a callback registered for inquiry complete, call it */
2659     BTM_TRACE_DEBUG ("BTM Inq Compl Callback: status 0x%02x, num results %d",
2660                       p_inq->inq_cmpl_info.status, p_inq->inq_cmpl_info.num_resp);
2661
2662     btm_process_inq_complete(HCI_SUCCESS, (UINT8)(p_inq->inqparms.mode & BTM_BLE_INQUIRY_MASK));
2663 }
2664
2665 /*******************************************************************************
2666 **
2667 ** Function         btm_ble_stop_observe
2668 **
2669 ** Description      Stop the BLE Observe.
2670 **
2671 ** Returns          void
2672 **
2673 *******************************************************************************/
2674 static void btm_ble_stop_observe(void)
2675 {
2676     tBTM_BLE_CB *p_ble_cb = & btm_cb.ble_ctr_cb;
2677     tBTM_CMPL_CB *p_obs_cb = p_ble_cb->p_obs_cmpl_cb;
2678
2679     btu_stop_timer (&p_ble_cb->obs_timer_ent);
2680
2681     p_ble_cb->scan_activity &= ~BTM_LE_OBSERVE_ACTIVE;
2682
2683     p_ble_cb->p_obs_results_cb = NULL;
2684     p_ble_cb->p_obs_cmpl_cb = NULL;
2685
2686     if (!BTM_BLE_IS_SCAN_ACTIVE(p_ble_cb->scan_activity))
2687         btm_ble_stop_scan();
2688
2689     if (p_obs_cb)
2690         (p_obs_cb)((tBTM_INQUIRY_CMPL *) &btm_cb.btm_inq_vars.inq_cmpl_info);
2691 }
2692 /*******************************************************************************
2693 **
2694 ** Function         btm_ble_adv_states_operation
2695 **
2696 ** Description      Set or clear adv states in topology mask
2697 **
2698 ** Returns          operation status. TRUE if sucessful, FALSE otherwise.
2699 **
2700 *******************************************************************************/
2701 typedef BOOLEAN (BTM_TOPOLOGY_FUNC_PTR)(tBTM_BLE_STATE_MASK);
2702 static BOOLEAN btm_ble_adv_states_operation(BTM_TOPOLOGY_FUNC_PTR *p_handler, UINT8 adv_evt)
2703 {
2704     BOOLEAN rt = FALSE;
2705
2706     switch (adv_evt)
2707     {
2708     case BTM_BLE_CONNECT_EVT:
2709         rt  = (*p_handler)(BTM_BLE_STATE_CONN_ADV_BIT);
2710         break;
2711
2712     case  BTM_BLE_NON_CONNECT_EVT:
2713         rt  = (*p_handler) (BTM_BLE_STATE_NON_CONN_ADV_BIT);
2714         break;
2715     case BTM_BLE_CONNECT_DIR_EVT:
2716         rt  =  (*p_handler) (BTM_BLE_STATE_HI_DUTY_DIR_ADV_BIT);
2717         break;
2718
2719     case BTM_BLE_DISCOVER_EVT:
2720         rt  =  (*p_handler) (BTM_BLE_STATE_SCAN_ADV_BIT);
2721         break;
2722
2723     default:
2724         BTM_TRACE_ERROR("unknown adv event : %d", adv_evt);
2725         break;
2726     }
2727
2728     return rt;
2729 }
2730
2731
2732 /*******************************************************************************
2733 **
2734 ** Function         btm_ble_start_adv
2735 **
2736 ** Description      start the BLE advertising.
2737 **
2738 ** Returns          void
2739 **
2740 *******************************************************************************/
2741 tBTM_STATUS btm_ble_start_adv(void)
2742 {
2743     tBTM_BLE_INQ_CB *p_cb = &btm_cb.ble_ctr_cb.inq_var;
2744     tBTM_STATUS     rt = BTM_NO_RESOURCES;
2745
2746     if (!btm_ble_adv_states_operation (btm_ble_topology_check, p_cb->evt_type))
2747         return BTM_WRONG_MODE;
2748
2749     if (p_cb->afp != AP_SCAN_CONN_ALL)
2750     {
2751         btm_execute_wl_dev_operation();
2752         btm_cb.ble_ctr_cb.wl_state |= BTM_BLE_WL_ADV;
2753     }
2754
2755     if (btsnd_hcic_ble_set_adv_enable (BTM_BLE_ADV_ENABLE))
2756     {
2757         if (p_cb->afp != AP_SCAN_CONN_ALL)
2758              btm_cb.ble_ctr_cb.wl_state |= BTM_BLE_WL_ADV;
2759
2760          p_cb->adv_mode = BTM_BLE_ADV_ENABLE;
2761
2762          rt = BTM_SUCCESS;
2763     }
2764     else
2765     {
2766         p_cb->adv_mode = BTM_BLE_ADV_DISABLE;
2767         btm_cb.ble_ctr_cb.wl_state &= ~BTM_BLE_WL_ADV;
2768     }
2769     return rt;
2770 }
2771 /*******************************************************************************
2772 **
2773 ** Function         btm_ble_stop_adv
2774 **
2775 ** Description      Stop the BLE advertising.
2776 **
2777 ** Returns          void
2778 **
2779 *******************************************************************************/
2780 tBTM_STATUS btm_ble_stop_adv(void)
2781 {
2782     tBTM_BLE_INQ_CB *p_cb = &btm_cb.ble_ctr_cb.inq_var;
2783     tBTM_STATUS rt = BTM_SUCCESS;
2784
2785     if (p_cb->adv_mode == BTM_BLE_ADV_ENABLE)
2786     {
2787         if (btsnd_hcic_ble_set_adv_enable (BTM_BLE_ADV_DISABLE))
2788         {
2789             p_cb->fast_adv_on = FALSE;
2790             p_cb->adv_mode = BTM_BLE_ADV_DISABLE;
2791             btm_cb.ble_ctr_cb.wl_state &= ~BTM_BLE_WL_ADV;
2792
2793             /* clear all adv states */
2794             btm_ble_clear_topology_mask (BTM_BLE_STATE_ALL_ADV_MASK);
2795         }
2796         else
2797             rt = BTM_NO_RESOURCES;
2798     }
2799     return rt;
2800 }
2801
2802
2803 /*******************************************************************************
2804 **
2805 ** Function         btm_ble_set_topology_mask
2806 **
2807 ** Description      set BLE topology mask
2808 **
2809 ** Returns          TRUE is request is allowed, FALSE otherwise.
2810 **
2811 *******************************************************************************/
2812 BOOLEAN btm_ble_set_topology_mask(tBTM_BLE_STATE_MASK request_state_mask)
2813 {
2814     BOOLEAN rt = TRUE;
2815
2816     request_state_mask &= BTM_BLE_STATE_ALL_MASK;
2817
2818     btm_cb.ble_ctr_cb.cur_states |= request_state_mask;
2819
2820     return rt;
2821 }
2822 /*******************************************************************************
2823 **
2824 ** Function         btm_ble_clear_topology_mask
2825 **
2826 ** Description      Clear BLE topology bit mask
2827 **
2828 ** Returns          TRUE is request is allowed, FALSE otherwise.
2829 **
2830 *******************************************************************************/
2831 BOOLEAN btm_ble_clear_topology_mask (tBTM_BLE_STATE_MASK request_state_mask)
2832 {
2833     request_state_mask &= BTM_BLE_STATE_ALL_MASK;
2834
2835     btm_cb.ble_ctr_cb.cur_states &= ~request_state_mask;
2836
2837     return TRUE;
2838 }
2839 /*******************************************************************************
2840 **
2841 ** Function         btm_ble_update_mode_operation
2842 **
2843 ** Description      This function update the GAP role operation when a link status
2844 **                  is updated.
2845 **
2846 ** Returns          void
2847 **
2848 *******************************************************************************/
2849 void btm_ble_update_mode_operation(UINT8 link_role, BD_ADDR bd_addr, UINT8 status)
2850 {
2851     tACL_CONN   *pa = &btm_cb.acl_db[0];
2852     UINT16       xx;
2853     UINT16       mask = BTM_BLE_STATE_ALL_CONN_MASK;
2854
2855     UNUSED(bd_addr);
2856
2857     if (link_role == HCI_ROLE_SLAVE)
2858     {
2859         btm_cb.ble_ctr_cb.inq_var.adv_mode  = BTM_BLE_ADV_DISABLE;
2860         /* clear all adv states */
2861         mask |= BTM_BLE_STATE_ALL_ADV_MASK;
2862     }
2863
2864     btm_ble_clear_topology_mask (mask);
2865
2866     /* check the device link role maps */
2867     for (xx = 0; xx < MAX_L2CAP_LINKS; xx++, pa++)
2868     {
2869         if (pa->in_use && pa->transport == BT_TRANSPORT_LE)
2870         {
2871             if (pa->link_role == HCI_ROLE_MASTER)
2872                 btm_ble_set_topology_mask (BTM_BLE_STATE_MASTER_BIT);
2873             else
2874                 btm_ble_set_topology_mask (BTM_BLE_STATE_SLAVE_BIT);
2875         }
2876     }
2877
2878     if (btm_cb.cmn_ble_vsc_cb.adv_inst_max == 0 &&
2879         btm_cb.ble_ctr_cb.inq_var.connectable_mode == BTM_BLE_CONNECTABLE)
2880     {
2881         btm_ble_set_connectability ( btm_cb.ble_ctr_cb.inq_var.connectable_mode );
2882     }
2883
2884     if (btm_ble_get_conn_st() == BLE_CONN_IDLE && status != HCI_ERR_HOST_REJECT_RESOURCES)
2885     {
2886         if (!btm_send_pending_direct_conn())
2887         {
2888             btm_ble_resume_bg_conn();
2889         }
2890     }
2891 }
2892
2893 /*******************************************************************************
2894 **
2895 ** Function         btm_ble_start_slow_adv
2896 **
2897 ** Description      Restart adv with slow adv interval
2898 **
2899 ** Returns          void
2900 **
2901 *******************************************************************************/
2902 static void btm_ble_start_slow_adv (void)
2903 {
2904     tBTM_BLE_INQ_CB         *p_cb = &btm_cb.ble_ctr_cb.inq_var;
2905     BD_ADDR                 p_addr_ptr= {0};
2906
2907     if (p_cb->adv_mode == BTM_BLE_ADV_ENABLE)
2908     {
2909         btm_ble_stop_adv();
2910
2911         btsnd_hcic_ble_write_adv_params (BTM_BLE_GAP_ADV_SLOW_INT,
2912                                          BTM_BLE_GAP_ADV_SLOW_INT,
2913                                          p_cb->evt_type,
2914                                          p_cb->adv_addr_type,
2915                                          btm_cb.ble_ctr_cb.addr_mgnt_cb.own_addr_type,/* slow adv
2916                                          mode never goes into directed adv */
2917                                          p_addr_ptr,
2918                                          p_cb->adv_chnl_map,
2919                                          p_cb->afp);
2920
2921         btm_ble_start_adv();
2922     }
2923 }
2924 /*******************************************************************************
2925 **
2926 ** Function         btm_ble_timeout
2927 **
2928 ** Description      Called when BTM BLE inquiry timer expires
2929 **
2930 ** Returns          void
2931 **
2932 *******************************************************************************/
2933 void btm_ble_timeout(TIMER_LIST_ENT *p_tle)
2934 {
2935     BTM_TRACE_EVENT ("btm_ble_timeout");
2936
2937     switch (p_tle->event)
2938     {
2939         case BTU_TTYPE_BLE_OBSERVE:
2940             btm_ble_stop_observe();
2941             break;
2942
2943         case BTU_TTYPE_BLE_INQUIRY:
2944             btm_ble_stop_inquiry();
2945             break;
2946
2947         case BTU_TTYPE_BLE_GAP_LIM_DISC:
2948             /* lim_timeout expiried, limited discovery should exit now */
2949             btm_cb.btm_inq_vars.discoverable_mode &= ~BTM_BLE_LIMITED_DISCOVERABLE;
2950             btm_ble_set_adv_flag(btm_cb.btm_inq_vars.connectable_mode, btm_cb.btm_inq_vars.discoverable_mode);
2951             break;
2952
2953         case BTU_TTYPE_BLE_RANDOM_ADDR:
2954             if (btm_cb.ble_ctr_cb.addr_mgnt_cb.own_addr_type == BLE_ADDR_RANDOM)
2955             {
2956                 if (NULL == (void *)(p_tle->param))
2957                 {
2958                     /* refresh the random addr */
2959                     btm_gen_resolvable_private_addr((void *)btm_gen_resolve_paddr_low);
2960                 }
2961                 else
2962                 {
2963                     if (BTM_BleMaxMultiAdvInstanceCount() > 0)
2964                        btm_ble_multi_adv_configure_rpa((tBTM_BLE_MULTI_ADV_INST*)p_tle->param);
2965                 }
2966             }
2967             break;
2968
2969         case BTU_TTYPE_BLE_GAP_FAST_ADV:
2970             /* fast adv is completed, fall back to slow adv interval */
2971             btm_ble_start_slow_adv();
2972             break;
2973
2974         default:
2975             break;
2976
2977     }
2978 }
2979
2980
2981 /*******************************************************************************
2982 **
2983 ** Function         btm_ble_read_remote_features_complete
2984 **
2985 ** Description      This function is called when the command complete message
2986 **                  is received from the HCI for the read LE remote feature supported
2987 **                  complete event.
2988 **
2989 ** Returns          void
2990 **
2991 *******************************************************************************/
2992 void btm_ble_read_remote_features_complete(UINT8 *p)
2993 {
2994     tACL_CONN        *p_acl_cb = &btm_cb.acl_db[0];
2995     UINT16            handle;
2996     UINT8             status;
2997     int               xx;
2998
2999     BTM_TRACE_EVENT ("btm_ble_read_remote_features_complete ");
3000
3001     STREAM_TO_UINT8(status, p);
3002     /* if LE read remote feature failed, expect disconnect complete to be received */
3003     if (status == HCI_SUCCESS)
3004     {
3005         STREAM_TO_UINT16 (handle, p);
3006
3007         /* Look up the connection by handle and copy features */
3008         for (xx = 0; xx < MAX_L2CAP_LINKS; xx++, p_acl_cb++)
3009         {
3010             if ((p_acl_cb->in_use) && (p_acl_cb->hci_handle == handle))
3011             {
3012                 STREAM_TO_ARRAY(p_acl_cb->peer_le_features, p, BD_FEATURES_LEN);
3013                 /*notify link up here */
3014                 l2cble_notify_le_connection (p_acl_cb->remote_addr);
3015                 break;
3016             }
3017         }
3018     }
3019
3020 }
3021
3022 /*******************************************************************************
3023 **
3024 ** Function         btm_ble_write_adv_enable_complete
3025 **
3026 ** Description      This function process the write adv enable command complete.
3027 **
3028 ** Returns          void
3029 **
3030 *******************************************************************************/
3031 void btm_ble_write_adv_enable_complete(UINT8 * p)
3032 {
3033     tBTM_BLE_INQ_CB *p_cb = &btm_cb.ble_ctr_cb.inq_var;
3034
3035     /* if write adv enable/disbale not succeed */
3036     if (*p != HCI_SUCCESS)
3037     {
3038         /* toggle back the adv mode */
3039         p_cb->adv_mode = !p_cb->adv_mode;
3040     }
3041 }
3042
3043 /*******************************************************************************
3044 **
3045 ** Function         btm_ble_dir_adv_tout
3046 **
3047 ** Description      when directed adv time out
3048 **
3049 ** Returns          void
3050 **
3051 *******************************************************************************/
3052 void btm_ble_dir_adv_tout(void)
3053 {
3054     btm_cb.ble_ctr_cb.inq_var.adv_mode = BTM_BLE_ADV_DISABLE;
3055
3056     /* make device fall back into undirected adv mode by default */
3057     btm_cb.ble_ctr_cb.inq_var.directed_conn = FALSE;
3058 }
3059
3060 /*******************************************************************************
3061 **
3062 ** Function         btm_ble_init
3063 **
3064 ** Description      Initialize the control block variable values.
3065 **
3066 ** Returns          void
3067 **
3068 *******************************************************************************/
3069 void btm_ble_init (void)
3070 {
3071     tBTM_BLE_CB *p_cb = &btm_cb.ble_ctr_cb;
3072
3073     BTM_TRACE_EVENT ("btm_ble_init ");
3074
3075     memset(p_cb, 0, sizeof(tBTM_BLE_CB));
3076     memset(&(btm_cb.cmn_ble_vsc_cb), 0 , sizeof(tBTM_BLE_VSC_CB));
3077     btm_cb.cmn_ble_vsc_cb.values_read = FALSE;
3078     p_cb->cur_states       = 0;
3079
3080     p_cb->inq_var.adv_mode = BTM_BLE_ADV_DISABLE;
3081     p_cb->inq_var.scan_type = BTM_BLE_SCAN_MODE_NONE;
3082     p_cb->inq_var.adv_chnl_map = BTM_BLE_DEFAULT_ADV_CHNL_MAP;
3083     p_cb->inq_var.afp = BTM_BLE_DEFAULT_AFP;
3084     p_cb->inq_var.sfp = BTM_BLE_DEFAULT_SFP;
3085     p_cb->inq_var.connectable_mode = BTM_BLE_NON_CONNECTABLE;
3086     p_cb->inq_var.discoverable_mode = BTM_BLE_NON_DISCOVERABLE;
3087
3088     /* for background connection, reset connection params to be undefined */
3089     p_cb->scan_int = p_cb->scan_win = BTM_BLE_CONN_PARAM_UNDEF;
3090
3091     p_cb->inq_var.evt_type = BTM_BLE_NON_CONNECT_EVT;
3092
3093 #if BLE_VND_INCLUDED == FALSE
3094     btm_ble_vendor_init(BTM_CS_IRK_LIST_MAX);
3095     btm_ble_adv_filter_init();
3096 #endif
3097 }
3098
3099 /*******************************************************************************
3100 **
3101 ** Function         btm_ble_topology_check
3102 **
3103 ** Description      check to see requested state is supported. One state check at
3104 **                  a time is supported
3105 **
3106 ** Returns          TRUE is request is allowed, FALSE otherwise.
3107 **
3108 *******************************************************************************/
3109 BOOLEAN btm_ble_topology_check(tBTM_BLE_STATE_MASK request_state_mask)
3110 {
3111     BOOLEAN rt = FALSE;
3112
3113     UINT8   state_offset = 0;
3114     UINT16  cur_states = btm_cb.ble_ctr_cb.cur_states;
3115     UINT8   mask, offset;
3116     UINT8   request_state = 0;
3117
3118     /* check only one bit is set and within valid range */
3119     if (request_state_mask == BTM_BLE_STATE_INVALID ||
3120         request_state_mask > BTM_BLE_STATE_SCAN_ADV_BIT ||
3121         (request_state_mask & (request_state_mask -1 )) != 0)
3122     {
3123         BTM_TRACE_ERROR("illegal state requested: %d", request_state_mask);
3124         return rt;
3125     }
3126
3127     while (request_state_mask)
3128     {
3129         request_state_mask >>= 1;
3130         request_state ++;
3131     }
3132
3133     /* check if the requested state is supported or not */
3134     mask = btm_le_state_combo_tbl[0][request_state - 1][0];
3135     offset = btm_le_state_combo_tbl[0][request_state-1][1];
3136
3137     if (!BTM_LE_STATES_SUPPORTED(btm_cb.devcb.le_supported_states, mask, offset))
3138     {
3139         BTM_TRACE_ERROR("state requested not supported: %d", request_state);
3140         return rt;
3141     }
3142
3143     rt = TRUE;
3144     /* make sure currently active states are all supported in conjunction with the requested
3145        state. If the bit in table is not set, the combination is not supported */
3146     while (cur_states != 0)
3147     {
3148         if (cur_states & 0x01)
3149         {
3150             mask = btm_le_state_combo_tbl[request_state][state_offset][0];
3151             offset = btm_le_state_combo_tbl[request_state][state_offset][1];
3152
3153             if (mask != 0 && offset != 0)
3154             {
3155                 if (!BTM_LE_STATES_SUPPORTED(btm_cb.devcb.le_supported_states, mask, offset))
3156                 {
3157                     rt = FALSE;
3158                     break;
3159                 }
3160             }
3161         }
3162         cur_states >>= 1;
3163         state_offset ++;
3164     }
3165     return rt;
3166 }
3167
3168
3169 #endif  /* BLE_INCLUDED */