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 "stack/bt_types.h"
30 //#include "bt_utils.h"
31 #include "btm_int.h"
32 #include "stack/btm_ble_api.h"
33 #include "stack/btu.h"
34 #include "device/controller.h"
35 #include "stack/hcimsgs.h"
36 #include "stack/gap_api.h"
37 #include "hci/hci_layer.h"
38 #if BLE_INCLUDED == TRUE
39 #include "l2c_int.h"
40 
41 #include "stack/gattdefs.h"
42 #include "gatt_int.h"
43 
44 #include "btm_ble_int.h"
45 //#define LOG_TAG "bt_btm_ble"
46 //#include "osi/include/log.h"
47 #include "osi/osi.h"
48 #include "osi/mutex.h"
49 
50 #define BTM_BLE_NAME_SHORT                  0x01
51 #define BTM_BLE_NAME_CMPL                   0x02
52 
53 #define BTM_BLE_FILTER_TARGET_UNKNOWN       0xff
54 #define BTM_BLE_POLICY_UNKNOWN              0xff
55 
56 #define BTM_EXT_BLE_RMT_NAME_TIMEOUT        30
57 #define MIN_ADV_LENGTH                       2
58 #define BTM_VSC_CHIP_CAPABILITY_RSP_LEN_L_RELEASE 9
59 
60 #define BTM_BLE_GAP_ADV_RPT_BATCH_SIZE           (10)
61 
62 #if BTM_DYNAMIC_MEMORY == FALSE
63 static tBTM_BLE_VSC_CB cmn_ble_gap_vsc_cb;
64 #else
65 static tBTM_BLE_VSC_CB *cmn_ble_gap_vsc_cb_ptr;
66 #define cmn_ble_gap_vsc_cb (*cmn_ble_gap_vsc_cb_ptr)
67 #endif
68 
69 #if BLE_VND_INCLUDED == TRUE
70 static tBTM_BLE_CTRL_FEATURES_CBACK    *p_ctrl_le_feature_rd_cmpl_cback = NULL;
71 #endif
72 
73 tBTM_CallbackFunc conn_callback_func;
74 /*******************************************************************************
75 **  Local functions
76 *******************************************************************************/
77 static void btm_ble_update_adv_flag(UINT8 flag);
78 static void btm_ble_process_adv_pkt_cont(BD_ADDR bda, UINT8 addr_type, UINT8 evt_type, UINT8 *p);
79 UINT8 *btm_ble_build_adv_data(tBTM_BLE_AD_MASK *p_data_mask, UINT8 **p_dst,
80                               tBTM_BLE_ADV_DATA *p_data);
81 static UINT8 btm_set_conn_mode_adv_init_addr(tBTM_BLE_INQ_CB *p_cb,
82         BD_ADDR_PTR p_peer_addr_ptr,
83         tBLE_ADDR_TYPE *p_peer_addr_type,
84         tBLE_ADDR_TYPE *p_own_addr_type);
85 static void btm_ble_stop_observe(void);
86 static void btm_ble_stop_discover(void);
87 static void btm_adv_pkt_handler(void *arg);
88 uint32_t BTM_BleUpdateOwnType(uint8_t *own_bda_type, tBTM_START_ADV_CMPL_CBACK *cb);
89 
90 #define BTM_BLE_INQ_RESULT          0x01
91 #define BTM_BLE_OBS_RESULT          0x02
92 #define BTM_BLE_SEL_CONN_RESULT     0x04
93 #define BTM_BLE_DISCO_RESULT        0x08
94 
95 static bool is_ble50_inter = false;
96 
btm_ble_inter_set(bool extble_inter)97 void btm_ble_inter_set(bool extble_inter)
98 {
99     is_ble50_inter = extble_inter;
100 }
101 
btm_ble_inter_get(void)102 bool btm_ble_inter_get(void)
103 {
104     return is_ble50_inter;
105 }
106 
107 /* LE states combo bit to check */
108 const UINT8 btm_le_state_combo_tbl[BTM_BLE_STATE_MAX][BTM_BLE_STATE_MAX][2] = {
109     {/* single state support */
110         {HCI_SUPP_LE_STATES_CONN_ADV_MASK, HCI_SUPP_LE_STATES_CONN_ADV_OFF},  /* conn_adv */
111         {HCI_SUPP_LE_STATES_INIT_MASK, HCI_SUPP_LE_STATES_INIT_OFF}, /* init */
112         {HCI_SUPP_LE_STATES_INIT_MASK, HCI_SUPP_LE_STATES_INIT_OFF}, /* master */
113         {HCI_SUPP_LE_STATES_SLAVE_MASK, HCI_SUPP_LE_STATES_SLAVE_OFF}, /* slave */
114         {HCI_SUPP_LE_STATES_LO_DUTY_DIR_ADV_MASK, HCI_SUPP_LE_STATES_LO_DUTY_DIR_ADV_OFF}, /* lo du dir adv */
115         {HCI_SUPP_LE_STATES_HI_DUTY_DIR_ADV_MASK, HCI_SUPP_LE_STATES_HI_DUTY_DIR_ADV_OFF}, /* hi duty dir adv */
116         {HCI_SUPP_LE_STATES_NON_CONN_ADV_MASK, HCI_SUPP_LE_STATES_NON_CONN_ADV_OFF},  /* non connectable adv */
117         {HCI_SUPP_LE_STATES_PASS_SCAN_MASK, HCI_SUPP_LE_STATES_PASS_SCAN_OFF},   /*  passive scan */
118         {HCI_SUPP_LE_STATES_ACTIVE_SCAN_MASK, HCI_SUPP_LE_STATES_ACTIVE_SCAN_OFF},  /*   active scan */
119         {HCI_SUPP_LE_STATES_SCAN_ADV_MASK, HCI_SUPP_LE_STATESSCAN_ADV_OFF}   /* scanable adv */
120     },
121     {    /* conn_adv =0 */
122         {0, 0},                                                                           /* conn_adv */
123         {HCI_SUPP_LE_STATES_CONN_ADV_INIT_MASK, HCI_SUPP_LE_STATES_CONN_ADV_INIT_OFF},      /* init: 32 */
124         {HCI_SUPP_LE_STATES_CONN_ADV_MASTER_MASK, HCI_SUPP_LE_STATES_CONN_ADV_MASTER_OFF},  /* master: 35 */
125         {HCI_SUPP_LE_STATES_CONN_ADV_SLAVE_MASK, HCI_SUPP_LE_STATES_CONN_ADV_SLAVE_OFF}, /* slave: 38,*/
126         {0, 0},                                                                           /* lo du dir adv */
127         {0, 0},                                                                            /* hi duty dir adv */
128         {0, 0},  /* non connectable adv */
129         {HCI_SUPP_LE_STATES_CONN_ADV_PASS_SCAN_MASK, HCI_SUPP_LE_STATES_CONN_ADV_PASS_SCAN_OFF},   /*  passive scan */
130         {HCI_SUPP_LE_STATES_CONN_ADV_ACTIVE_SCAN_MASK, HCI_SUPP_LE_STATES_CONN_ADV_ACTIVE_SCAN_OFF},  /*   active scan */
131         {0, 0}   /* scanable adv */
132     },
133     {   /* init */
134         {HCI_SUPP_LE_STATES_CONN_ADV_INIT_MASK, HCI_SUPP_LE_STATES_CONN_ADV_INIT_OFF},      /* conn_adv: 32 */
135         {0, 0},                                                                             /* init */
136         {HCI_SUPP_LE_STATES_INIT_MASTER_MASK, HCI_SUPP_LE_STATES_INIT_MASTER_OFF},          /* master 28 */
137         {HCI_SUPP_LE_STATES_INIT_MASTER_SLAVE_MASK, HCI_SUPP_LE_STATES_INIT_MASTER_SLAVE_OFF}, /* slave 41 */
138         {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 */
139         {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 */
140         {HCI_SUPP_LE_STATES_NON_CONN_INIT_MASK, HCI_SUPP_LE_STATES_NON_CONN_INIT_OFF},  /*  non connectable adv */
141         {HCI_SUPP_LE_STATES_PASS_SCAN_INIT_MASK, HCI_SUPP_LE_STATES_PASS_SCAN_INIT_OFF},   /* passive scan */
142         {HCI_SUPP_LE_STATES_ACTIVE_SCAN_INIT_MASK, HCI_SUPP_LE_STATES_ACTIVE_SCAN_INIT_OFF},  /*  active scan */
143         {HCI_SUPP_LE_STATES_SCAN_ADV_INIT_MASK, HCI_SUPP_LE_STATES_SCAN_ADV_INIT_OFF}   /* scanable adv */
144 
145     },
146     {   /* master */
147         {HCI_SUPP_LE_STATES_CONN_ADV_MASTER_MASK, HCI_SUPP_LE_STATES_CONN_ADV_MASTER_OFF},  /* conn_adv: 35 */
148         {HCI_SUPP_LE_STATES_INIT_MASTER_MASK, HCI_SUPP_LE_STATES_INIT_MASTER_OFF},          /* init 28 */
149         {HCI_SUPP_LE_STATES_INIT_MASTER_MASK, HCI_SUPP_LE_STATES_INIT_MASTER_OFF},          /* master 28 */
150         {HCI_SUPP_LE_STATES_CONN_ADV_INIT_MASK, HCI_SUPP_LE_STATES_CONN_ADV_INIT_OFF},      /* slave: 32 */
151         {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 */
152         {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 */
153         {HCI_SUPP_LE_STATES_NON_CONN_ADV_MASTER_MASK, HCI_SUPP_LE_STATES_NON_CONN_ADV_MASTER_OFF},  /*  non connectable adv */
154         {HCI_SUPP_LE_STATES_PASS_SCAN_MASTER_MASK, HCI_SUPP_LE_STATES_PASS_SCAN_MASTER_OFF},   /*  passive scan */
155         {HCI_SUPP_LE_STATES_ACTIVE_SCAN_MASTER_MASK, HCI_SUPP_LE_STATES_ACTIVE_SCAN_MASTER_OFF},  /*   active scan */
156         {HCI_SUPP_LE_STATES_SCAN_ADV_MASTER_MASK, HCI_SUPP_LE_STATES_SCAN_ADV_MASTER_OFF}   /*  scanable adv */
157 
158     },
159     { /* slave */
160         {HCI_SUPP_LE_STATES_CONN_ADV_SLAVE_MASK, HCI_SUPP_LE_STATES_CONN_ADV_SLAVE_OFF}, /* conn_adv: 38,*/
161         {HCI_SUPP_LE_STATES_INIT_MASTER_SLAVE_MASK, HCI_SUPP_LE_STATES_INIT_MASTER_SLAVE_OFF}, /* init 41 */
162         {HCI_SUPP_LE_STATES_INIT_MASTER_SLAVE_MASK, HCI_SUPP_LE_STATES_INIT_MASTER_SLAVE_OFF}, /* master 41 */
163         {HCI_SUPP_LE_STATES_CONN_ADV_SLAVE_MASK, HCI_SUPP_LE_STATES_CONN_ADV_SLAVE_OFF},        /* slave: 38,*/
164         {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 */
165         {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 */
166         {HCI_SUPP_LE_STATES_NON_CONN_ADV_SLAVE_MASK, HCI_SUPP_LE_STATES_NON_CONN_ADV_SLAVE_OFF},  /* non connectable adv */
167         {HCI_SUPP_LE_STATES_PASS_SCAN_SLAVE_MASK, HCI_SUPP_LE_STATES_PASS_SCAN_SLAVE_OFF},   /* passive scan */
168         {HCI_SUPP_LE_STATES_ACTIVE_SCAN_SLAVE_MASK, HCI_SUPP_LE_STATES_ACTIVE_SCAN_SLAVE_OFF},  /*  active scan */
169         {HCI_SUPP_LE_STATES_SCAN_ADV_SLAVE_MASK, HCI_SUPP_LE_STATES_SCAN_ADV_SLAVE_OFF}   /* scanable adv */
170 
171     },
172     { /* lo duty cycle adv */
173         {0, 0}, /* conn_adv: 38,*/
174         {HCI_SUPP_LE_STATES_LO_DUTY_DIR_ADV_INIT_MASK, HCI_SUPP_LE_STATES_LO_DUTY_DIR_ADV_INIT_OFF} ,/* init 34 */
175         {HCI_SUPP_LE_STATES_LO_DUTY_DIR_ADV_MASTER_MASK, HCI_SUPP_LE_STATES_LO_DUTY_DIR_ADV_MASTER_OFF}, /* master 37 */
176         {HCI_SUPP_LE_STATES_LO_DUTY_DIR_ADV_SLAVE_MASK, HCI_SUPP_LE_STATES_LO_DUTY_DIR_ADV_SLAVE_OFF}, /* slave: 40 */
177         {0, 0},  /* lo duty cycle adv 40 */
178         {0, 0},   /* hi duty cycle adv 39 */
179         {0, 0},  /*  non connectable adv */
180         {HCI_SUPP_LE_STATES_LO_DUTY_DIR_ADV_PASS_SCAN_MASK, HCI_SUPP_LE_STATES_LO_DUTY_DIR_ADV_PASS_SCAN_OFF},   /* passive scan */
181         {HCI_SUPP_LE_STATES_LO_DUTY_DIR_ADV_ACTIVE_SCAN_MASK, HCI_SUPP_LE_STATES_LO_DUTY_DIR_ADV_ACTIVE_SCAN_OFF},  /* active scan */
182         {0, 0}   /*  scanable adv */
183     },
184     { /* hi duty cycle adv */
185         {0, 0}, /* conn_adv: 38,*/
186         {HCI_SUPP_LE_STATES_HI_DUTY_DIR_ADV_INIT_MASK, HCI_SUPP_LE_STATES_HI_DUTY_DIR_ADV_INIT_OFF}, /* init 33 */
187         {HCI_SUPP_LE_STATES_HI_DUTY_DIR_ADV_MASTER_MASK, HCI_SUPP_LE_STATES_HI_DUTY_DIR_ADV_MASTER_OFF}, /* master 36 */
188         {HCI_SUPP_LE_STATES_HI_DUTY_DIR_ADV_SLAVE_MASK, HCI_SUPP_LE_STATES_HI_DUTY_DIR_ADV_SLAVE_OFF},   /* slave: 39*/
189         {0, 0},  /* lo duty cycle adv 40 */
190         {0, 0},   /* hi duty cycle adv 39 */
191         {0, 0},  /* non connectable adv */
192         {HCI_SUPP_LE_STATES_HI_DUTY_DIR_ADV_PASS_SCAN_MASK, HCI_SUPP_LE_STATES_HI_DUTY_DIR_ADV_PASS_SCAN_OFF},   /* passive scan */
193         {HCI_SUPP_LE_STATES_HI_DUTY_DIR_ADV_ACTIVE_SCAN_MASK, HCI_SUPP_LE_STATES_HI_DUTY_DIR_ADV_ACTIVE_SCAN_OFF},  /* active scan */
194         {0, 0}   /* scanable adv */
195     },
196     { /* non connectable adv */
197         {0, 0}, /* conn_adv: */
198         {HCI_SUPP_LE_STATES_NON_CONN_INIT_MASK, HCI_SUPP_LE_STATES_NON_CONN_INIT_OFF}, /* init  */
199         {HCI_SUPP_LE_STATES_NON_CONN_ADV_MASTER_MASK, HCI_SUPP_LE_STATES_NON_CONN_ADV_MASTER_OFF}, /* master  */
200         {HCI_SUPP_LE_STATES_NON_CONN_ADV_SLAVE_MASK, HCI_SUPP_LE_STATES_NON_CONN_ADV_SLAVE_OFF},   /* slave: */
201         {0, 0},  /* lo duty cycle adv */
202         {0, 0},   /* hi duty cycle adv */
203         {0, 0},  /* non connectable adv */
204         {HCI_SUPP_LE_STATES_NON_CONN_ADV_PASS_SCAN_MASK, HCI_SUPP_LE_STATES_NON_CONN_ADV_PASS_SCAN_OFF},   /* passive scan */
205         {HCI_SUPP_LE_STATES_NON_CONN_ADV_ACTIVE_SCAN_MASK, HCI_SUPP_LE_STATES_NON_CONN_ADV_ACTIVE_SCAN_OFF},  /*  active scan */
206         {0, 0}   /* scanable adv */
207     },
208     { /* passive scan */
209         {HCI_SUPP_LE_STATES_CONN_ADV_PASS_SCAN_MASK, HCI_SUPP_LE_STATES_CONN_ADV_PASS_SCAN_OFF}, /* conn_adv: */
210         {HCI_SUPP_LE_STATES_PASS_SCAN_INIT_MASK, HCI_SUPP_LE_STATES_PASS_SCAN_INIT_OFF}, /* init  */
211         {HCI_SUPP_LE_STATES_PASS_SCAN_MASTER_MASK, HCI_SUPP_LE_STATES_PASS_SCAN_MASTER_OFF}, /* master  */
212         {HCI_SUPP_LE_STATES_PASS_SCAN_SLAVE_MASK, HCI_SUPP_LE_STATES_PASS_SCAN_SLAVE_OFF},   /* slave: */
213         {0, 0},  /* lo duty cycle adv */
214         {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 */
215         {HCI_SUPP_LE_STATES_NON_CONN_ADV_PASS_SCAN_MASK, HCI_SUPP_LE_STATES_NON_CONN_ADV_PASS_SCAN_OFF},  /*  non connectable adv */
216         {0, 0},   /* passive scan */
217         {0, 0},  /* active scan */
218         {HCI_SUPP_LE_STATES_SCAN_ADV_PASS_SCAN_MASK, HCI_SUPP_LE_STATES_SCAN_ADV_PASS_SCAN_OFF}   /* scanable adv */
219     },
220     { /* active scan */
221         {HCI_SUPP_LE_STATES_CONN_ADV_ACTIVE_SCAN_MASK, HCI_SUPP_LE_STATES_CONN_ADV_ACTIVE_SCAN_OFF}, /* conn_adv: */
222         {HCI_SUPP_LE_STATES_ACTIVE_SCAN_INIT_MASK, HCI_SUPP_LE_STATES_ACTIVE_SCAN_INIT_OFF}, /* init  */
223         {HCI_SUPP_LE_STATES_ACTIVE_SCAN_MASTER_MASK, HCI_SUPP_LE_STATES_ACTIVE_SCAN_MASTER_OFF}, /* master  */
224         {HCI_SUPP_LE_STATES_ACTIVE_SCAN_SLAVE_MASK, HCI_SUPP_LE_STATES_ACTIVE_SCAN_SLAVE_OFF},   /* slave: */
225         {0, 0},  /* lo duty cycle adv */
226         {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 */
227         {HCI_SUPP_LE_STATES_NON_CONN_ADV_ACTIVE_SCAN_MASK, HCI_SUPP_LE_STATES_NON_CONN_ADV_ACTIVE_SCAN_OFF},  /*  non connectable adv */
228         {0, 0},   /* TODO: passive scan */
229         {0, 0},  /* TODO:  active scan */
230         {HCI_SUPP_LE_STATES_SCAN_ADV_ACTIVE_SCAN_MASK, HCI_SUPP_LE_STATES_SCAN_ADV_ACTIVE_SCAN_OFF}   /*  scanable adv */
231     },
232     { /* scanable adv */
233         {0, 0}, /* conn_adv: */
234         {HCI_SUPP_LE_STATES_SCAN_ADV_INIT_MASK, HCI_SUPP_LE_STATES_SCAN_ADV_INIT_OFF}, /* init  */
235         {HCI_SUPP_LE_STATES_SCAN_ADV_MASTER_MASK, HCI_SUPP_LE_STATES_SCAN_ADV_MASTER_OFF}, /* master  */
236         {HCI_SUPP_LE_STATES_SCAN_ADV_SLAVE_MASK, HCI_SUPP_LE_STATES_SCAN_ADV_SLAVE_OFF},   /* slave: */
237         {0, 0},  /* lo duty cycle adv */
238         {0, 0},   /* hi duty cycle adv */
239         {0, 0},  /* non connectable adv */
240         {HCI_SUPP_LE_STATES_SCAN_ADV_PASS_SCAN_MASK, HCI_SUPP_LE_STATES_SCAN_ADV_PASS_SCAN_OFF},   /*  passive scan */
241         {HCI_SUPP_LE_STATES_SCAN_ADV_ACTIVE_SCAN_MASK, HCI_SUPP_LE_STATES_SCAN_ADV_ACTIVE_SCAN_OFF},  /*  active scan */
242         {0, 0}   /* scanable adv */
243     }
244 
245 };
246 /* check LE combo state supported */
247 #define BTM_LE_STATES_SUPPORTED(x, y, z)      ((x)[(z)] & (y))
248 
249 static osi_mutex_t adv_enable_lock;
250 static osi_mutex_t adv_data_lock;
251 static osi_mutex_t adv_param_lock;
252 static osi_mutex_t scan_enable_lock;
253 static osi_mutex_t scan_param_lock;
254 osi_sem_t adv_enable_sem;
255 osi_sem_t adv_data_sem;
256 osi_sem_t adv_param_sem;
257 osi_sem_t scan_enable_sem;
258 osi_sem_t scan_param_sem;
259 uint8_t adv_enable_status  = 0;
260 uint8_t adv_data_status    = 0;
261 uint8_t adv_param_status   = 0;
262 uint8_t scan_enable_status = 0;
263 uint8_t scan_param_status  = 0;
264 
btm_ble_lock_init(void)265 void btm_ble_lock_init(void)
266 {
267     osi_mutex_new(&adv_enable_lock);
268     osi_mutex_new(&adv_data_lock);
269     osi_mutex_new(&adv_param_lock);
270     osi_mutex_new(&scan_enable_lock);
271     osi_mutex_new(&scan_param_lock);
272 }
273 
btm_ble_lock_free(void)274 void btm_ble_lock_free(void)
275 {
276     osi_mutex_free(&adv_enable_lock);
277     osi_mutex_free(&adv_data_lock);
278     osi_mutex_free(&adv_param_lock);
279     osi_mutex_free(&scan_enable_lock);
280     osi_mutex_free(&scan_param_lock);
281 }
282 
btm_ble_sem_init(void)283 void btm_ble_sem_init(void)
284 {
285     osi_sem_new(&adv_enable_sem, 1, 0);
286     osi_sem_new(&adv_data_sem, 1, 0);
287     osi_sem_new(&adv_param_sem, 1, 0);
288     osi_sem_new(&scan_enable_sem, 1, 0);
289     osi_sem_new(&scan_param_sem, 1, 0);
290 }
291 
btm_ble_sem_free(void)292 void btm_ble_sem_free(void)
293 {
294     osi_sem_free(&adv_enable_sem);
295     osi_sem_free(&adv_data_sem);
296     osi_sem_free(&adv_param_sem);
297     osi_sem_free(&scan_enable_sem);
298     osi_sem_free(&scan_param_sem);
299 }
300 
301 /*******************************************************************************
302 **
303 ** Function         BTM_BleRegiseterConnParamCallback
304 **
305 ** Description      register connection parameters update callback func
306 **
307 ** Returns          void
308 **
309 *******************************************************************************/
BTM_BleRegiseterConnParamCallback(tBTM_UPDATE_CONN_PARAM_CBACK * update_conn_param_cb)310 void BTM_BleRegiseterConnParamCallback(tBTM_UPDATE_CONN_PARAM_CBACK *update_conn_param_cb)
311 {
312     conn_callback_func.update_conn_param_cb = update_conn_param_cb;
313 }
314 
315 /*******************************************************************************
316 **
317 ** Function         BTM_BleRegiseterPktLengthChangeCallback
318 **
319 ** Description      Registers a callback function for packet length changes.
320 **
321 ** Returns          void
322 **
323 *******************************************************************************/
BTM_BleRegiseterPktLengthChangeCallback(tBTM_SET_PKT_DATA_LENGTH_CBACK * ptk_len_chane_cb)324 void BTM_BleRegiseterPktLengthChangeCallback(tBTM_SET_PKT_DATA_LENGTH_CBACK *ptk_len_chane_cb)
325 {
326     conn_callback_func.set_pkt_data_length_cb = ptk_len_chane_cb;
327 }
328 
329 /*******************************************************************************
330 **
331 ** Function         BTM_BleUpdateAdvWhitelist
332 **
333 ** Description      Add or remove device from advertising white list
334 **
335 ** Returns          void
336 **
337 *******************************************************************************/
BTM_BleUpdateAdvWhitelist(BOOLEAN add_remove,BD_ADDR remote_bda,tBLE_ADDR_TYPE addr_type,tBTM_UPDATE_WHITELIST_CBACK * update_wl_cb)338 BOOLEAN BTM_BleUpdateAdvWhitelist(BOOLEAN add_remove, BD_ADDR remote_bda, tBLE_ADDR_TYPE addr_type, tBTM_UPDATE_WHITELIST_CBACK *update_wl_cb)
339 {
340     return btm_update_dev_to_white_list(add_remove, remote_bda, addr_type, update_wl_cb);
341 }
342 
343 /*******************************************************************************
344 **
345 ** Function         BTM_BleUpdateAdvWhitelist
346 **
347 ** Description      Add or remove device from advertising white list
348 **
349 ** Returns          void
350 **
351 *******************************************************************************/
BTM_BleClearWhitelist(tBTM_UPDATE_WHITELIST_CBACK * update_wl_cb)352 void BTM_BleClearWhitelist(tBTM_UPDATE_WHITELIST_CBACK *update_wl_cb)
353 {
354    btm_ble_clear_white_list(update_wl_cb);
355 }
356 
357 /*******************************************************************************
358 **
359 ** Function         BTM_BleUpdateAdvFilterPolicy
360 **
361 ** Description      This function update the filter policy of advertiser.
362 **
363 ** Parameter        adv_policy: advertising filter policy
364 **
365 ** Return           void
366 *******************************************************************************/
BTM_BleUpdateAdvFilterPolicy(tBTM_BLE_AFP adv_policy)367 void BTM_BleUpdateAdvFilterPolicy(tBTM_BLE_AFP adv_policy)
368 {
369     tBTM_BLE_INQ_CB *p_cb = &btm_cb.ble_ctr_cb.inq_var;
370     tBLE_ADDR_TYPE   init_addr_type = BLE_ADDR_PUBLIC;
371     BD_ADDR          p_addr_ptr = {0};
372     UINT8            adv_mode = p_cb->adv_mode;
373 
374     BTM_TRACE_EVENT ("BTM_BleUpdateAdvFilterPolicy\n");
375 
376     if (!controller_get_interface()->supports_ble()) {
377         return;
378     }
379 
380     if (p_cb->afp != adv_policy) {
381         p_cb->afp = adv_policy;
382 
383         /* if adv active, stop and restart */
384         btm_ble_stop_adv ();
385 
386         if (p_cb->connectable_mode & BTM_BLE_CONNECTABLE) {
387             p_cb->evt_type = btm_set_conn_mode_adv_init_addr(p_cb, p_addr_ptr, &init_addr_type,
388                              &p_cb->adv_addr_type);
389         }
390 
391         uint8_t null_addr[BD_ADDR_LEN] = {0};
392         if ((p_cb->evt_type == 0x01 || p_cb->evt_type == 0x04) && memcmp(p_addr_ptr, null_addr, BD_ADDR_LEN) == 0) {
393             /* directed advertising */
394             return;
395         }
396 
397         btsnd_hcic_ble_write_adv_params ((UINT16)(p_cb->adv_interval_min ? p_cb->adv_interval_min :
398                                          BTM_BLE_GAP_ADV_SLOW_INT),
399                                          (UINT16)(p_cb->adv_interval_max ? p_cb->adv_interval_max :
400                                                  BTM_BLE_GAP_ADV_SLOW_INT),
401                                          p_cb->evt_type,
402                                          p_cb->adv_addr_type,
403                                          init_addr_type,
404                                          p_addr_ptr,
405                                          p_cb->adv_chnl_map,
406                                          p_cb->afp);
407 
408         if (adv_mode == BTM_BLE_ADV_ENABLE) {
409             btm_ble_start_adv ();
410         }
411 
412     }
413 }
414 
415 /*******************************************************************************
416 **
417 ** Function         btm_ble_send_extended_scan_params
418 **
419 ** Description      This function sends out the extended scan parameters command to the controller
420 **
421 ** Parameters       scan_type - Scan type
422 **                  scan_int - Scan interval
423 **                  scan_win - Scan window
424 **                  addr_type_own - Own address type
425 **                  scan_filter_policy - Scan filter policy
426 **
427 ** Returns          TRUE or FALSE
428 **
429 *******************************************************************************/
btm_ble_send_extended_scan_params(UINT8 scan_type,UINT32 scan_int,UINT32 scan_win,UINT8 addr_type_own,UINT8 scan_filter_policy)430 BOOLEAN btm_ble_send_extended_scan_params(UINT8 scan_type, UINT32 scan_int,
431         UINT32 scan_win, UINT8 addr_type_own,
432         UINT8 scan_filter_policy)
433 {
434     UINT8 scan_param[HCIC_PARAM_SIZE_BLE_WRITE_EXTENDED_SCAN_PARAM];
435     UINT8 *pp_scan = scan_param;
436 
437     memset(scan_param, 0, HCIC_PARAM_SIZE_BLE_WRITE_EXTENDED_SCAN_PARAM);
438 
439     UINT8_TO_STREAM(pp_scan, scan_type);
440     UINT32_TO_STREAM(pp_scan, scan_int);
441     UINT32_TO_STREAM(pp_scan, scan_win);
442     UINT8_TO_STREAM(pp_scan, addr_type_own);
443     UINT8_TO_STREAM(pp_scan, scan_filter_policy);
444 
445     BTM_TRACE_DEBUG("%s, %d, %d", __func__, scan_int, scan_win);
446     if ((BTM_VendorSpecificCommand(HCI_BLE_EXTENDED_SCAN_PARAMS_OCF,
447                                    HCIC_PARAM_SIZE_BLE_WRITE_EXTENDED_SCAN_PARAM, scan_param, NULL)) != BTM_SUCCESS) {
448         BTM_TRACE_ERROR("%s error sending extended scan parameters", __func__);
449         return FALSE;
450     }
451     return TRUE;
452 }
453 
454 /*******************************************************************************
455 **
456 ** Function         BTM_BleObserve
457 **
458 ** Description      This procedure keep the device listening for advertising
459 **                  events from a broadcast device.
460 **
461 ** Parameters       start: start or stop observe.
462 **                  white_list: use white list in observer mode or not.
463 **
464 ** Returns          void
465 **
466 *******************************************************************************/
BTM_BleObserve(BOOLEAN start,UINT32 duration,tBTM_INQ_RESULTS_CB * p_results_cb,tBTM_CMPL_CB * p_cmpl_cb)467 tBTM_STATUS BTM_BleObserve(BOOLEAN start, UINT32 duration,
468                            tBTM_INQ_RESULTS_CB *p_results_cb, tBTM_CMPL_CB *p_cmpl_cb)
469 {
470     tBTM_BLE_INQ_CB *p_inq = &btm_cb.ble_ctr_cb.inq_var;
471     tBTM_STATUS status = BTM_WRONG_MODE;
472 
473     UINT32 scan_interval = !p_inq->scan_interval ? BTM_BLE_GAP_DISC_SCAN_INT : p_inq->scan_interval;
474     UINT32 scan_window = !p_inq->scan_window ? BTM_BLE_GAP_DISC_SCAN_WIN : p_inq->scan_window;
475 
476     BTM_TRACE_EVENT ("%s : scan_type:%d, %d, %d\n", __func__, btm_cb.btm_inq_vars.scan_type,
477                      p_inq->scan_interval, p_inq->scan_window);
478 
479     if (!controller_get_interface()->supports_ble()) {
480         return BTM_ILLEGAL_VALUE;
481     }
482 
483     if (start) {
484         /* shared inquiry database, do not allow observe if any inquiry is active */
485         if (BTM_BLE_IS_OBS_ACTIVE(btm_cb.ble_ctr_cb.scan_activity)) {
486             BTM_TRACE_ERROR("%s Observe Already Active", __func__);
487             return status;
488         }
489 
490         btm_cb.ble_ctr_cb.p_obs_results_cb = p_results_cb;
491         btm_cb.ble_ctr_cb.p_obs_cmpl_cb = p_cmpl_cb;
492         status = BTM_CMD_STARTED;
493 
494         /* scan is not started */
495         if (!BTM_BLE_IS_SCAN_ACTIVE(btm_cb.ble_ctr_cb.scan_activity)) {
496             /* allow config of scan type */
497             p_inq->scan_type = (p_inq->scan_type == BTM_BLE_SCAN_MODE_NONE) ?
498                                BTM_BLE_SCAN_MODE_ACTI : p_inq->scan_type;
499             /* assume observe always not using white list */
500 #if (defined BLE_PRIVACY_SPT && BLE_PRIVACY_SPT == TRUE)
501             /* enable resolving list */
502             //btm_ble_enable_resolving_list_for_platform(BTM_BLE_RL_SCAN);
503 #endif
504 
505             if (cmn_ble_gap_vsc_cb.extended_scan_support == 0) {
506                 btsnd_hcic_ble_set_scan_params(p_inq->scan_type, (UINT16)scan_interval,
507                                                (UINT16)scan_window,
508                                                btm_cb.ble_ctr_cb.addr_mgnt_cb.own_addr_type,
509                                                BTM_BLE_DEFAULT_SFP);
510             } else {
511                 btm_ble_send_extended_scan_params(p_inq->scan_type, scan_interval, scan_window,
512                                                   btm_cb.ble_ctr_cb.addr_mgnt_cb.own_addr_type,
513                                                   BTM_BLE_DEFAULT_SFP);
514             }
515 
516             status = btm_ble_start_scan();
517         }
518 
519         if (status == BTM_CMD_STARTED) {
520             btm_cb.ble_ctr_cb.scan_activity |= BTM_LE_OBSERVE_ACTIVE;
521             if (duration != 0)
522                 /* start observer timer */
523             {
524                 btu_start_timer (&btm_cb.ble_ctr_cb.obs_timer_ent, BTU_TTYPE_BLE_OBSERVE, duration);
525             }
526         }
527     } else if (BTM_BLE_IS_OBS_ACTIVE(btm_cb.ble_ctr_cb.scan_activity)) {
528         status = BTM_CMD_STARTED;
529         btm_ble_stop_observe();
530     } else {
531         BTM_TRACE_ERROR("%s Observe not active\n", __func__);
532     }
533 
534     return status;
535 
536 }
537 
538 /*******************************************************************************
539 **
540 ** Function         BTM_BleScan
541 **
542 ** Description      This procedure keep the device listening for advertising
543 **                  events from a broadcast device.
544 **
545 ** Parameters       start: start or stop scan.
546 **                  white_list: use white list in observer mode or not.
547 **
548 ** Returns          void
549 **
550 *******************************************************************************/
BTM_BleScan(BOOLEAN start,UINT32 duration,tBTM_INQ_RESULTS_CB * p_results_cb,tBTM_CMPL_CB * p_cmpl_cb,tBTM_INQ_DIS_CB * p_discard_cb)551 tBTM_STATUS BTM_BleScan(BOOLEAN start, UINT32 duration,
552                            tBTM_INQ_RESULTS_CB *p_results_cb, tBTM_CMPL_CB *p_cmpl_cb, tBTM_INQ_DIS_CB *p_discard_cb)
553 {
554     tBTM_BLE_INQ_CB *p_inq = &btm_cb.ble_ctr_cb.inq_var;
555     tBTM_STATUS status = BTM_WRONG_MODE;
556 
557     if (!controller_get_interface()->supports_ble()) {
558         return BTM_ILLEGAL_VALUE;
559     }
560 
561     if (start) {
562         /* shared inquiry database, do not allow scan if any inquiry is active */
563         if (BTM_BLE_IS_DISCO_ACTIVE(btm_cb.ble_ctr_cb.scan_activity)) {
564             BTM_TRACE_ERROR("%s scan already active", __func__);
565             return status;
566         }
567 
568         btm_cb.ble_ctr_cb.p_scan_results_cb = p_results_cb;
569         btm_cb.ble_ctr_cb.p_scan_cmpl_cb = p_cmpl_cb;
570         btm_cb.ble_ctr_cb.p_obs_discard_cb = p_discard_cb;
571         status = BTM_CMD_STARTED;
572 
573         /* scan is not started */
574         if (!BTM_BLE_IS_SCAN_ACTIVE(btm_cb.ble_ctr_cb.scan_activity)) {
575             /* assume observe always not using white list */
576 #if (defined BLE_PRIVACY_SPT && BLE_PRIVACY_SPT == TRUE)
577             /* enable resolving list */
578             //btm_ble_enable_resolving_list_for_platform(BTM_BLE_RL_SCAN);
579 #endif
580             // if not set scan params, set default scan params
581             if (!p_inq->scan_params_set) {
582                 /* allow config of scan type */
583                 p_inq->scan_type = BTM_BLE_SCAN_MODE_ACTI;
584                 p_inq->scan_interval = BTM_BLE_GAP_DISC_SCAN_INT;
585                 p_inq->scan_window = BTM_BLE_GAP_DISC_SCAN_WIN;
586                 p_inq->sfp = BTM_BLE_DEFAULT_SFP;
587                 p_inq->scan_params_set = TRUE;
588                 p_inq->scan_duplicate_filter = BTM_BLE_DUPLICATE_DISABLE;
589                 btsnd_hcic_ble_set_scan_params(p_inq->scan_type, p_inq->scan_interval,
590                                                p_inq->scan_window,
591                                                btm_cb.ble_ctr_cb.addr_mgnt_cb.own_addr_type,
592                                                p_inq->sfp);
593             }
594             status = btm_ble_start_scan();
595         }
596 
597         if (status == BTM_CMD_STARTED) {
598             btm_cb.ble_ctr_cb.scan_activity |= BTM_LE_DISCOVER_ACTIVE;
599             if (duration != 0)
600                 /* start observer timer */
601             {
602                 btu_start_timer (&btm_cb.ble_ctr_cb.scan_timer_ent, BTU_TTYPE_BLE_SCAN, duration);
603             }
604         }
605     } else if (BTM_BLE_IS_DISCO_ACTIVE(btm_cb.ble_ctr_cb.scan_activity)) {
606         status = BTM_CMD_STARTED;
607         btm_ble_stop_discover();
608     } else {
609         BTM_TRACE_ERROR("%s scan not active\n", __func__);
610     }
611 
612     return status;
613 
614 }
615 
616 /*******************************************************************************
617 **
618 ** Function         BTM_BleBroadcast
619 **
620 ** Description      This function is to start or stop broadcasting.
621 **
622 ** Parameters       start: start or stop broadcasting.
623 **
624 ** Returns          status.
625 **
626 *******************************************************************************/
BTM_BleBroadcast(BOOLEAN start,tBTM_START_STOP_ADV_CMPL_CBACK * p_stop_adv_cback)627 tBTM_STATUS BTM_BleBroadcast(BOOLEAN start, tBTM_START_STOP_ADV_CMPL_CBACK  *p_stop_adv_cback)
628 {
629     tBTM_STATUS status = BTM_NO_RESOURCES;
630     tBTM_LE_RANDOM_CB *p_addr_cb = &btm_cb.ble_ctr_cb.addr_mgnt_cb;
631     tBTM_BLE_INQ_CB *p_cb = &btm_cb.ble_ctr_cb.inq_var;
632     UINT8 evt_type = p_cb->scan_rsp ? BTM_BLE_DISCOVER_EVT : BTM_BLE_NON_CONNECT_EVT;
633 
634     if (!controller_get_interface()->supports_ble()) {
635         return BTM_ILLEGAL_VALUE;
636     }
637 
638 #ifdef  BTM_BLE_PC_ADV_TEST_MODE
639     if (BTM_BLE_PC_ADV_TEST_MODE) {
640         evt_type = p_cb->scan_rsp ? BTM_BLE_CONNECT_EVT : BTM_BLE_NON_CONNECT_EVT;
641     }
642 #endif
643 
644     if (start) {
645         /* update adv params */
646         if (!btsnd_hcic_ble_write_adv_params ((UINT16)(p_cb->adv_interval_min ? p_cb->adv_interval_min :
647                                               BTM_BLE_GAP_ADV_INT),
648                                               (UINT16)(p_cb->adv_interval_max ? p_cb->adv_interval_max :
649                                                       BTM_BLE_GAP_ADV_INT),
650                                               evt_type,
651                                               p_addr_cb->own_addr_type,
652                                               p_cb->direct_bda.type,
653                                               p_cb->direct_bda.bda,
654                                               p_cb->adv_chnl_map,
655                                               p_cb->afp))
656 
657         {
658             status = BTM_NO_RESOURCES;
659         } else {
660             p_cb->evt_type = evt_type;
661         }
662 
663         status = btm_ble_start_adv ();
664     } else {
665         //save the stop adv callback to the BTM env.
666         p_cb->p_stop_adv_cb = p_stop_adv_cback;
667         status = btm_ble_stop_adv();
668 #if BLE_PRIVACY_SPT == TRUE
669         btm_ble_disable_resolving_list(BTM_BLE_RL_ADV, TRUE);
670 #endif
671     }
672     return status;
673 }
674 
675 #if BLE_VND_INCLUDED == TRUE
676 /*******************************************************************************
677 **
678 ** Function         btm_vsc_brcm_features_complete
679 **
680 ** Description      Command Complete callback for HCI_BLE_VENDOR_CAP_OCF
681 **
682 ** Returns          void
683 **
684 *******************************************************************************/
btm_ble_vendor_capability_vsc_cmpl_cback(tBTM_VSC_CMPL * p_vcs_cplt_params)685 static void btm_ble_vendor_capability_vsc_cmpl_cback (tBTM_VSC_CMPL *p_vcs_cplt_params)
686 {
687     UINT8 status = 0xFF;
688     UINT8 *p;
689 
690     BTM_TRACE_DEBUG("%s", __func__);
691 
692     /* Check status of command complete event */
693     if ((p_vcs_cplt_params->opcode == HCI_BLE_VENDOR_CAP_OCF) &&
694             (p_vcs_cplt_params->param_len > 0)) {
695         p = p_vcs_cplt_params->p_param_buf;
696         STREAM_TO_UINT8(status, p);
697     }
698 
699     if (status == HCI_SUCCESS) {
700         STREAM_TO_UINT8(btm_cb.cmn_ble_vsc_cb.adv_inst_max, p);
701         STREAM_TO_UINT8(btm_cb.cmn_ble_vsc_cb.rpa_offloading, p);
702         STREAM_TO_UINT16(btm_cb.cmn_ble_vsc_cb.tot_scan_results_strg, p);
703         STREAM_TO_UINT8(btm_cb.cmn_ble_vsc_cb.max_irk_list_sz, p);
704         STREAM_TO_UINT8(btm_cb.cmn_ble_vsc_cb.filter_support, p);
705         STREAM_TO_UINT8(btm_cb.cmn_ble_vsc_cb.max_filter, p);
706         STREAM_TO_UINT8(btm_cb.cmn_ble_vsc_cb.energy_support, p);
707 
708         if (p_vcs_cplt_params->param_len > BTM_VSC_CHIP_CAPABILITY_RSP_LEN_L_RELEASE) {
709             STREAM_TO_UINT16(btm_cb.cmn_ble_vsc_cb.version_supported, p);
710         } else {
711             btm_cb.cmn_ble_vsc_cb.version_supported = BTM_VSC_CHIP_CAPABILITY_L_VERSION;
712         }
713 
714         if (btm_cb.cmn_ble_vsc_cb.version_supported >= BTM_VSC_CHIP_CAPABILITY_M_VERSION) {
715             STREAM_TO_UINT16(btm_cb.cmn_ble_vsc_cb.total_trackable_advertisers, p);
716             STREAM_TO_UINT16(btm_cb.cmn_ble_vsc_cb.extended_scan_support, p);
717             STREAM_TO_UINT16(btm_cb.cmn_ble_vsc_cb.debug_logging_supported, p);
718         }
719         btm_cb.cmn_ble_vsc_cb.values_read = TRUE;
720     }
721 
722     BTM_TRACE_DEBUG("%s: stat=%d, irk=%d, ADV ins:%d, rpa=%d, ener=%d, ext_scan=%d",
723                     __func__, status, btm_cb.cmn_ble_vsc_cb.max_irk_list_sz,
724                     btm_cb.cmn_ble_vsc_cb.adv_inst_max, btm_cb.cmn_ble_vsc_cb.rpa_offloading,
725                     btm_cb.cmn_ble_vsc_cb.energy_support, btm_cb.cmn_ble_vsc_cb.extended_scan_support);
726 
727     if (BTM_BleMaxMultiAdvInstanceCount() > 0) {
728         btm_ble_multi_adv_init();
729     }
730 
731     if (btm_cb.cmn_ble_vsc_cb.max_filter > 0) {
732         btm_ble_adv_filter_init();
733     }
734 
735 #if (defined BLE_PRIVACY_SPT && BLE_PRIVACY_SPT == TRUE)
736     /* VS capability included and non-4.2 device */
737     if (btm_cb.cmn_ble_vsc_cb.max_irk_list_sz > 0 &&
738             controller_get_interface()->get_ble_resolving_list_max_size() == 0) {
739         btm_ble_resolving_list_init(btm_cb.cmn_ble_vsc_cb.max_irk_list_sz);
740     }
741 #endif
742 
743     if (btm_cb.cmn_ble_vsc_cb.tot_scan_results_strg > 0) {
744         btm_ble_batchscan_init();
745     }
746 
747     if (p_ctrl_le_feature_rd_cmpl_cback != NULL) {
748         p_ctrl_le_feature_rd_cmpl_cback(status);
749     }
750 }
751 #endif
752 
753 /*******************************************************************************
754 **
755 ** Function         BTM_BleGetVendorCapabilities
756 **
757 ** Description      This function reads local LE features
758 **
759 ** Parameters       p_cmn_vsc_cb : Locala LE capability structure
760 **
761 ** Returns          void
762 **
763 *******************************************************************************/
BTM_BleGetVendorCapabilities(tBTM_BLE_VSC_CB * p_cmn_vsc_cb)764 extern void BTM_BleGetVendorCapabilities(tBTM_BLE_VSC_CB *p_cmn_vsc_cb)
765 {
766     BTM_TRACE_DEBUG("BTM_BleGetVendorCapabilities");
767 
768     if (NULL != p_cmn_vsc_cb) {
769         *p_cmn_vsc_cb = btm_cb.cmn_ble_vsc_cb;
770     }
771 }
772 
773 /******************************************************************************
774 **
775 ** Function         BTM_BleReadControllerFeatures
776 **
777 ** Description      Reads BLE specific controller features
778 **
779 ** Parameters:      tBTM_BLE_CTRL_FEATURES_CBACK : Callback to notify when features are read
780 **
781 ** Returns          void
782 **
783 *******************************************************************************/
BTM_BleReadControllerFeatures(tBTM_BLE_CTRL_FEATURES_CBACK * p_vsc_cback)784 extern void BTM_BleReadControllerFeatures(tBTM_BLE_CTRL_FEATURES_CBACK  *p_vsc_cback)
785 {
786     if (TRUE == btm_cb.cmn_ble_vsc_cb.values_read) {
787         return;
788     }
789 
790 #if BLE_VND_INCLUDED == TRUE
791     BTM_TRACE_DEBUG("BTM_BleReadControllerFeatures");
792 
793     p_ctrl_le_feature_rd_cmpl_cback = p_vsc_cback;
794     if ( BTM_VendorSpecificCommand (HCI_BLE_VENDOR_CAP_OCF,
795                                     0,
796                                     NULL,
797                                     btm_ble_vendor_capability_vsc_cmpl_cback)
798             != BTM_CMD_STARTED) {
799         BTM_TRACE_ERROR("LE Get_Vendor Capabilities Command Failed.");
800     }
801 #else
802     UNUSED(p_vsc_cback);
803 #endif
804     return ;
805 }
806 
BTM_VendorHciEchoCmdCallback(tBTM_VSC_CMPL * p1)807 void BTM_VendorHciEchoCmdCallback(tBTM_VSC_CMPL *p1)
808 {
809 #if (!CONFIG_BT_STACK_NO_LOG)
810     if (!p1) {
811         return;
812     }
813     uint8_t *p = p1->p_param_buf;
814     uint8_t status, echo;
815     STREAM_TO_UINT8  (status, p);
816     STREAM_TO_UINT8  (echo, p);
817 #endif
818     BTM_TRACE_DEBUG("%s status 0x%x echo 0x%x", __func__, status, echo);
819 }
820 
821 /******************************************************************************
822 **
823 ** Function         BTM_VendorHciEchoCmdTest
824 **
825 ** Description      vendor common echo hci cmd test, controller will return status and echo
826 **
827 ** Parameters:      echo : echo value
828 **
829 ** Returns          void
830 **
831 *******************************************************************************/
BTM_VendorHciEchoCmdTest(uint8_t echo)832 void BTM_VendorHciEchoCmdTest(uint8_t echo)
833 {
834     BTM_VendorSpecificCommand (HCI_VENDOR_COMMON_ECHO_CMD_OPCODE,
835                                 1,
836                                 &echo,
837                                 BTM_VendorHciEchoCmdCallback);
838 }
839 
840 /*******************************************************************************
841 **
842 ** Function         BTM_BleEnableMixedPrivacyMode
843 **
844 ** Description      This function is called to enabled Mixed mode if privacy 1.2
845 **                  is applicable in controller.
846 **
847 ** Parameters       mixed_on:  mixed mode to be used or not.
848 **
849 ** Returns          void
850 **
851 *******************************************************************************/
BTM_BleEnableMixedPrivacyMode(BOOLEAN mixed_on)852 void BTM_BleEnableMixedPrivacyMode(BOOLEAN mixed_on)
853 {
854 
855 #if BLE_PRIVACY_SPT == TRUE
856     btm_cb.ble_ctr_cb.mixed_mode = mixed_on;
857 
858     /* TODO: send VSC to enabled mixed mode */
859 #endif
860 }
861 
862 /*******************************************************************************
863 **
864 ** Function         BTM_BleConfigPrivacy
865 **
866 ** Description      This function is called to enable or disable the privacy in
867 **                   LE channel of the local device.
868 **
869 ** Parameters       privacy_mode:  privacy mode on or off.
870 **
871 ** Returns          BOOLEAN privacy mode set success; otherwise failed.
872 **
873 *******************************************************************************/
BTM_BleConfigPrivacy(BOOLEAN privacy_mode,tBTM_SET_LOCAL_PRIVACY_CBACK * set_local_privacy_cback)874 BOOLEAN BTM_BleConfigPrivacy(BOOLEAN privacy_mode, tBTM_SET_LOCAL_PRIVACY_CBACK *set_local_privacy_cback)
875 {
876 #if BLE_PRIVACY_SPT == TRUE
877     tBTM_BLE_CB  *p_cb = &btm_cb.ble_ctr_cb;
878     tBTM_LE_RANDOM_CB *random_cb = &btm_cb.ble_ctr_cb.addr_mgnt_cb;
879     if (random_cb){
880         random_cb->set_local_privacy_cback = set_local_privacy_cback;
881     }else{
882         BTM_TRACE_ERROR("%s,random_cb = NULL", __func__);
883     }
884 
885     BTM_TRACE_EVENT ("%s\n", __func__);
886 
887     /* if LE is not supported, return error */
888     if (!controller_get_interface()->supports_ble()) {
889         return FALSE;
890     }
891 
892 #if (defined(GAP_INCLUDED) && GAP_INCLUDED == TRUE && GATTS_INCLUDED == TRUE)
893     uint8_t addr_resolution = 0;
894 #endif  /* defined(GAP_INCLUDED) && GAP_INCLUDED == TRUE && GATTS_INCLUDED == TRUE */
895     if (!privacy_mode) { /* if privacy disabled, always use public address */
896         p_cb->addr_mgnt_cb.exist_addr_bit &= (~BTM_BLE_GAP_ADDR_BIT_RESOLVABLE);
897         memset(p_cb->addr_mgnt_cb.resolvale_addr, 0, BD_ADDR_LEN);
898         p_cb->addr_mgnt_cb.own_addr_type = BLE_ADDR_PUBLIC;
899         p_cb->privacy_mode = BTM_PRIVACY_NONE;
900         // Disable RPA function
901         btsnd_hcic_ble_set_addr_resolution_enable(FALSE);
902     } else { /* privacy is turned on*/
903 #if (CONTROLLER_RPA_LIST_ENABLE == FALSE)
904         /* always set host random address, used when privacy 1.1 or priavcy 1.2 is disabled */
905         btm_gen_resolvable_private_addr((void *)btm_gen_resolve_paddr_low);
906 #endif
907 
908         if (BTM_BleMaxMultiAdvInstanceCount() > 0) {
909             btm_ble_multi_adv_enb_privacy(privacy_mode);
910         }
911 
912         /* 4.2 controller only allow privacy 1.2 or mixed mode, resolvable private address in controller */
913         if (controller_get_interface()->supports_ble_privacy()) {
914 #if (defined(GAP_INCLUDED) && GAP_INCLUDED == TRUE && GATTS_INCLUDED == TRUE)
915             addr_resolution = 1;
916 #endif  /* defined(GAP_INCLUDED) && GAP_INCLUDED == TRUE && GATTS_INCLUDED == TRUE */
917             /* check vendor specific capability */
918             p_cb->privacy_mode = btm_cb.ble_ctr_cb.mixed_mode ? BTM_PRIVACY_MIXED : BTM_PRIVACY_1_2;
919         } else { /* 4.1/4.0 controller */
920             p_cb->privacy_mode = BTM_PRIVACY_1_1;
921         }
922         // Enable RPA function
923         btsnd_hcic_ble_set_addr_resolution_enable(TRUE);
924     }
925 
926 #if (defined(GAP_INCLUDED) && GAP_INCLUDED == TRUE && GATTS_INCLUDED == TRUE)
927     GAP_BleAttrDBUpdate (GATT_UUID_GAP_CENTRAL_ADDR_RESOL, (tGAP_BLE_ATTR_VALUE *)&addr_resolution);
928 #endif
929 
930     return TRUE;
931 #else
932     return FALSE;
933 #endif
934 }
935 
936 /*******************************************************************************
937 **
938 ** Function         BTMGetLocalResolvablePrivateAddr
939 **
940 ** Description      This function is called to get local RPA address
941 **
942 ** Parameters       bda: address pointer.
943 **
944 **
945 *******************************************************************************/
946 
BTM_GetLocalResolvablePrivateAddr(BD_ADDR bda)947 BOOLEAN BTM_GetLocalResolvablePrivateAddr(BD_ADDR bda)
948 {
949     tBTM_LE_RANDOM_CB *p_cb = &btm_cb.ble_ctr_cb.addr_mgnt_cb;
950     BTM_TRACE_DEBUG ("get owm resolvable random address");
951 
952     if (bda) {
953         /* if privacy disabled, return false */
954         if ((p_cb->exist_addr_bit & BTM_BLE_GAP_ADDR_BIT_RESOLVABLE) == BTM_BLE_GAP_ADDR_BIT_RESOLVABLE) {
955             memcpy(bda, p_cb->resolvale_addr, BD_ADDR_LEN);
956             BTM_TRACE_DEBUG("own resolvable random address: 0x%02x:%02x:%02x:%02x:%02x:%02x",
957                             p_cb->resolvale_addr[0], p_cb->resolvale_addr[1],
958                             p_cb->resolvale_addr[2], p_cb->resolvale_addr[3],
959                             p_cb->resolvale_addr[4], p_cb->resolvale_addr[5]);
960             return TRUE;
961         }
962 
963         return FALSE;
964     }
965 
966    return FALSE;
967 }
968 
969 /*******************************************************************************
970 **
971 ** Function         BTM_UpdateAddrInfor
972 **
973 ** Description      This function is called to update address information
974 **
975 ** Parameters       addr_type: address type
976 **                  bda: address pointer.
977 **
978 **
979 *******************************************************************************/
BTM_UpdateAddrInfor(uint8_t addr_type,BD_ADDR bda)980 void BTM_UpdateAddrInfor(uint8_t addr_type, BD_ADDR bda)
981 {
982     btm_cb.ble_ctr_cb.addr_mgnt_cb.own_addr_type = addr_type;
983     memcpy(btm_cb.ble_ctr_cb.addr_mgnt_cb.private_addr, bda, BD_ADDR_LEN);
984 }
985 
986 /*******************************************************************************
987 **
988 ** Function         BTM_BleSetStaticAddr
989 **
990 ** Description      This function is called to save random address
991 **
992 ** Parameters       rand_addr: address pointer.
993 **
994 **
995 *******************************************************************************/
BTM_BleSetStaticAddr(BD_ADDR rand_addr)996 void BTM_BleSetStaticAddr(BD_ADDR rand_addr)
997 {
998     memcpy(btm_cb.ble_ctr_cb.addr_mgnt_cb.static_rand_addr, rand_addr, BD_ADDR_LEN);
999     btm_cb.ble_ctr_cb.addr_mgnt_cb.exist_addr_bit |= BTM_BLE_GAP_ADDR_BIT_RANDOM;
1000 }
1001 
1002 #if (CONTROLLER_RPA_LIST_ENABLE == FALSE)
BTM_BleUpdateOwnType(uint8_t * own_bda_type,tBTM_START_ADV_CMPL_CBACK * cb)1003 uint32_t BTM_BleUpdateOwnType(uint8_t *own_bda_type, tBTM_START_ADV_CMPL_CBACK *cb)
1004 {
1005     if(*own_bda_type == BLE_ADDR_RANDOM) {
1006         if((btm_cb.ble_ctr_cb.addr_mgnt_cb.exist_addr_bit & BTM_BLE_GAP_ADDR_BIT_RANDOM) == BTM_BLE_GAP_ADDR_BIT_RANDOM) {
1007             //close privacy
1008             #if BLE_PRIVACY_SPT == TRUE
1009             if (btm_cb.ble_ctr_cb.privacy_mode != BTM_PRIVACY_NONE) {
1010                 BTM_BleConfigPrivacy(FALSE, NULL);
1011             }
1012             #endif
1013             btm_cb.ble_ctr_cb.addr_mgnt_cb.own_addr_type = BLE_ADDR_RANDOM;
1014             memcpy(btm_cb.ble_ctr_cb.addr_mgnt_cb.private_addr, btm_cb.ble_ctr_cb.addr_mgnt_cb.static_rand_addr, BD_ADDR_LEN);
1015             // set address to controller
1016             btsnd_hcic_ble_set_random_addr(btm_cb.ble_ctr_cb.addr_mgnt_cb.static_rand_addr);
1017 
1018         } else if((btm_cb.ble_ctr_cb.addr_mgnt_cb.exist_addr_bit & BTM_BLE_GAP_ADDR_BIT_RESOLVABLE) == BTM_BLE_GAP_ADDR_BIT_RESOLVABLE) {
1019             btm_cb.ble_ctr_cb.addr_mgnt_cb.own_addr_type = BLE_ADDR_RANDOM;
1020             memcpy(btm_cb.ble_ctr_cb.addr_mgnt_cb.private_addr, btm_cb.ble_ctr_cb.addr_mgnt_cb.resolvale_addr, BD_ADDR_LEN);
1021             btsnd_hcic_ble_set_random_addr(btm_cb.ble_ctr_cb.addr_mgnt_cb.resolvale_addr);
1022         }else {
1023             BTM_TRACE_ERROR ("No random address yet, please set random address using API \"esp_ble_gap_set_rand_addr\" and retry\n");
1024             if(cb) {
1025                 (* cb)(HCI_ERR_ESP_VENDOR_FAIL);
1026             }
1027             return BTM_ILLEGAL_VALUE;
1028         }
1029     } else if(*own_bda_type == BLE_ADDR_PUBLIC_ID || *own_bda_type == BLE_ADDR_RANDOM_ID) {
1030         if((btm_cb.ble_ctr_cb.addr_mgnt_cb.exist_addr_bit & BTM_BLE_GAP_ADDR_BIT_RESOLVABLE) == BTM_BLE_GAP_ADDR_BIT_RESOLVABLE) {
1031             *own_bda_type = BLE_ADDR_RANDOM;
1032             btm_cb.ble_ctr_cb.addr_mgnt_cb.own_addr_type = BLE_ADDR_RANDOM;
1033             memcpy(btm_cb.ble_ctr_cb.addr_mgnt_cb.private_addr, btm_cb.ble_ctr_cb.addr_mgnt_cb.resolvale_addr, BD_ADDR_LEN);
1034             btsnd_hcic_ble_set_random_addr(btm_cb.ble_ctr_cb.addr_mgnt_cb.resolvale_addr);
1035         } else {
1036             #if BLE_PRIVACY_SPT == TRUE
1037             if(btm_cb.ble_ctr_cb.privacy_mode != BTM_PRIVACY_NONE) {
1038                 BTM_TRACE_ERROR ("Error state\n");
1039                 if(cb) {
1040                     (* cb)(HCI_ERR_ESP_VENDOR_FAIL);
1041                 }
1042                 return BTM_ILLEGAL_VALUE;
1043             }
1044             #endif
1045             if(*own_bda_type == BLE_ADDR_PUBLIC_ID) {
1046                 *own_bda_type = BLE_ADDR_PUBLIC;
1047                 btm_cb.ble_ctr_cb.addr_mgnt_cb.own_addr_type = BLE_ADDR_PUBLIC;
1048             } else { //own_bda_type == BLE_ADDR_RANDOM_ID
1049                 if((btm_cb.ble_ctr_cb.addr_mgnt_cb.exist_addr_bit & BTM_BLE_GAP_ADDR_BIT_RANDOM) == BTM_BLE_GAP_ADDR_BIT_RANDOM) {
1050                     *own_bda_type = BLE_ADDR_RANDOM;
1051                     btm_cb.ble_ctr_cb.addr_mgnt_cb.own_addr_type = BLE_ADDR_RANDOM;
1052                     memcpy(btm_cb.ble_ctr_cb.addr_mgnt_cb.private_addr, btm_cb.ble_ctr_cb.addr_mgnt_cb.static_rand_addr, BD_ADDR_LEN);
1053                     btsnd_hcic_ble_set_random_addr(btm_cb.ble_ctr_cb.addr_mgnt_cb.static_rand_addr);
1054                 } else {
1055                     BTM_TRACE_ERROR ("No RPA and no random address yet, please set RPA or random address and try\n");
1056                     if(cb) {
1057                         (* cb)(HCI_ERR_ESP_VENDOR_FAIL);
1058                     }
1059                     return BTM_ILLEGAL_VALUE;
1060                 }
1061             }
1062         }
1063     } else {
1064         btm_cb.ble_ctr_cb.addr_mgnt_cb.own_addr_type = BLE_ADDR_PUBLIC;
1065     }
1066 
1067     return BTM_SUCCESS;
1068 }
1069 #else
BTM_BleUpdateOwnType(uint8_t * own_bda_type,tBTM_START_ADV_CMPL_CBACK * cb)1070 uint32_t BTM_BleUpdateOwnType(uint8_t *own_bda_type, tBTM_START_ADV_CMPL_CBACK *cb)
1071 {
1072     tBTM_LE_RANDOM_CB *p_cb = &btm_cb.ble_ctr_cb.addr_mgnt_cb;
1073 
1074     if((*own_bda_type == BLE_ADDR_RANDOM) || (*own_bda_type == BLE_ADDR_RANDOM_ID)) {
1075         if((p_cb->exist_addr_bit & BTM_BLE_GAP_ADDR_BIT_RANDOM) != BTM_BLE_GAP_ADDR_BIT_RANDOM) {
1076             BTM_TRACE_ERROR("No random address yet, please set random address and try\n");
1077             if(cb) {
1078                 (* cb)(HCI_ERR_ESP_VENDOR_FAIL);
1079             }
1080             return BTM_ILLEGAL_VALUE;
1081         }
1082 
1083         // If a device is using RPA, it shall also have an Identity Address
1084         if ((*own_bda_type == BLE_ADDR_RANDOM_ID) && BTM_BLE_IS_NON_RESLVE_BDA(p_cb->static_rand_addr)) {
1085             BTM_TRACE_ERROR("No identity address yet, please set static random address and try\n");
1086             if (cb) {
1087                 (* cb)(HCI_ERR_ESP_VENDOR_FAIL);
1088             }
1089             return BTM_ILLEGAL_VALUE;
1090         }
1091     }
1092 
1093     p_cb->own_addr_type = *own_bda_type;
1094 
1095     return BTM_SUCCESS;
1096 }
1097 #endif
1098 
1099 
1100 /*******************************************************************************
1101 **
1102 ** Function         BTM_BleConfigLocalIcon
1103 **
1104 ** Description      This function is called to set local icon
1105 **
1106 ** Parameters       icon:  appearance value.
1107 **
1108 **
1109 *******************************************************************************/
BTM_BleConfigLocalIcon(uint16_t icon)1110 void BTM_BleConfigLocalIcon(uint16_t icon)
1111 {
1112 #if (defined(GAP_INCLUDED) && GAP_INCLUDED == TRUE && GATTS_INCLUDED == TRUE)
1113     tGAP_BLE_ATTR_VALUE p_value;
1114     p_value.icon = icon;
1115     GAP_BleAttrDBUpdate(GATT_UUID_GAP_ICON, &p_value);
1116 #else
1117     BTM_TRACE_ERROR("%s\n", __func__);
1118 #endif
1119 }
1120 
1121 /*******************************************************************************
1122 **
1123 ** Function         BTM_BleConfigConnParams
1124 **
1125 ** Description      This function is called to set the connection parameters
1126 **
1127 ** Parameters       int_min:  minimum connection interval
1128 **                  int_max:  maximum connection interval
1129 **                  latency:  slave latency
1130 **                  timeout:  supervision timeout
1131 **
1132 *******************************************************************************/
BTM_BleConfigConnParams(uint16_t int_min,uint16_t int_max,uint16_t latency,uint16_t timeout)1133 void BTM_BleConfigConnParams(uint16_t int_min, uint16_t int_max, uint16_t latency, uint16_t timeout)
1134 {
1135 #if (defined(GAP_INCLUDED) && GAP_INCLUDED == TRUE && GATTS_INCLUDED == TRUE)
1136     tGAP_BLE_ATTR_VALUE p_value;
1137 
1138     p_value.conn_param.int_min = int_min;
1139     p_value.conn_param.int_max = int_max;
1140     p_value.conn_param.latency = latency;
1141     p_value.conn_param.sp_tout = timeout;
1142     GAP_BleAttrDBUpdate(GATT_UUID_GAP_PREF_CONN_PARAM, &p_value);
1143 #else
1144     BTM_TRACE_ERROR("%s\n", __func__);
1145 #endif
1146 }
1147 
1148 /*******************************************************************************
1149 **
1150 ** Function          BTM_BleMaxMultiAdvInstanceCount
1151 **
1152 ** Description        Returns max number of multi adv instances supported by controller
1153 **
1154 ** Returns          Max multi adv instance count
1155 **
1156 *******************************************************************************/
BTM_BleMaxMultiAdvInstanceCount(void)1157 extern UINT8  BTM_BleMaxMultiAdvInstanceCount(void)
1158 {
1159     return btm_cb.cmn_ble_vsc_cb.adv_inst_max < BTM_BLE_MULTI_ADV_MAX ?
1160            btm_cb.cmn_ble_vsc_cb.adv_inst_max : BTM_BLE_MULTI_ADV_MAX;
1161 }
1162 
1163 #if BLE_PRIVACY_SPT == TRUE
1164 /*******************************************************************************
1165 **
1166 ** Function         btm_ble_resolve_random_addr_on_adv
1167 **
1168 ** Description      resolve random address complete callback.
1169 **
1170 ** Returns          void
1171 **
1172 *******************************************************************************/
btm_ble_resolve_random_addr_on_adv(void * p_rec,void * p)1173 static void btm_ble_resolve_random_addr_on_adv(void *p_rec, void *p)
1174 {
1175     tBTM_SEC_DEV_REC    *match_rec = (tBTM_SEC_DEV_REC *) p_rec;
1176     UINT8       addr_type = BLE_ADDR_RANDOM;
1177     BD_ADDR     bda;
1178     UINT8       *pp = (UINT8 *)p + 1;
1179     UINT8           evt_type;
1180 
1181     BTM_TRACE_EVENT ("btm_ble_resolve_random_addr_on_adv ");
1182 
1183     STREAM_TO_UINT8    (evt_type, pp);
1184     STREAM_TO_UINT8    (addr_type, pp);
1185     STREAM_TO_BDADDR   (bda, pp);
1186 
1187     if (match_rec) {
1188         BTM_TRACE_DEBUG("Random match");
1189         match_rec->ble.active_addr_type = BTM_BLE_ADDR_RRA;
1190         memcpy(match_rec->ble.cur_rand_addr, bda, BD_ADDR_LEN);
1191 
1192         if (btm_ble_init_pseudo_addr(match_rec, bda)) {
1193             memcpy(bda, match_rec->bd_addr, BD_ADDR_LEN);
1194         } else {
1195             // Assign the original address to be the current report address
1196             memcpy(bda, match_rec->ble.pseudo_addr, BD_ADDR_LEN);
1197         }
1198     }
1199 
1200     btm_ble_process_adv_pkt_cont(bda, addr_type, evt_type, pp);
1201 
1202     return;
1203 }
1204 #endif
1205 
1206 /*******************************************************************************
1207 **
1208 ** Function         BTM_BleLocalPrivacyEnabled
1209 **
1210 ** Description        Checks if local device supports private address
1211 **
1212 ** Returns          Return TRUE if local privacy is enabled else FALSE
1213 **
1214 *******************************************************************************/
BTM_BleLocalPrivacyEnabled(void)1215 BOOLEAN BTM_BleLocalPrivacyEnabled(void)
1216 {
1217 #if BLE_PRIVACY_SPT == TRUE
1218     return (btm_cb.ble_ctr_cb.privacy_mode != BTM_PRIVACY_NONE);
1219 #else
1220     return false;
1221 #endif
1222 }
1223 
1224 /*******************************************************************************
1225 **
1226 ** Function         BTM_BleSetBgConnType
1227 **
1228 ** Description      This function is called to set BLE connectable mode for a
1229 **                  peripheral device.
1230 **
1231 ** Parameters       bg_conn_type: it can be auto connection, or selective connection.
1232 **                  p_select_cback: callback function when selective connection procedure
1233 **                              is being used.
1234 **
1235 ** Returns          void
1236 **
1237 *******************************************************************************/
BTM_BleSetBgConnType(tBTM_BLE_CONN_TYPE bg_conn_type,tBTM_BLE_SEL_CBACK * p_select_cback)1238 BOOLEAN BTM_BleSetBgConnType(tBTM_BLE_CONN_TYPE   bg_conn_type,
1239                              tBTM_BLE_SEL_CBACK   *p_select_cback)
1240 {
1241     BOOLEAN started = TRUE;
1242 
1243     BTM_TRACE_EVENT ("BTM_BleSetBgConnType ");
1244     if (!controller_get_interface()->supports_ble()) {
1245         return FALSE;
1246     }
1247 
1248     if (btm_cb.ble_ctr_cb.bg_conn_type != bg_conn_type) {
1249         switch (bg_conn_type) {
1250         case BTM_BLE_CONN_AUTO:
1251             btm_ble_start_auto_conn(TRUE);
1252             break;
1253 
1254         case BTM_BLE_CONN_SELECTIVE:
1255             if (btm_cb.ble_ctr_cb.bg_conn_type == BTM_BLE_CONN_AUTO) {
1256                 btm_ble_start_auto_conn(FALSE);
1257             }
1258             btm_ble_start_select_conn(TRUE, p_select_cback);
1259             break;
1260 
1261         case BTM_BLE_CONN_NONE:
1262             if (btm_cb.ble_ctr_cb.bg_conn_type == BTM_BLE_CONN_AUTO) {
1263                 btm_ble_start_auto_conn(FALSE);
1264             } else if (btm_cb.ble_ctr_cb.bg_conn_type == BTM_BLE_CONN_SELECTIVE) {
1265                 btm_ble_start_select_conn(FALSE, NULL);
1266             }
1267             started = TRUE;
1268             break;
1269 
1270         default:
1271             BTM_TRACE_ERROR("invalid bg connection type : %d ", bg_conn_type);
1272             started = FALSE;
1273             break;
1274         }
1275 
1276         if (started) {
1277             btm_cb.ble_ctr_cb.bg_conn_type = bg_conn_type;
1278         }
1279     }
1280     return started;
1281 }
1282 
1283 /*******************************************************************************
1284 **
1285 ** Function         BTM_BleClearBgConnDev
1286 **
1287 ** Description      This function is called to clear the whitelist,
1288 **                  end any pending whitelist connections,
1289 *                   and reset the local bg device list.
1290 **
1291 ** Parameters       void
1292 **
1293 ** Returns          void
1294 **
1295 *******************************************************************************/
BTM_BleClearBgConnDev(void)1296 void BTM_BleClearBgConnDev(void)
1297 {
1298     btm_ble_start_auto_conn(FALSE);
1299     btm_ble_clear_white_list(NULL);
1300     gatt_reset_bgdev_list();
1301 }
1302 
1303 /*******************************************************************************
1304 **
1305 ** Function         BTM_BleUpdateBgConnDev
1306 **
1307 ** Description      This function is called to add or remove a device into/from
1308 **                  background connection procedure. The background connection
1309 *                   procedure is decided by the background connection type, it can be
1310 *                   auto connection, or selective connection.
1311 **
1312 ** Parameters       add_remove: TRUE to add; FALSE to remove.
1313 **                  remote_bda: device address to add/remove.
1314 **
1315 ** Returns          void
1316 **
1317 *******************************************************************************/
BTM_BleUpdateBgConnDev(BOOLEAN add_remove,BD_ADDR remote_bda)1318 BOOLEAN BTM_BleUpdateBgConnDev(BOOLEAN add_remove, BD_ADDR   remote_bda)
1319 {
1320     BTM_TRACE_EVENT("%s() add=%d", __func__, add_remove);
1321     return btm_update_dev_to_white_list(add_remove, remote_bda, 0, NULL);
1322 }
1323 
1324 /*******************************************************************************
1325 **
1326 ** Function         BTM_BleSetConnectableMode
1327 **
1328 ** Description      This function is called to set BLE connectable mode for a
1329 **                  peripheral device.
1330 **
1331 ** Parameters       conn_mode:  directed connectable mode, or non-directed.It can
1332 **                              be BTM_BLE_CONNECT_EVT, BTM_BLE_CONNECT_DIR_EVT or
1333 **                              BTM_BLE_CONNECT_LO_DUTY_DIR_EVT
1334 **
1335 ** Returns          BTM_ILLEGAL_VALUE if controller does not support BLE.
1336 **                  BTM_SUCCESS is status set successfully; otherwise failure.
1337 **
1338 *******************************************************************************/
BTM_BleSetConnectableMode(tBTM_BLE_CONN_MODE connectable_mode)1339 tBTM_STATUS BTM_BleSetConnectableMode(tBTM_BLE_CONN_MODE connectable_mode)
1340 {
1341     tBTM_BLE_INQ_CB *p_cb = &btm_cb.ble_ctr_cb.inq_var;
1342 
1343     BTM_TRACE_EVENT ("%s connectable_mode = %d ", __func__, connectable_mode);
1344     if (!controller_get_interface()->supports_ble()) {
1345         return BTM_ILLEGAL_VALUE;
1346     }
1347 
1348     p_cb->directed_conn = connectable_mode;
1349     return btm_ble_set_connectability( p_cb->connectable_mode);
1350 }
1351 
1352 /*******************************************************************************
1353 **
1354 ** Function         btm_set_conn_mode_adv_init_addr
1355 **
1356 ** Description      set initiator address type and local address type based on adv
1357 **                  mode.
1358 **
1359 **
1360 *******************************************************************************/
btm_set_conn_mode_adv_init_addr(tBTM_BLE_INQ_CB * p_cb,BD_ADDR_PTR p_peer_addr_ptr,tBLE_ADDR_TYPE * p_peer_addr_type,tBLE_ADDR_TYPE * p_own_addr_type)1361 static UINT8 btm_set_conn_mode_adv_init_addr(tBTM_BLE_INQ_CB *p_cb,
1362         BD_ADDR_PTR p_peer_addr_ptr,
1363         tBLE_ADDR_TYPE *p_peer_addr_type,
1364         tBLE_ADDR_TYPE *p_own_addr_type)
1365 {
1366     UINT8 evt_type;
1367 #if BLE_PRIVACY_SPT == TRUE
1368     UINT8 i = BTM_SEC_MAX_DEVICE_RECORDS;
1369     tBTM_SEC_DEV_REC    *p_dev_rec;
1370     list_node_t         *p_node = NULL;
1371 #endif  ///BLE_PRIVACY_SPT == TRUE
1372     evt_type = (p_cb->connectable_mode == BTM_BLE_NON_CONNECTABLE) ? \
1373                ((p_cb->scan_rsp) ? BTM_BLE_DISCOVER_EVT : BTM_BLE_NON_CONNECT_EVT )\
1374                : BTM_BLE_CONNECT_EVT;
1375 
1376     if (evt_type == BTM_BLE_CONNECT_EVT) {
1377         evt_type = p_cb->directed_conn;
1378 
1379         if ( p_cb->directed_conn == BTM_BLE_CONNECT_DIR_EVT ||
1380                 p_cb->directed_conn == BTM_BLE_CONNECT_LO_DUTY_DIR_EVT) {
1381 
1382 #if BLE_PRIVACY_SPT == TRUE
1383             /* for privacy 1.2, convert peer address as static, own address set as ID addr */
1384             if (btm_cb.ble_ctr_cb.privacy_mode ==  BTM_PRIVACY_1_2 ||
1385                     btm_cb.ble_ctr_cb.privacy_mode ==  BTM_PRIVACY_MIXED) {
1386                 /* only do so for bonded device */
1387                 if ((p_dev_rec = btm_find_or_alloc_dev (p_cb->direct_bda.bda)) != NULL &&
1388                         p_dev_rec->ble.in_controller_list & BTM_RESOLVING_LIST_BIT) {
1389                     //btm_ble_enable_resolving_list(BTM_BLE_RL_ADV);
1390                     memcpy(p_peer_addr_ptr, p_dev_rec->ble.static_addr, BD_ADDR_LEN);
1391                     *p_peer_addr_type = p_dev_rec->ble.static_addr_type;
1392                     *p_own_addr_type = BLE_ADDR_RANDOM_ID;
1393                     return evt_type;
1394                 }
1395                 /* otherwise fall though as normal directed adv */
1396                 else {
1397                     btm_ble_disable_resolving_list(BTM_BLE_RL_ADV, TRUE);
1398                 }
1399             }
1400 #endif
1401             /* direct adv mode does not have privacy, if privacy is not enabled  */
1402             *p_peer_addr_type  = p_cb->direct_bda.type;
1403             memcpy(p_peer_addr_ptr, p_cb->direct_bda.bda, BD_ADDR_LEN);
1404             return evt_type;
1405         }
1406     }
1407 
1408     /* undirect adv mode or non-connectable mode*/
1409 #if BLE_PRIVACY_SPT == TRUE
1410     /* when privacy 1.2 privacy only mode is used, or mixed mode */
1411     if ((btm_cb.ble_ctr_cb.privacy_mode ==  BTM_PRIVACY_1_2 && p_cb->afp != AP_SCAN_CONN_ALL) ||
1412             btm_cb.ble_ctr_cb.privacy_mode ==  BTM_PRIVACY_MIXED) {
1413         /* if enhanced privacy is required, set Identity address and matching IRK peer */
1414         for (p_node = list_begin(btm_cb.p_sec_dev_rec_list); p_node; p_node = list_next(p_node)) {
1415             p_dev_rec = list_node(p_node);
1416             if ((p_dev_rec->sec_flags & BTM_SEC_IN_USE) != 0 &&
1417                     (p_dev_rec->ble.in_controller_list & BTM_RESOLVING_LIST_BIT) != 0) {
1418                 memcpy(p_peer_addr_ptr, p_dev_rec->ble.static_addr, BD_ADDR_LEN);
1419                 *p_peer_addr_type = p_dev_rec->ble.static_addr_type;
1420                 break;
1421 	    }
1422 	}
1423 
1424         if (i != BTM_SEC_MAX_DEVICE_RECORDS) {
1425             *p_own_addr_type = BLE_ADDR_RANDOM_ID;
1426         } else
1427             /* resolving list is empty, not enabled */
1428         {
1429             *p_own_addr_type = BLE_ADDR_RANDOM;
1430         }
1431     }
1432     /* privacy 1.1, or privacy 1.2, general discoverable/connectable mode, disable privacy in */
1433     /* controller fall back to host based privacy */
1434     else if (btm_cb.ble_ctr_cb.privacy_mode !=  BTM_PRIVACY_NONE) {
1435         *p_own_addr_type = BLE_ADDR_RANDOM;
1436     }
1437 #endif
1438 
1439     /* if no privacy,do not set any peer address,*/
1440     /* local address type go by global privacy setting */
1441     return evt_type;
1442 }
1443 
1444 /*******************************************************************************
1445 **
1446 ** Function         BTM_BleSetAdvParams
1447 **
1448 ** Description      This function is called to set advertising parameters.
1449 **
1450 ** Parameters       adv_int_min: minimum advertising interval
1451 **                  adv_int_max: maximum advertising interval
1452 **                  p_dir_bda: connectable direct initiator's LE device address
1453 **                  chnl_map: advertising channel map.
1454 **
1455 ** Returns          void
1456 **
1457 *******************************************************************************/
BTM_BleSetAdvParams(UINT16 adv_int_min,UINT16 adv_int_max,tBLE_BD_ADDR * p_dir_bda,tBTM_BLE_ADV_CHNL_MAP chnl_map)1458 tBTM_STATUS BTM_BleSetAdvParams(UINT16 adv_int_min, UINT16 adv_int_max,
1459                                 tBLE_BD_ADDR *p_dir_bda,
1460                                 tBTM_BLE_ADV_CHNL_MAP chnl_map)
1461 {
1462     tBTM_LE_RANDOM_CB *p_addr_cb = &btm_cb.ble_ctr_cb.addr_mgnt_cb;
1463     tBTM_BLE_INQ_CB *p_cb = &btm_cb.ble_ctr_cb.inq_var;
1464     tBTM_STATUS status = BTM_SUCCESS;
1465     BD_ADDR     p_addr_ptr =  {0};
1466     tBLE_ADDR_TYPE   init_addr_type = BLE_ADDR_PUBLIC;
1467     tBLE_ADDR_TYPE   own_addr_type = p_addr_cb->own_addr_type;
1468     UINT8            adv_mode = p_cb->adv_mode;
1469 
1470     BTM_TRACE_EVENT ("BTM_BleSetAdvParams");
1471 
1472     if (!controller_get_interface()->supports_ble()) {
1473         return BTM_ILLEGAL_VALUE;
1474     }
1475 
1476     if (!BTM_BLE_ISVALID_PARAM(adv_int_min, BTM_BLE_ADV_INT_MIN, BTM_BLE_ADV_INT_MAX) ||
1477             !BTM_BLE_ISVALID_PARAM(adv_int_max, BTM_BLE_ADV_INT_MIN, BTM_BLE_ADV_INT_MAX)) {
1478         return BTM_ILLEGAL_VALUE;
1479     }
1480 
1481     p_cb->adv_interval_min = adv_int_min;
1482     p_cb->adv_interval_max = adv_int_max;
1483     p_cb->adv_chnl_map = chnl_map;
1484 
1485     if (p_dir_bda) {
1486         memcpy(&p_cb->direct_bda, p_dir_bda, sizeof(tBLE_BD_ADDR));
1487     }
1488 
1489     BTM_TRACE_EVENT ("update params for an active adv\n");
1490 
1491     btm_ble_stop_adv();
1492 
1493     p_cb->evt_type = btm_set_conn_mode_adv_init_addr(p_cb, p_addr_ptr, &init_addr_type,
1494                      &own_addr_type);
1495 
1496     /* update adv params */
1497     btsnd_hcic_ble_write_adv_params (p_cb->adv_interval_min,
1498                                      p_cb->adv_interval_max,
1499                                      p_cb->evt_type,
1500                                      own_addr_type,
1501                                      init_addr_type,
1502                                      p_addr_ptr,
1503                                      p_cb->adv_chnl_map,
1504                                      p_cb->afp);
1505 
1506     if (adv_mode == BTM_BLE_ADV_ENABLE) {
1507         btm_ble_start_adv();
1508     }
1509 
1510     return status;
1511 }
1512 
1513 
1514 /*******************************************************************************
1515 **
1516 ** Function         BTM_BleSetAdvParamsAll
1517 **
1518 ** Description      This function is called to set all of the advertising parameters.
1519 **
1520 ** Parameters:       None.
1521 **
1522 ** Returns          void
1523 **
1524 *******************************************************************************/
BTM_BleSetAdvParamsAll(UINT16 adv_int_min,UINT16 adv_int_max,UINT8 adv_type,tBLE_ADDR_TYPE own_bda_type,tBLE_BD_ADDR * p_dir_bda,tBTM_BLE_ADV_CHNL_MAP chnl_map,tBTM_BLE_AFP afp,tBTM_START_ADV_CMPL_CBACK * adv_cb)1525 tBTM_STATUS BTM_BleSetAdvParamsAll(UINT16 adv_int_min, UINT16 adv_int_max, UINT8 adv_type,
1526                                         tBLE_ADDR_TYPE own_bda_type, tBLE_BD_ADDR *p_dir_bda,
1527                                         tBTM_BLE_ADV_CHNL_MAP chnl_map, tBTM_BLE_AFP afp, tBTM_START_ADV_CMPL_CBACK *adv_cb)
1528 {
1529     tBTM_LE_RANDOM_CB *p_addr_cb = &btm_cb.ble_ctr_cb.addr_mgnt_cb;
1530     tBTM_BLE_INQ_CB *p_cb = &btm_cb.ble_ctr_cb.inq_var;
1531 
1532     BTM_TRACE_EVENT ("BTM_BleSetAdvParamsAll\n");
1533 
1534     if (!controller_get_interface()->supports_ble()) {
1535         return BTM_ILLEGAL_VALUE;
1536     }
1537     if (BTM_BleUpdateOwnType(&own_bda_type, adv_cb) != 0) {
1538         return BTM_ILLEGAL_VALUE;
1539     }
1540     if (!BTM_BLE_ISVALID_PARAM(adv_int_min, BTM_BLE_ADV_INT_MIN, BTM_BLE_ADV_INT_MAX) ||
1541             !BTM_BLE_ISVALID_PARAM(adv_int_max, BTM_BLE_ADV_INT_MIN, BTM_BLE_ADV_INT_MAX)) {
1542          BTM_TRACE_ERROR ("adv_int_min or adv_int_max is invalid\n");
1543         if(adv_cb) {
1544             (* adv_cb)(HCI_ERR_ESP_VENDOR_FAIL);
1545         }
1546         return BTM_ILLEGAL_VALUE;
1547     }
1548 
1549     btm_ble_stop_adv();
1550 
1551     osi_mutex_lock(&adv_param_lock, OSI_MUTEX_MAX_TIMEOUT);
1552     if(adv_type == BTM_BLE_CONNECT_DIR_EVT){
1553         btm_ble_set_topology_mask(BTM_BLE_STATE_HI_DUTY_DIR_ADV_BIT);
1554     }else if(adv_type == BTM_BLE_CONNECT_LO_DUTY_DIR_EVT){
1555         btm_ble_set_topology_mask(BTM_BLE_STATE_LO_DUTY_DIR_ADV_BIT);
1556     }else if(adv_type == BTM_BLE_NON_CONNECT_EVT){
1557         btm_ble_set_topology_mask(BTM_BLE_STATE_NON_CONN_ADV_BIT);
1558     }
1559 
1560     p_cb->adv_interval_min = adv_int_min;
1561     p_cb->adv_interval_max = adv_int_max;
1562     p_cb->adv_chnl_map = chnl_map;
1563     p_addr_cb->own_addr_type = own_bda_type;
1564     p_cb->evt_type = adv_type;
1565     p_cb->afp = afp;
1566     p_cb->p_adv_cb = adv_cb;
1567 
1568     if (p_dir_bda) {
1569         memcpy(&p_cb->direct_bda, p_dir_bda, sizeof(tBLE_BD_ADDR));
1570     } else {
1571         return BTM_ILLEGAL_VALUE;
1572     }
1573 
1574     BTM_TRACE_EVENT ("update params for an active adv\n");
1575 
1576     tBTM_STATUS status = BTM_SUCCESS;
1577     /* update adv params */
1578     if (btsnd_hcic_ble_write_adv_params (adv_int_min,
1579                                         adv_int_max,
1580                                         adv_type,
1581                                         own_bda_type,
1582                                         p_dir_bda->type,
1583                                         p_dir_bda->bda,
1584                                         chnl_map,
1585                                         p_cb->afp)) {
1586         osi_sem_take(&adv_param_sem, OSI_SEM_MAX_TIMEOUT);
1587         status = adv_param_status;
1588     } else {
1589         status = BTM_NO_RESOURCES;
1590     }
1591     osi_mutex_unlock(&adv_param_lock);
1592     return status;
1593 }
1594 
BTM_BleStartAdv(void)1595 tBTM_STATUS BTM_BleStartAdv(void)
1596 {
1597     tBTM_STATUS status = BTM_SUCCESS;
1598     if (!controller_get_interface()->supports_ble()) {
1599         return BTM_ILLEGAL_VALUE;
1600     }
1601 
1602     btm_ble_stop_adv();
1603 
1604     status = btm_ble_start_adv();
1605 
1606     return status;
1607 }
1608 /*******************************************************************************
1609 **
1610 ** Function         BTM_BleReadAdvParams
1611 **
1612 ** Description      This function is called to set advertising parameters.
1613 **
1614 ** Parameters       adv_int_min: minimum advertising interval
1615 **                  adv_int_max: maximum advertising interval
1616 **                  p_dir_bda: connectable direct initiator's LE device address
1617 **                  chnl_map: advertising channel map.
1618 **
1619 ** Returns          void
1620 **
1621 *******************************************************************************/
BTM_BleReadAdvParams(UINT16 * adv_int_min,UINT16 * adv_int_max,tBLE_BD_ADDR * p_dir_bda,tBTM_BLE_ADV_CHNL_MAP * p_chnl_map)1622 void BTM_BleReadAdvParams (UINT16 *adv_int_min, UINT16 *adv_int_max,
1623                            tBLE_BD_ADDR *p_dir_bda, tBTM_BLE_ADV_CHNL_MAP *p_chnl_map)
1624 {
1625     tBTM_BLE_INQ_CB *p_cb = &btm_cb.ble_ctr_cb.inq_var;
1626 
1627     BTM_TRACE_EVENT ("BTM_BleReadAdvParams ");
1628     if (!controller_get_interface()->supports_ble()) {
1629         return ;
1630     }
1631 
1632     *adv_int_min = p_cb->adv_interval_min;
1633     *adv_int_max = p_cb->adv_interval_max;
1634     *p_chnl_map = p_cb->adv_chnl_map;
1635 
1636     if (p_dir_bda != NULL) {
1637         memcpy(p_dir_bda, &p_cb->direct_bda, sizeof(tBLE_BD_ADDR));
1638     }
1639 }
1640 
1641 /*******************************************************************************
1642 **
1643 ** Function         BTM_BleSetScanParams
1644 **
1645 ** Description      This function is called to set scan parameters.
1646 **
1647 ** Parameters       client_if - Client IF
1648 **                  scan_interval - Scan interval
1649 **                  scan_window - Scan window
1650 **                  scan_mode -    Scan mode
1651 **                  scan_setup_status_cback - Scan param setup status callback
1652 **
1653 ** Returns          void
1654 **
1655 *******************************************************************************/
BTM_BleSetScanParams(tGATT_IF client_if,UINT32 scan_interval,UINT32 scan_window,tBLE_SCAN_MODE scan_mode,tBLE_SCAN_PARAM_SETUP_CBACK scan_setup_status_cback)1656 void BTM_BleSetScanParams(tGATT_IF client_if, UINT32 scan_interval, UINT32 scan_window,
1657                           tBLE_SCAN_MODE scan_mode,
1658                           tBLE_SCAN_PARAM_SETUP_CBACK scan_setup_status_cback)
1659 {
1660     tBTM_BLE_INQ_CB *p_cb = &btm_cb.ble_ctr_cb.inq_var;
1661     UINT32 max_scan_interval;
1662     UINT32 max_scan_window;
1663 
1664     BTM_TRACE_EVENT ("%s\n", __func__);
1665     if (!controller_get_interface()->supports_ble()) {
1666         return;
1667     }
1668 
1669     /* If not supporting extended scan support, use the older range for checking */
1670     if (btm_cb.cmn_ble_vsc_cb.extended_scan_support == 0) {
1671         max_scan_interval = BTM_BLE_SCAN_INT_MAX;
1672         max_scan_window = BTM_BLE_SCAN_WIN_MAX;
1673     } else {
1674         /* If supporting extended scan support, use the new extended range for checking */
1675         max_scan_interval = BTM_BLE_EXT_SCAN_INT_MAX;
1676         max_scan_window = BTM_BLE_EXT_SCAN_WIN_MAX;
1677     }
1678 
1679     if (BTM_BLE_ISVALID_PARAM(scan_interval, BTM_BLE_SCAN_INT_MIN, max_scan_interval) &&
1680             BTM_BLE_ISVALID_PARAM(scan_window, BTM_BLE_SCAN_WIN_MIN, max_scan_window) &&
1681             (scan_mode == BTM_BLE_SCAN_MODE_ACTI || scan_mode == BTM_BLE_SCAN_MODE_PASS)) {
1682         p_cb->scan_type = scan_mode;
1683         p_cb->scan_interval = scan_interval;
1684         p_cb->scan_window = scan_window;
1685 
1686         if (scan_setup_status_cback != NULL) {
1687             scan_setup_status_cback(client_if, BTM_SUCCESS);
1688         }
1689     } else {
1690         if (scan_setup_status_cback != NULL) {
1691             scan_setup_status_cback(client_if, BTM_ILLEGAL_VALUE);
1692         }
1693 
1694         BTM_TRACE_ERROR("Illegal params: scan_interval = %d scan_window = %d\n",
1695                         scan_interval, scan_window);
1696     }
1697 
1698 }
1699 
BTM_BleSetScanFilterParams(tGATT_IF client_if,UINT32 scan_interval,UINT32 scan_window,tBLE_SCAN_MODE scan_mode,UINT8 addr_type_own,UINT8 scan_duplicate_filter,tBTM_BLE_SFP scan_filter_policy,tBLE_SCAN_PARAM_SETUP_CBACK scan_setup_status_cback)1700 tBTM_STATUS BTM_BleSetScanFilterParams(tGATT_IF client_if, UINT32 scan_interval, UINT32 scan_window,
1701                                 tBLE_SCAN_MODE scan_mode, UINT8 addr_type_own, UINT8 scan_duplicate_filter, tBTM_BLE_SFP scan_filter_policy,
1702                                 tBLE_SCAN_PARAM_SETUP_CBACK scan_setup_status_cback)
1703 {
1704     tBTM_BLE_INQ_CB *p_cb = &btm_cb.ble_ctr_cb.inq_var;
1705     UINT32 max_scan_interval;
1706     UINT32 max_scan_window;
1707     tBTM_STATUS ret = BTM_SUCCESS;
1708 
1709     BTM_TRACE_EVENT ("%s\n", __func__);
1710     if (!controller_get_interface()->supports_ble()) {
1711         return BTM_ILLEGAL_VALUE;
1712     }
1713     if (BTM_BleUpdateOwnType(&addr_type_own, NULL) != 0) {
1714         return BTM_ILLEGAL_VALUE;
1715     }
1716     /* If not supporting extended scan support, use the older range for checking */
1717     if (btm_cb.cmn_ble_vsc_cb.extended_scan_support == 0) {
1718         max_scan_interval = BTM_BLE_SCAN_INT_MAX;
1719         max_scan_window = BTM_BLE_SCAN_WIN_MAX;
1720     } else {
1721         /* If supporting extended scan support, use the new extended range for checking */
1722         max_scan_interval = BTM_BLE_EXT_SCAN_INT_MAX;
1723         max_scan_window = BTM_BLE_EXT_SCAN_WIN_MAX;
1724     }
1725 
1726     osi_mutex_lock(&scan_param_lock, OSI_MUTEX_MAX_TIMEOUT);
1727 
1728     if (BTM_BLE_ISVALID_PARAM(scan_interval, BTM_BLE_SCAN_INT_MIN, max_scan_interval) &&
1729             BTM_BLE_ISVALID_PARAM(scan_window, BTM_BLE_SCAN_WIN_MIN, max_scan_window) &&
1730             (scan_mode == BTM_BLE_SCAN_MODE_ACTI || scan_mode == BTM_BLE_SCAN_MODE_PASS) &&
1731             (scan_duplicate_filter < BTM_BLE_SCAN_DUPLICATE_MAX) && (scan_window <= scan_interval)) {
1732         p_cb->scan_type = scan_mode;
1733         p_cb->scan_interval = scan_interval;
1734         p_cb->scan_window = scan_window;
1735         p_cb->sfp = scan_filter_policy;
1736         p_cb->scan_params_set = TRUE;
1737         p_cb->scan_duplicate_filter = scan_duplicate_filter;
1738 
1739 
1740         if (btsnd_hcic_ble_set_scan_params(p_cb->scan_type, (UINT16)scan_interval,
1741                                        (UINT16)scan_window,
1742                                        addr_type_own,
1743                                        scan_filter_policy)) {
1744             osi_sem_take(&scan_param_sem, OSI_SEM_MAX_TIMEOUT);
1745             ret = scan_param_status;
1746         }
1747     } else {
1748         ret = BTM_ILLEGAL_VALUE;
1749         BTM_TRACE_ERROR("Illegal params: scan_interval = %d scan_window = %d\n",
1750                         scan_interval, scan_window);
1751     }
1752     osi_mutex_unlock(&scan_param_lock);
1753     return ret;
1754 }
1755 
1756 
1757 /*******************************************************************************
1758 **
1759 ** Function         BTM_BleWriteScanRsp
1760 **
1761 ** Description      This function is called to write LE scan response.
1762 **
1763 ** Parameters:      p_scan_rsp: scan response information.
1764 **
1765 ** Returns          void
1766 **
1767 *******************************************************************************/
BTM_BleWriteScanRsp(tBTM_BLE_AD_MASK data_mask,tBTM_BLE_ADV_DATA * p_data)1768 tBTM_STATUS BTM_BleWriteScanRsp(tBTM_BLE_AD_MASK data_mask, tBTM_BLE_ADV_DATA *p_data)
1769 {
1770     tBTM_STATUS     ret;
1771     UINT8   rsp_data[BTM_BLE_AD_DATA_LEN],
1772             *p = rsp_data;
1773 
1774     BTM_TRACE_EVENT (" BTM_BleWriteScanRsp");
1775 
1776     if (!controller_get_interface()->supports_ble()) {
1777         return BTM_ILLEGAL_VALUE;
1778     }
1779 
1780     osi_mutex_lock(&adv_data_lock, OSI_MUTEX_MAX_TIMEOUT);
1781     memset(rsp_data, 0, BTM_BLE_AD_DATA_LEN);
1782     btm_ble_build_adv_data(&data_mask, &p, p_data);
1783     if (data_mask != 0) {
1784         //data length should not exceed 31 bytes
1785         BTM_TRACE_WARNING("%s, Partial data write into ADV", __func__);
1786     }
1787 
1788     if (btsnd_hcic_ble_set_scan_rsp_data((UINT8)(p - rsp_data), rsp_data)) {
1789         osi_sem_take(&adv_data_sem, OSI_SEM_MAX_TIMEOUT);
1790         ret = adv_data_status;
1791 
1792         if (adv_data_status == BTM_SUCCESS && data_mask != 0) {
1793             btm_cb.ble_ctr_cb.inq_var.scan_rsp = TRUE;
1794         } else {
1795             btm_cb.ble_ctr_cb.inq_var.scan_rsp = FALSE;
1796         }
1797     } else {
1798         ret = BTM_ILLEGAL_VALUE;
1799     }
1800 
1801     osi_mutex_unlock(&adv_data_lock);
1802     return ret;
1803 }
1804 
1805 /*******************************************************************************
1806 **
1807 ** Function         BTM_BleWriteScanRspRaw
1808 **
1809 ** Description      This function is called to write raw scan response data
1810 **
1811 ** Parameters:      None.
1812 **
1813 ** Returns          void
1814 **
1815 *******************************************************************************/
BTM_BleWriteScanRspRaw(UINT8 * p_raw_scan_rsp,UINT32 raw_scan_rsp_len)1816 tBTM_STATUS BTM_BleWriteScanRspRaw(UINT8 *p_raw_scan_rsp, UINT32 raw_scan_rsp_len)
1817 {
1818     tBTM_STATUS     ret;
1819 
1820     osi_mutex_lock(&adv_data_lock, OSI_MUTEX_MAX_TIMEOUT);
1821     if (btsnd_hcic_ble_set_scan_rsp_data((UINT8)raw_scan_rsp_len, p_raw_scan_rsp)) {
1822         osi_sem_take(&adv_data_sem, OSI_SEM_MAX_TIMEOUT);
1823         ret = adv_data_status;
1824     } else {
1825         ret = BTM_NO_RESOURCES;
1826     }
1827     osi_mutex_unlock(&adv_data_lock);
1828 
1829     return ret;
1830 }
1831 
1832 /*******************************************************************************
1833 **
1834 ** Function         BTM_UpdateBleDuplicateExceptionalList
1835 **
1836 ** Description      This function is called to update duplicate scan exceptional list.
1837 **
1838 ** Parameters:      subcode: add, remove or clean duplicate scan exceptional list.
1839 **                  type: device info type
1840 **                  device_info: device information
1841 **                  update_exceptional_list_cmp_cb: complete callback
1842 **
1843 ** Returns          status
1844 **
1845 *******************************************************************************/
BTM_UpdateBleDuplicateExceptionalList(uint8_t subcode,uint32_t type,BD_ADDR device_info,tBTM_UPDATE_DUPLICATE_EXCEPTIONAL_LIST_CMPL_CBACK update_exceptional_list_cmp_cb)1846 tBTM_STATUS BTM_UpdateBleDuplicateExceptionalList(uint8_t subcode, uint32_t type, BD_ADDR device_info,
1847                                                 tBTM_UPDATE_DUPLICATE_EXCEPTIONAL_LIST_CMPL_CBACK update_exceptional_list_cmp_cb)
1848 {
1849     tBTM_BLE_CB *ble_cb = &btm_cb.ble_ctr_cb;
1850     tBTM_STATUS status = BTM_NO_RESOURCES;
1851 
1852     ble_cb->update_exceptional_list_cmp_cb = update_exceptional_list_cmp_cb;
1853 
1854     if (!controller_get_interface()->supports_ble()) {
1855         return BTM_ILLEGAL_VALUE;
1856     }
1857     if(!device_info) {
1858         return BTM_ILLEGAL_VALUE;
1859     }
1860     // subcoe + type + device info
1861     uint8_t device_info_array[1 + 4 + BD_ADDR_LEN] = {0};
1862     device_info_array[0] = subcode;
1863     device_info_array[1] = type & 0xff;
1864     device_info_array[2] = (type >> 8) & 0xff;
1865     device_info_array[3] = (type >> 16) & 0xff;
1866     device_info_array[4] = (type >> 24) & 0xff;
1867     switch (type)
1868     {
1869         case BTM_DUPLICATE_SCAN_EXCEPTIONAL_INFO_ADV_ADDR:
1870             bt_rcopy(&device_info_array[5], device_info, BD_ADDR_LEN);
1871             break;
1872         case BTM_DUPLICATE_SCAN_EXCEPTIONAL_INFO_MESH_LINK_ID:
1873             memcpy(&device_info_array[5], device_info, 4);
1874             break;
1875         case BTM_DUPLICATE_SCAN_EXCEPTIONAL_INFO_MESH_BEACON_TYPE:
1876             //do nothing
1877             break;
1878         case BTM_DUPLICATE_SCAN_EXCEPTIONAL_INFO_MESH_PROV_SRV_ADV:
1879             //do nothing
1880             break;
1881         case BTM_DUPLICATE_SCAN_EXCEPTIONAL_INFO_MESH_PROXY_SRV_ADV:
1882             //do nothing
1883             break;
1884         default:
1885             //do nothing
1886             break;
1887     }
1888 
1889     status = BTM_VendorSpecificCommand(HCI_VENDOR_BLE_UPDATE_DUPLICATE_EXCEPTIONAL_LIST, 1 + 4 + BD_ADDR_LEN, device_info_array, NULL);
1890     if(status == BTM_CMD_STARTED) {
1891         status = BTM_SUCCESS;
1892     }
1893 
1894     return status;
1895 }
1896 
1897 /*******************************************************************************
1898 **
1899 ** Function         BTM_BleWriteAdvData
1900 **
1901 ** Description      This function is called to write advertising data.
1902 **
1903 ** Parameters:       None.
1904 **
1905 ** Returns          void
1906 **
1907 *******************************************************************************/
BTM_BleWriteAdvData(tBTM_BLE_AD_MASK data_mask,tBTM_BLE_ADV_DATA * p_data)1908 tBTM_STATUS BTM_BleWriteAdvData(tBTM_BLE_AD_MASK data_mask, tBTM_BLE_ADV_DATA *p_data)
1909 {
1910     tBTM_BLE_LOCAL_ADV_DATA *p_cb_data = &btm_cb.ble_ctr_cb.inq_var.adv_data;
1911     UINT8  *p;
1912     tBTM_BLE_AD_MASK   mask = data_mask;
1913     tBTM_STATUS ret;
1914 
1915     BTM_TRACE_EVENT ("BTM_BleWriteAdvData ");
1916 
1917     if (!controller_get_interface()->supports_ble()) {
1918         return BTM_ILLEGAL_VALUE;
1919     }
1920     osi_mutex_lock(&adv_data_lock, OSI_MUTEX_MAX_TIMEOUT);
1921     memset(p_cb_data, 0, sizeof(tBTM_BLE_LOCAL_ADV_DATA));
1922     p = p_cb_data->ad_data;
1923     p_cb_data->data_mask = data_mask;
1924 
1925     p_cb_data->p_flags = btm_ble_build_adv_data(&mask, &p, p_data);
1926 
1927     p_cb_data->p_pad = p;
1928 
1929     if (mask != 0) {
1930         //data length should not exceed 31 bytes
1931         BTM_TRACE_WARNING("%s, Partial data write into ADV", __func__);
1932     }
1933 
1934     p_cb_data->data_mask &= ~mask;
1935 
1936     if (btsnd_hcic_ble_set_adv_data((UINT8)(p_cb_data->p_pad - p_cb_data->ad_data),
1937                                     p_cb_data->ad_data)) {
1938         osi_sem_take(&adv_data_sem, OSI_SEM_MAX_TIMEOUT);
1939         ret = adv_data_status;
1940     } else {
1941         ret = BTM_NO_RESOURCES;
1942     }
1943     osi_mutex_unlock(&adv_data_lock);
1944     return ret;
1945 }
1946 
1947 /*******************************************************************************
1948 **
1949 ** Function         BTM_BleWriteLongAdvData
1950 **
1951 ** Description      This function is called to write long advertising data.
1952 **
1953 ** Parameters:      adv_data: long advertising data
1954 **                  adv_data_len: the length of long advertising data
1955 **
1956 ** Returns          void
1957 **
1958 *******************************************************************************/
BTM_BleWriteLongAdvData(uint8_t * adv_data,uint8_t adv_data_len)1959 tBTM_STATUS BTM_BleWriteLongAdvData(uint8_t *adv_data, uint8_t adv_data_len)
1960 {
1961     tBTM_STATUS status = BTM_NO_RESOURCES;
1962     if (!controller_get_interface()->supports_ble()) {
1963         return BTM_ILLEGAL_VALUE;
1964     }
1965     if(!adv_data || adv_data_len <= 0 || adv_data_len > BTM_BLE_LONG_ADV_MAX_LEN) {
1966         return BTM_ILLEGAL_VALUE;
1967     }
1968     uint8_t long_adv[BTM_BLE_LONG_ADV_MAX_LEN + 1] = {0};
1969     long_adv[0] = adv_data_len;
1970     memcpy(&long_adv[1], adv_data, adv_data_len);
1971     status = BTM_VendorSpecificCommand(HCI_VENDOR_BLE_LONG_ADV_DATA, BTM_BLE_LONG_ADV_MAX_LEN + 1, long_adv, NULL);
1972     if(status == BTM_CMD_STARTED) {
1973         status = BTM_SUCCESS;
1974     }
1975 
1976     return status;
1977 }
1978 
1979 /*******************************************************************************
1980 **
1981 ** Function         BTM_BleWriteAdvDataRaw
1982 **
1983 ** Description      This function is called to write raw advertising data.
1984 **
1985 ** Parameters:       None.
1986 **
1987 ** Returns          void
1988 **
1989 *******************************************************************************/
BTM_BleWriteAdvDataRaw(UINT8 * p_raw_adv,UINT32 raw_adv_len)1990 tBTM_STATUS BTM_BleWriteAdvDataRaw(UINT8 *p_raw_adv, UINT32 raw_adv_len)
1991 {
1992     tBTM_STATUS ret;
1993     osi_mutex_lock(&adv_data_lock, OSI_MUTEX_MAX_TIMEOUT);
1994     if (btsnd_hcic_ble_set_adv_data((UINT8)raw_adv_len, p_raw_adv)) {
1995         osi_sem_take(&adv_data_sem, OSI_SEM_MAX_TIMEOUT);
1996         ret = adv_data_status;
1997     } else {
1998         ret = BTM_NO_RESOURCES;
1999     }
2000     osi_mutex_unlock(&adv_data_lock);
2001 
2002     return ret;
2003 }
2004 
2005 
2006 /*******************************************************************************
2007 **
2008 ** Function         BTM_BleSetRandAddress
2009 **
2010 ** Description      This function is called to set the LE random address.
2011 **
2012 ** Parameters:       None.
2013 **
2014 ** Returns          void
2015 **
2016 *******************************************************************************/
BTM_BleSetRandAddress(BD_ADDR rand_addr)2017 tBTM_STATUS BTM_BleSetRandAddress(BD_ADDR rand_addr)
2018 {
2019 	if (rand_addr == NULL) {
2020 		return BTM_SET_STATIC_RAND_ADDR_FAIL;
2021     }
2022 
2023     if (btm_cb.ble_ctr_cb.inq_var.state != BTM_BLE_IDLE) {
2024         BTM_TRACE_ERROR("Advertising or scanning now, can't set randaddress %d", btm_cb.ble_ctr_cb.inq_var.state);
2025         return BTM_SET_STATIC_RAND_ADDR_FAIL;
2026     }
2027     memcpy(btm_cb.ble_ctr_cb.addr_mgnt_cb.private_addr, rand_addr, BD_ADDR_LEN);
2028     memcpy(btm_cb.ble_ctr_cb.addr_mgnt_cb.static_rand_addr, rand_addr, BD_ADDR_LEN);
2029     //send the set random address to the controller
2030     if(btsnd_hcic_ble_set_random_addr(rand_addr)) {
2031         btm_cb.ble_ctr_cb.addr_mgnt_cb.exist_addr_bit |= BTM_BLE_GAP_ADDR_BIT_RANDOM;
2032         return BTM_SUCCESS;
2033     } else {
2034         return BTM_SET_STATIC_RAND_ADDR_FAIL;
2035     }
2036 }
2037 
2038 /*******************************************************************************
2039 **
2040 ** Function         BTM_BleClearRandAddress
2041 **
2042 ** Description      This function is called to clear the LE random address.
2043 **
2044 ** Parameters:       None.
2045 **
2046 ** Returns          void
2047 **
2048 *******************************************************************************/
BTM_BleClearRandAddress(void)2049 void BTM_BleClearRandAddress(void)
2050 {
2051     tBTM_BLE_CB  *p_cb = &btm_cb.ble_ctr_cb;
2052     if (btm_cb.ble_ctr_cb.addr_mgnt_cb.own_addr_type == BLE_ADDR_RANDOM && (p_cb->inq_var.state != BTM_BLE_IDLE)) {
2053         BTM_TRACE_ERROR("Advertising or scanning now, can't restore public address ");
2054         return;
2055     }
2056     memset(btm_cb.ble_ctr_cb.addr_mgnt_cb.static_rand_addr, 0, BD_ADDR_LEN);
2057     btm_cb.ble_ctr_cb.addr_mgnt_cb.exist_addr_bit &= (~BTM_BLE_GAP_ADDR_BIT_RANDOM);
2058     btm_cb.ble_ctr_cb.addr_mgnt_cb.own_addr_type = BLE_ADDR_PUBLIC;
2059 }
2060 /*******************************************************************************
2061 **
2062 ** Function         BTM_BleGetCurrentAddress
2063 **
2064 ** Description      This function is called to get local used BLE address.
2065 **
2066 ** Parameters:       None.
2067 **
2068 ** Returns          success or fail
2069 **
2070 *******************************************************************************/
BTM_BleGetCurrentAddress(BD_ADDR addr,uint8_t * addr_type)2071 BOOLEAN BTM_BleGetCurrentAddress(BD_ADDR addr, uint8_t *addr_type)
2072 {
2073     if(addr == NULL || addr_type == NULL) {
2074         BTM_TRACE_ERROR("%s addr or addr_type is NULL\n", __func__);
2075         return FALSE;
2076     }
2077     if(btm_cb.ble_ctr_cb.addr_mgnt_cb.own_addr_type == BLE_ADDR_RANDOM) {
2078         *addr_type = BLE_ADDR_RANDOM;
2079         memcpy(addr, btm_cb.ble_ctr_cb.addr_mgnt_cb.private_addr, BD_ADDR_LEN);
2080     } else if(btm_cb.ble_ctr_cb.addr_mgnt_cb.own_addr_type == BLE_ADDR_PUBLIC) {
2081         *addr_type = BLE_ADDR_PUBLIC;
2082         memcpy(addr, &controller_get_interface()->get_address()->address, BD_ADDR_LEN);
2083     } else {
2084         BTM_TRACE_ERROR("%s\n", __func__);
2085         memset(addr, 0, BD_ADDR_LEN);
2086         return FALSE;
2087     }
2088     return TRUE;
2089 }
2090 
2091 /*******************************************************************************
2092 **
2093 ** Function         BTM_CheckAdvData
2094 **
2095 ** Description      This function is called to get ADV data for a specific type.
2096 **
2097 ** Parameters       p_adv - pointer of ADV data
2098 **                  type   - finding ADV data type
2099 **                  p_length - return the length of ADV data not including type
2100 **
2101 ** Returns          pointer of ADV data
2102 **
2103 *******************************************************************************/
BTM_CheckAdvData(UINT8 * p_adv,UINT16 adv_data_len,UINT8 type,UINT8 * p_length)2104 UINT8 *BTM_CheckAdvData( UINT8 *p_adv, UINT16 adv_data_len, UINT8 type, UINT8 *p_length)
2105 {
2106     UINT8 *p = p_adv;
2107     UINT8 length;
2108     UINT8 adv_type;
2109     BTM_TRACE_API("BTM_CheckAdvData type=0x%02X", type);
2110 
2111     STREAM_TO_UINT8(length, p);
2112 
2113     while ( length && (p - p_adv < adv_data_len)) {
2114         STREAM_TO_UINT8(adv_type, p);
2115 
2116         if ( adv_type == type ) {
2117             /* length doesn't include itself */
2118             *p_length = length - 1; /* minus the length of type */
2119             return p;
2120         }
2121 
2122         p += length - 1; /* skip the length of data */
2123 
2124         /* Break loop if advertising data is in an incorrect format,
2125            as it may lead to memory overflow */
2126         if (p >= p_adv + adv_data_len) {
2127             break;
2128         }
2129 
2130         STREAM_TO_UINT8(length, p);
2131     }
2132 
2133     *p_length = 0;
2134     return NULL;
2135 }
2136 
2137 /*******************************************************************************
2138 **
2139 ** Function         BTM__BLEReadDiscoverability
2140 **
2141 ** Description      This function is called to read the current LE discoverability
2142 **                  mode of the device.
2143 **
2144 ** Returns          BTM_BLE_NON_DISCOVERABLE ,BTM_BLE_LIMITED_DISCOVERABLE or
2145 **                     BTM_BLE_GENRAL_DISCOVERABLE
2146 **
2147 *******************************************************************************/
BTM_BleReadDiscoverability(void)2148 UINT16 BTM_BleReadDiscoverability(void)
2149 {
2150     BTM_TRACE_API("%s\n", __FUNCTION__);
2151 
2152     return (btm_cb.ble_ctr_cb.inq_var.discoverable_mode);
2153 }
2154 
2155 /*******************************************************************************
2156 **
2157 ** Function         BTM__BLEReadConnectability
2158 **
2159 ** Description      This function is called to read the current LE connectibility
2160 **                  mode of the device.
2161 **
2162 ** Returns          BTM_BLE_NON_CONNECTABLE or BTM_BLE_CONNECTABLE
2163 **
2164 *******************************************************************************/
BTM_BleReadConnectability(void)2165 UINT16 BTM_BleReadConnectability(void)
2166 {
2167     BTM_TRACE_API ("%s\n", __FUNCTION__);
2168 
2169     return (btm_cb.ble_ctr_cb.inq_var.connectable_mode);
2170 }
2171 
BTM_Recovery_Pre_State(void)2172 void BTM_Recovery_Pre_State(void)
2173 {
2174     tBTM_BLE_INQ_CB *ble_inq_cb = &btm_cb.ble_ctr_cb.inq_var;
2175 
2176     if (ble_inq_cb->state & BTM_BLE_ADVERTISING) {
2177         btm_ble_stop_adv();
2178         btm_ble_start_adv();
2179     }
2180     if (ble_inq_cb->state & BTM_BLE_SCANNING) {
2181         btm_ble_start_scan();
2182     }
2183 
2184     return;
2185 }
2186 
2187 /*******************************************************************************
2188 **
2189 ** Function         BTM_GetCurrentConnParams
2190 **
2191 ** Description      This function is called to read the current connection parameters
2192 **                  of the device
2193 **
2194 ** Returns          TRUE or FALSE
2195 **
2196 *******************************************************************************/
2197 
BTM_GetCurrentConnParams(BD_ADDR bda,uint16_t * interval,uint16_t * latency,uint16_t * timeout)2198 BOOLEAN BTM_GetCurrentConnParams(BD_ADDR bda, uint16_t *interval, uint16_t *latency, uint16_t *timeout)
2199 {
2200     if( (interval == NULL) || (latency == NULL) || (timeout == NULL) ) {
2201         BTM_TRACE_ERROR("%s error ", __func__);
2202         return FALSE;
2203     }
2204 
2205     if(btm_get_current_conn_params(bda, interval, latency, timeout)) {
2206         return TRUE;
2207     }
2208 
2209     return FALSE;
2210 }
2211 
2212 /*******************************************************************************
2213 **
2214 ** Function         btm_ble_build_adv_data
2215 **
2216 ** Description      This function is called build the adv data and rsp data.
2217 *******************************************************************************/
btm_ble_build_adv_data(tBTM_BLE_AD_MASK * p_data_mask,UINT8 ** p_dst,tBTM_BLE_ADV_DATA * p_data)2218 UINT8 *btm_ble_build_adv_data(tBTM_BLE_AD_MASK *p_data_mask, UINT8 **p_dst,
2219                               tBTM_BLE_ADV_DATA *p_data)
2220 {
2221     UINT32 data_mask = *p_data_mask;
2222     UINT8   *p = *p_dst,
2223              *p_flag = NULL;
2224     UINT16  len = BTM_BLE_AD_DATA_LEN, cp_len = 0;
2225     UINT8   i = 0;
2226     tBTM_BLE_PROP_ELEM      *p_elem;
2227 
2228     BTM_TRACE_EVENT (" btm_ble_build_adv_data");
2229 
2230     /* build the adv data structure and build the data string */
2231     if (data_mask) {
2232         /* flags */
2233         if (data_mask & BTM_BLE_AD_BIT_FLAGS) {
2234             *p++ = MIN_ADV_LENGTH;
2235             *p++ = BTM_BLE_AD_TYPE_FLAG;
2236             p_flag = p;
2237             if (p_data) {
2238                 *p++ = p_data->flag;
2239             } else {
2240                 *p++ = 0;
2241             }
2242 
2243             len -= 3;
2244 
2245             data_mask &= ~BTM_BLE_AD_BIT_FLAGS;
2246         }
2247         /* appearance data */
2248         if (len > 3 && data_mask & BTM_BLE_AD_BIT_APPEARANCE) {
2249             *p++ = 3; /* length */
2250             *p++ = BTM_BLE_AD_TYPE_APPEARANCE;
2251             UINT16_TO_STREAM(p, p_data->appearance);
2252             len -= 4;
2253 
2254             data_mask &= ~BTM_BLE_AD_BIT_APPEARANCE;
2255         }
2256         /* device name */
2257 #if BTM_MAX_LOC_BD_NAME_LEN > 0
2258         if (len > MIN_ADV_LENGTH && data_mask & BTM_BLE_AD_BIT_DEV_NAME) {
2259             if (strlen(btm_cb.cfg.bd_name) > (UINT16)(len - MIN_ADV_LENGTH)) {
2260                 cp_len = (UINT16)(len - MIN_ADV_LENGTH);
2261                 *p++ = cp_len + 1;
2262                 *p++ = BTM_BLE_AD_TYPE_NAME_SHORT;
2263                 ARRAY_TO_STREAM(p, btm_cb.cfg.bd_name, cp_len);
2264             } else {
2265                 cp_len = (UINT16)strlen(btm_cb.cfg.bd_name);
2266                 *p++ = cp_len + 1;
2267                 *p++ = BTM_BLE_AD_TYPE_NAME_CMPL;
2268                 ARRAY_TO_STREAM(p, btm_cb.cfg.bd_name, cp_len);
2269             }
2270             len -= (cp_len + MIN_ADV_LENGTH);
2271             data_mask &= ~BTM_BLE_AD_BIT_DEV_NAME;
2272         }
2273 #endif
2274         /* manufacturer data */
2275         if (len > MIN_ADV_LENGTH && data_mask & BTM_BLE_AD_BIT_MANU &&
2276                 p_data && p_data->p_manu &&
2277                 p_data->p_manu->len != 0 && p_data->p_manu->p_val) {
2278             if (p_data->p_manu->len > (len - MIN_ADV_LENGTH)) {
2279                 cp_len = len - MIN_ADV_LENGTH;
2280             } else {
2281                 cp_len = p_data->p_manu->len;
2282             }
2283             BTM_TRACE_DEBUG("cp_len = %d\n,p_data->p_manu->len=%d\n", cp_len, p_data->p_manu->len);
2284             for (int i = 0; i < p_data->p_manu->len; i++) {
2285                 BTM_TRACE_DEBUG("p_data->p_manu->p_val[%d] = %x\n", i, p_data->p_manu->p_val[i]);
2286             }
2287             *p++ = cp_len + 1;
2288             *p++ = BTM_BLE_AD_TYPE_MANU;
2289             ARRAY_TO_STREAM(p, p_data->p_manu->p_val, cp_len);
2290             BTM_TRACE_DEBUG("p_addr = %p\n,p_data->p_manu->p_val = %p\n", p, p_data->p_manu->p_val);
2291             len -= (cp_len + MIN_ADV_LENGTH);
2292             data_mask &= ~BTM_BLE_AD_BIT_MANU;
2293         }
2294         /* TX power */
2295         if (len > MIN_ADV_LENGTH && data_mask & BTM_BLE_AD_BIT_TX_PWR) {
2296             *p++ = MIN_ADV_LENGTH;
2297             *p++ = BTM_BLE_AD_TYPE_TX_PWR;
2298             if (p_data->tx_power > BTM_BLE_ADV_TX_POWER_MAX) {
2299                 p_data->tx_power = BTM_BLE_ADV_TX_POWER_MAX;
2300             }
2301             *p++ = btm_ble_map_adv_tx_power(p_data->tx_power);
2302             len -= 3;
2303             data_mask &= ~BTM_BLE_AD_BIT_TX_PWR;
2304         }
2305         /* 16 bits services */
2306         if (len > MIN_ADV_LENGTH && data_mask & BTM_BLE_AD_BIT_SERVICE &&
2307                 p_data && p_data->p_services &&
2308                 p_data->p_services->num_service != 0 &&
2309                 p_data->p_services->p_uuid) {
2310             if (p_data->p_services->num_service * LEN_UUID_16 > (len - MIN_ADV_LENGTH)) {
2311                 cp_len = (len - MIN_ADV_LENGTH) / LEN_UUID_16;
2312                 *p ++ = 1 + cp_len * LEN_UUID_16;
2313                 *p++ = BTM_BLE_AD_TYPE_16SRV_PART;
2314             } else {
2315                 cp_len = p_data->p_services->num_service;
2316                 *p++ = 1 + cp_len * LEN_UUID_16;
2317                 *p++ = BTM_BLE_AD_TYPE_16SRV_CMPL;
2318             }
2319             for (i = 0; i < cp_len; i ++) {
2320                 UINT16_TO_STREAM(p, *(p_data->p_services->p_uuid + i));
2321             }
2322 
2323             len -= (cp_len * MIN_ADV_LENGTH + MIN_ADV_LENGTH);
2324             data_mask &= ~BTM_BLE_AD_BIT_SERVICE;
2325         }
2326         /* 32 bits service uuid */
2327         if (len > MIN_ADV_LENGTH && data_mask & BTM_BLE_AD_BIT_SERVICE_32 &&
2328                 p_data && p_data->p_service_32b &&
2329                 p_data->p_service_32b->num_service != 0 &&
2330                 p_data->p_service_32b->p_uuid) {
2331             if ((p_data->p_service_32b->num_service * LEN_UUID_32) > (len - MIN_ADV_LENGTH)) {
2332                 cp_len = (len - MIN_ADV_LENGTH) / LEN_UUID_32;
2333                 *p ++ = 1 + cp_len * LEN_UUID_32;
2334                 *p++ = BTM_BLE_AD_TYPE_32SRV_PART;
2335             } else {
2336                 cp_len = p_data->p_service_32b->num_service;
2337                 *p++ = 1 + cp_len * LEN_UUID_32;
2338                 *p++ = BTM_BLE_AD_TYPE_32SRV_CMPL;
2339             }
2340             for (i = 0; i < cp_len; i ++) {
2341                 UINT32_TO_STREAM(p, *(p_data->p_service_32b->p_uuid + i));
2342             }
2343 
2344             len -= (cp_len * LEN_UUID_32 + MIN_ADV_LENGTH);
2345             data_mask &= ~BTM_BLE_AD_BIT_SERVICE_32;
2346         }
2347         /* 128 bits services */
2348         if (len >= (MAX_UUID_SIZE + 2) && data_mask & BTM_BLE_AD_BIT_SERVICE_128 &&
2349                 p_data && p_data->p_services_128b) {
2350             *p ++ = 1 + MAX_UUID_SIZE;
2351             if (!p_data->p_services_128b->list_cmpl) {
2352                 *p++ = BTM_BLE_AD_TYPE_128SRV_PART;
2353             } else {
2354                 *p++ = BTM_BLE_AD_TYPE_128SRV_CMPL;
2355             }
2356 
2357             ARRAY_TO_STREAM(p, p_data->p_services_128b->uuid128, MAX_UUID_SIZE);
2358 
2359             len -= (MAX_UUID_SIZE + MIN_ADV_LENGTH);
2360             data_mask &= ~BTM_BLE_AD_BIT_SERVICE_128;
2361         }
2362         /* 32 bits Service Solicitation UUIDs */
2363         if (len > MIN_ADV_LENGTH && data_mask & BTM_BLE_AD_BIT_SERVICE_32SOL &&
2364                 p_data && p_data->p_sol_service_32b &&
2365                 p_data->p_sol_service_32b->num_service != 0 &&
2366                 p_data->p_sol_service_32b->p_uuid) {
2367             if ((p_data->p_sol_service_32b->num_service * LEN_UUID_32) > (len - MIN_ADV_LENGTH)) {
2368                 cp_len = (len - MIN_ADV_LENGTH) / LEN_UUID_32;
2369                 *p ++ = 1 + cp_len * LEN_UUID_32;
2370             } else {
2371                 cp_len = p_data->p_sol_service_32b->num_service;
2372                 *p++ = 1 + cp_len * LEN_UUID_32;
2373             }
2374 
2375             *p++ = BTM_BLE_AD_TYPE_32SOL_SRV_UUID;
2376             for (i = 0; i < cp_len; i ++) {
2377                 UINT32_TO_STREAM(p, *(p_data->p_sol_service_32b->p_uuid + i));
2378             }
2379 
2380             len -= (cp_len * LEN_UUID_32 + MIN_ADV_LENGTH);
2381             data_mask &= ~BTM_BLE_AD_BIT_SERVICE_32SOL;
2382         }
2383         /* 128 bits Solicitation services UUID */
2384         if (len >= (MAX_UUID_SIZE + MIN_ADV_LENGTH) && data_mask & BTM_BLE_AD_BIT_SERVICE_128SOL &&
2385                 p_data && p_data->p_sol_service_128b) {
2386             *p ++ = 1 + MAX_UUID_SIZE;
2387             *p++ = BTM_BLE_AD_TYPE_128SOL_SRV_UUID;
2388             ARRAY_TO_STREAM(p, p_data->p_sol_service_128b->uuid128, MAX_UUID_SIZE);
2389             len -= (MAX_UUID_SIZE + MIN_ADV_LENGTH);
2390             data_mask &= ~BTM_BLE_AD_BIT_SERVICE_128SOL;
2391         }
2392         /* 16bits/32bits/128bits Service Data */
2393         if (len > MIN_ADV_LENGTH && data_mask & BTM_BLE_AD_BIT_SERVICE_DATA &&
2394                 p_data && p_data->p_service_data->len != 0 && p_data->p_service_data->p_val) {
2395             if (len  > (p_data->p_service_data->service_uuid.len + MIN_ADV_LENGTH)) {
2396                 if (p_data->p_service_data->len > (len - MIN_ADV_LENGTH)) {
2397                     cp_len = len - MIN_ADV_LENGTH - p_data->p_service_data->service_uuid.len;
2398                 } else {
2399                     cp_len = p_data->p_service_data->len;
2400                 }
2401 
2402                 *p++ = cp_len + 1 + p_data->p_service_data->service_uuid.len;
2403                 if (p_data->p_service_data->service_uuid.len == LEN_UUID_16) {
2404                     *p++ = BTM_BLE_AD_TYPE_SERVICE_DATA;
2405                     UINT16_TO_STREAM(p, p_data->p_service_data->service_uuid.uu.uuid16);
2406                 } else if (p_data->p_service_data->service_uuid.len == LEN_UUID_32) {
2407                     *p++ = BTM_BLE_AD_TYPE_32SERVICE_DATA;
2408                     UINT32_TO_STREAM(p, p_data->p_service_data->service_uuid.uu.uuid32);
2409                 } else {
2410                     *p++ = BTM_BLE_AD_TYPE_128SERVICE_DATA;
2411                     ARRAY_TO_STREAM(p, p_data->p_service_data->service_uuid.uu.uuid128,
2412                                     LEN_UUID_128);
2413                 }
2414 
2415                 ARRAY_TO_STREAM(p, p_data->p_service_data->p_val, cp_len);
2416 
2417                 len -= (cp_len + MIN_ADV_LENGTH + p_data->p_service_data->service_uuid.len);
2418                 data_mask &= ~BTM_BLE_AD_BIT_SERVICE_DATA;
2419             } else {
2420                 BTM_TRACE_WARNING("service data does not fit");
2421             }
2422         }
2423 
2424         if (len >= 6 && data_mask & BTM_BLE_AD_BIT_INT_RANGE &&
2425                 p_data) {
2426             *p++ = 5;
2427             *p++ = BTM_BLE_AD_TYPE_INT_RANGE;
2428             UINT16_TO_STREAM(p, p_data->int_range.low);
2429             UINT16_TO_STREAM(p, p_data->int_range.hi);
2430             len -= 6;
2431             data_mask &= ~BTM_BLE_AD_BIT_INT_RANGE;
2432         }
2433         if (data_mask & BTM_BLE_AD_BIT_PROPRIETARY && p_data && p_data->p_proprietary) {
2434             for (i = 0; i < p_data->p_proprietary->num_elem ; i ++) {
2435                 p_elem = p_data->p_proprietary->p_elem  + i;
2436 
2437                 if (len >= (MIN_ADV_LENGTH + p_elem->len))/* len byte(1) + ATTR type(1) + Uuid len(2)
2438                                                           + value length */
2439                 {
2440                     *p ++ = p_elem->len + 1; /* Uuid len + value length */
2441                     *p ++ = p_elem->adv_type;
2442                     ARRAY_TO_STREAM(p, p_elem->p_val, p_elem->len);
2443 
2444                     len -= (MIN_ADV_LENGTH + p_elem->len);
2445                 } else {
2446                     BTM_TRACE_WARNING("data exceed max adv packet length");
2447                     break;
2448                 }
2449             }
2450             data_mask &= ~BTM_BLE_AD_BIT_PROPRIETARY;
2451         }
2452     }
2453 
2454     *p_data_mask = data_mask;
2455     *p_dst = p;
2456 
2457     return p_flag;
2458 }
2459 /*******************************************************************************
2460 **
2461 ** Function         btm_ble_select_adv_interval
2462 **
2463 ** Description      select adv interval based on device mode
2464 **
2465 ** Returns          void
2466 **
2467 *******************************************************************************/
btm_ble_select_adv_interval(tBTM_BLE_INQ_CB * p_cb,UINT8 evt_type,UINT16 * p_adv_int_min,UINT16 * p_adv_int_max)2468 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)
2469 {
2470     if (p_cb->adv_interval_min && p_cb->adv_interval_max) {
2471         *p_adv_int_min = p_cb->adv_interval_min;
2472         *p_adv_int_max = p_cb->adv_interval_max;
2473     } else {
2474         switch (evt_type) {
2475         case BTM_BLE_CONNECT_EVT:
2476         case BTM_BLE_CONNECT_LO_DUTY_DIR_EVT:
2477             *p_adv_int_min = *p_adv_int_max = BTM_BLE_GAP_ADV_FAST_INT_1;
2478             break;
2479 
2480         case BTM_BLE_NON_CONNECT_EVT:
2481         case BTM_BLE_DISCOVER_EVT:
2482             *p_adv_int_min = *p_adv_int_max = BTM_BLE_GAP_ADV_FAST_INT_2;
2483             break;
2484 
2485         /* connectable directed event */
2486         case BTM_BLE_CONNECT_DIR_EVT:
2487             *p_adv_int_min = BTM_BLE_GAP_ADV_DIR_MIN_INT;
2488             *p_adv_int_max = BTM_BLE_GAP_ADV_DIR_MAX_INT;
2489             break;
2490 
2491         default:
2492             *p_adv_int_min = *p_adv_int_max = BTM_BLE_GAP_ADV_SLOW_INT;
2493             break;
2494         }
2495     }
2496     return;
2497 }
2498 
2499 /*******************************************************************************
2500 **
2501 ** Function         btm_ble_update_dmt_flag_bits
2502 **
2503 ** Description      Obtain updated adv flag value based on connect and discoverability mode.
2504 **                  Also, setup DMT support value in the flag based on whether the controller
2505 **                  supports both LE and BR/EDR.
2506 **
2507 ** Parameters:      flag_value (Input / Output) - flag value
2508 **                  connect_mode (Input) - Connect mode value
2509 **                  disc_mode (Input) - discoverability mode
2510 **
2511 ** Returns          void
2512 **
2513 *******************************************************************************/
btm_ble_update_dmt_flag_bits(UINT8 * adv_flag_value,const UINT16 connect_mode,const UINT16 disc_mode)2514 void btm_ble_update_dmt_flag_bits(UINT8 *adv_flag_value, const UINT16 connect_mode,
2515                                   const UINT16 disc_mode)
2516 {
2517     /* BR/EDR non-discoverable , non-connectable */
2518     if ((disc_mode & BTM_DISCOVERABLE_MASK) == 0 &&
2519             (connect_mode & BTM_CONNECTABLE_MASK) == 0) {
2520         *adv_flag_value |= BTM_BLE_BREDR_NOT_SPT;
2521     } else {
2522         *adv_flag_value &= ~BTM_BLE_BREDR_NOT_SPT;
2523     }
2524 
2525     /* if local controller support, mark both controller and host support in flag */
2526     if (controller_get_interface()->supports_simultaneous_le_bredr()) {
2527         *adv_flag_value |= (BTM_BLE_DMT_CONTROLLER_SPT | BTM_BLE_DMT_HOST_SPT);
2528     } else {
2529         *adv_flag_value &= ~(BTM_BLE_DMT_CONTROLLER_SPT | BTM_BLE_DMT_HOST_SPT);
2530     }
2531 }
2532 
2533 /*******************************************************************************
2534 **
2535 ** Function         btm_ble_set_adv_flag
2536 **
2537 ** Description      Set adv flag in adv data.
2538 **
2539 ** Parameters:      connect_mode (Input)- Connect mode value
2540 **                  disc_mode (Input) - discoverability mode
2541 **
2542 ** Returns          void
2543 **
2544 *******************************************************************************/
btm_ble_set_adv_flag(UINT16 connect_mode,UINT16 disc_mode)2545 void btm_ble_set_adv_flag(UINT16 connect_mode, UINT16 disc_mode)
2546 {
2547     UINT8 flag = 0, old_flag = 0;
2548     tBTM_BLE_LOCAL_ADV_DATA *p_adv_data = &btm_cb.ble_ctr_cb.inq_var.adv_data;
2549 
2550     if (p_adv_data->p_flags != NULL) {
2551         flag = old_flag = *(p_adv_data->p_flags);
2552     }
2553 
2554     btm_ble_update_dmt_flag_bits (&flag, connect_mode, disc_mode);
2555 
2556     BTM_TRACE_DEBUG("disc_mode %04x", disc_mode);
2557     /* update discoverable flag */
2558     if (disc_mode & BTM_BLE_LIMITED_DISCOVERABLE) {
2559         flag &= ~BTM_BLE_GEN_DISC_FLAG;
2560         flag |= BTM_BLE_LIMIT_DISC_FLAG;
2561     } else if (disc_mode & BTM_BLE_GENERAL_DISCOVERABLE) {
2562         flag |= BTM_BLE_GEN_DISC_FLAG;
2563         flag &= ~BTM_BLE_LIMIT_DISC_FLAG;
2564     } else { /* remove all discoverable flags */
2565         flag &= ~(BTM_BLE_LIMIT_DISC_FLAG | BTM_BLE_GEN_DISC_FLAG);
2566     }
2567 
2568     if (flag != old_flag) {
2569         BTM_TRACE_ERROR("flag = 0x%x,old_flag = 0x%x", flag, old_flag);
2570         btm_ble_update_adv_flag(flag);
2571     }
2572 }
2573 /*******************************************************************************
2574 **
2575 ** Function         btm_ble_set_discoverability
2576 **
2577 ** Description      This function is called to set BLE discoverable mode.
2578 **
2579 ** Parameters:      combined_mode: discoverability mode.
2580 **
2581 ** Returns          BTM_SUCCESS is status set successfully; otherwise failure.
2582 **
2583 *******************************************************************************/
btm_ble_set_discoverability(UINT16 combined_mode)2584 tBTM_STATUS btm_ble_set_discoverability(UINT16 combined_mode)
2585 {
2586     tBTM_LE_RANDOM_CB   *p_addr_cb = &btm_cb.ble_ctr_cb.addr_mgnt_cb;
2587     tBTM_BLE_INQ_CB     *p_cb = &btm_cb.ble_ctr_cb.inq_var;
2588     UINT16              mode = (combined_mode &  BTM_BLE_DISCOVERABLE_MASK);
2589     UINT8               new_mode = BTM_BLE_ADV_ENABLE;
2590     UINT8               evt_type;
2591     tBTM_STATUS         status = BTM_SUCCESS;
2592     BD_ADDR             p_addr_ptr = {0};
2593     tBLE_ADDR_TYPE      init_addr_type = BLE_ADDR_PUBLIC,
2594                         own_addr_type = p_addr_cb->own_addr_type;
2595     UINT16              adv_int_min, adv_int_max;
2596 
2597     BTM_TRACE_EVENT ("%s mode=0x%0x combined_mode=0x%x\n", __FUNCTION__, mode, combined_mode);
2598 
2599     /*** Check mode parameter ***/
2600     if (mode > BTM_BLE_MAX_DISCOVERABLE) {
2601         return (BTM_ILLEGAL_VALUE);
2602     }
2603 
2604     p_cb->discoverable_mode = mode;
2605 
2606     evt_type = btm_set_conn_mode_adv_init_addr(p_cb, p_addr_ptr, &init_addr_type, &own_addr_type);
2607 
2608     if (p_cb->connectable_mode == BTM_BLE_NON_CONNECTABLE && mode == BTM_BLE_NON_DISCOVERABLE) {
2609         new_mode = BTM_BLE_ADV_DISABLE;
2610     }
2611 
2612     btm_ble_select_adv_interval(p_cb, evt_type, &adv_int_min, &adv_int_max);
2613 
2614     btu_stop_timer(&p_cb->fast_adv_timer);
2615 
2616     /* update adv params if start advertising */
2617     BTM_TRACE_EVENT ("evt_type=0x%x p-cb->evt_type=0x%x\n ", evt_type, p_cb->evt_type);
2618 
2619     if (new_mode == BTM_BLE_ADV_ENABLE) {
2620         btm_ble_set_adv_flag (btm_cb.btm_inq_vars.connectable_mode, combined_mode);
2621 
2622         if (evt_type != p_cb->evt_type || p_cb->adv_addr_type != own_addr_type
2623                 || !p_cb->fast_adv_on) {
2624             btm_ble_stop_adv();
2625 
2626             /* update adv params */
2627             if (!btsnd_hcic_ble_write_adv_params (adv_int_min,
2628                                                   adv_int_max,
2629                                                   evt_type,
2630                                                   own_addr_type,
2631                                                   init_addr_type,
2632                                                   p_addr_ptr,
2633                                                   p_cb->adv_chnl_map,
2634                                                   p_cb->afp)) {
2635                 status = BTM_NO_RESOURCES;
2636             } else {
2637                 p_cb->evt_type = evt_type;
2638                 p_cb->adv_addr_type = own_addr_type;
2639             }
2640         }
2641     }
2642 
2643     if (status == BTM_SUCCESS && p_cb->adv_mode != new_mode) {
2644         if (new_mode == BTM_BLE_ADV_ENABLE) {
2645             status = btm_ble_start_adv();
2646         } else {
2647             status = btm_ble_stop_adv();
2648         }
2649     }
2650 
2651     if (p_cb->adv_mode == BTM_BLE_ADV_ENABLE) {
2652         p_cb->fast_adv_on = TRUE;
2653         /* start initial GAP mode adv timer */
2654         btu_start_timer (&p_cb->fast_adv_timer, BTU_TTYPE_BLE_GAP_FAST_ADV,
2655                          BTM_BLE_GAP_FAST_ADV_TOUT);
2656     } else {
2657 #if BLE_PRIVACY_SPT == TRUE
2658         btm_ble_disable_resolving_list(BTM_BLE_RL_ADV, TRUE);
2659 #endif
2660     }
2661 
2662     /* set up stop advertising timer */
2663     if (status == BTM_SUCCESS && mode == BTM_BLE_LIMITED_DISCOVERABLE) {
2664         BTM_TRACE_EVENT ("start timer for limited disc mode duration=%d (180 secs)", BTM_BLE_GAP_LIM_TOUT);
2665         /* start Tgap(lim_timeout) */
2666         btu_start_timer (&p_cb->inq_timer_ent, BTU_TTYPE_BLE_GAP_LIM_DISC,
2667                          BTM_BLE_GAP_LIM_TOUT);
2668     }
2669     return status;
2670 }
2671 
2672 /*******************************************************************************
2673 **
2674 ** Function         btm_ble_set_connectability
2675 **
2676 ** Description      This function is called to set BLE connectability mode.
2677 **
2678 ** Parameters:      combined_mode: connectability mode.
2679 **
2680 ** Returns          BTM_SUCCESS is status set successfully; otherwise failure.
2681 **
2682 *******************************************************************************/
btm_ble_set_connectability(UINT16 combined_mode)2683 tBTM_STATUS btm_ble_set_connectability(UINT16 combined_mode)
2684 {
2685     tBTM_LE_RANDOM_CB       *p_addr_cb = &btm_cb.ble_ctr_cb.addr_mgnt_cb;
2686     tBTM_BLE_INQ_CB         *p_cb = &btm_cb.ble_ctr_cb.inq_var;
2687     UINT16                  mode = (combined_mode & BTM_BLE_CONNECTABLE_MASK);
2688     UINT8                   new_mode = BTM_BLE_ADV_ENABLE;
2689     UINT8                   evt_type;
2690     tBTM_STATUS             status = BTM_SUCCESS;
2691     BD_ADDR                 p_addr_ptr =  {0};
2692     tBLE_ADDR_TYPE          peer_addr_type = BLE_ADDR_PUBLIC,
2693                             own_addr_type = p_addr_cb->own_addr_type;
2694     UINT16                  adv_int_min, adv_int_max;
2695 
2696     BTM_TRACE_EVENT ("%s mode=0x%0x combined_mode=0x%x\n", __FUNCTION__, mode, combined_mode);
2697 
2698     /*** Check mode parameter ***/
2699     if (mode > BTM_BLE_MAX_CONNECTABLE) {
2700         return (BTM_ILLEGAL_VALUE);
2701     }
2702 
2703     p_cb->connectable_mode = mode;
2704 
2705     evt_type = btm_set_conn_mode_adv_init_addr(p_cb, p_addr_ptr, &peer_addr_type, &own_addr_type);
2706 
2707     if (mode == BTM_BLE_NON_CONNECTABLE && p_cb->discoverable_mode == BTM_BLE_NON_DISCOVERABLE) {
2708         new_mode = BTM_BLE_ADV_DISABLE;
2709     }
2710 
2711     btm_ble_select_adv_interval(p_cb, evt_type, &adv_int_min, &adv_int_max);
2712 
2713     btu_stop_timer(&p_cb->fast_adv_timer);
2714     /* update adv params if needed */
2715     if (new_mode == BTM_BLE_ADV_ENABLE) {
2716         btm_ble_set_adv_flag (combined_mode, btm_cb.btm_inq_vars.discoverable_mode);
2717         if (p_cb->evt_type != evt_type || p_cb->adv_addr_type != p_addr_cb->own_addr_type
2718                 || !p_cb->fast_adv_on) {
2719             btm_ble_stop_adv();
2720 
2721             if (!btsnd_hcic_ble_write_adv_params (adv_int_min,
2722                                                   adv_int_max,
2723                                                   evt_type,
2724                                                   own_addr_type,
2725                                                   peer_addr_type,
2726                                                   p_addr_ptr,
2727                                                   p_cb->adv_chnl_map,
2728                                                   p_cb->afp)) {
2729                 status = BTM_NO_RESOURCES;
2730             } else {
2731                 p_cb->evt_type = evt_type;
2732                 p_cb->adv_addr_type = own_addr_type;
2733             }
2734         }
2735     }
2736 
2737     /* update advertising mode */
2738     if (status == BTM_SUCCESS && new_mode != p_cb->adv_mode) {
2739         if (new_mode == BTM_BLE_ADV_ENABLE) {
2740             status = btm_ble_start_adv();
2741         } else {
2742             status = btm_ble_stop_adv();
2743         }
2744     }
2745 
2746     if (p_cb->adv_mode == BTM_BLE_ADV_ENABLE) {
2747         p_cb->fast_adv_on = TRUE;
2748         /* start initial GAP mode adv timer */
2749         btu_start_timer (&p_cb->fast_adv_timer, BTU_TTYPE_BLE_GAP_FAST_ADV,
2750                          BTM_BLE_GAP_FAST_ADV_TOUT);
2751     } else {
2752 #if BLE_PRIVACY_SPT == TRUE
2753         btm_ble_disable_resolving_list(BTM_BLE_RL_ADV, TRUE);
2754 #endif
2755     }
2756     return status;
2757 }
2758 
2759 
2760 /*******************************************************************************
2761 **
2762 ** Function         btm_ble_start_inquiry
2763 **
2764 ** Description      This function is called to start BLE inquiry procedure.
2765 **                  If the duration is zero, the periodic inquiry mode is cancelled.
2766 **
2767 ** Parameters:      mode - GENERAL or LIMITED inquiry
2768 **                  p_inq_params - pointer to the BLE inquiry parameter.
2769 **                  p_results_cb - callback returning pointer to results (tBTM_INQ_RESULTS)
2770 **                  p_cmpl_cb - callback indicating the end of an inquiry
2771 **
2772 **
2773 **
2774 ** Returns          BTM_CMD_STARTED if successfully started
2775 **                  BTM_NO_RESOURCES if could not allocate a message buffer
2776 **                  BTM_BUSY - if an inquiry is already active
2777 **
2778 *******************************************************************************/
btm_ble_start_inquiry(UINT8 mode,UINT8 duration)2779 tBTM_STATUS btm_ble_start_inquiry (UINT8 mode, UINT8   duration)
2780 {
2781     tBTM_STATUS status = BTM_CMD_STARTED;
2782     tBTM_BLE_CB *p_ble_cb = &btm_cb.ble_ctr_cb;
2783     tBTM_INQUIRY_VAR_ST      *p_inq = &btm_cb.btm_inq_vars;
2784 
2785     BTM_TRACE_DEBUG("btm_ble_start_inquiry: mode = %02x inq_active = 0x%02x", mode, btm_cb.btm_inq_vars.inq_active);
2786 
2787     /* if selective connection is active, or inquiry is already active, reject it */
2788     if (BTM_BLE_IS_INQ_ACTIVE(p_ble_cb->scan_activity) ||
2789             BTM_BLE_IS_SEL_CONN_ACTIVE (p_ble_cb->scan_activity)) {
2790         BTM_TRACE_ERROR("LE Inquiry is active, can not start inquiry");
2791         return (BTM_BUSY);
2792     }
2793 
2794     if (!BTM_BLE_IS_SCAN_ACTIVE(p_ble_cb->scan_activity)) {
2795         btsnd_hcic_ble_set_scan_params(BTM_BLE_SCAN_MODE_ACTI,
2796                                        BTM_BLE_LOW_LATENCY_SCAN_INT,
2797                                        BTM_BLE_LOW_LATENCY_SCAN_WIN,
2798                                        btm_cb.ble_ctr_cb.addr_mgnt_cb.own_addr_type,
2799                                        SP_ADV_ALL);
2800 #if (defined BLE_PRIVACY_SPT && BLE_PRIVACY_SPT == TRUE)
2801         /* enable IRK list */
2802         //btm_ble_enable_resolving_list_for_platform(BTM_BLE_RL_SCAN);
2803 #endif
2804         status = btm_ble_start_scan();
2805     } else if ((p_ble_cb->inq_var.scan_interval != BTM_BLE_LOW_LATENCY_SCAN_INT) ||
2806                (p_ble_cb->inq_var.scan_window != BTM_BLE_LOW_LATENCY_SCAN_WIN)) {
2807         BTM_TRACE_DEBUG("%s, restart LE scan with low latency scan params", __FUNCTION__);
2808         btsnd_hcic_ble_set_scan_enable(BTM_BLE_SCAN_DISABLE, BTM_BLE_DUPLICATE_ENABLE);
2809         btsnd_hcic_ble_set_scan_params(BTM_BLE_SCAN_MODE_ACTI,
2810                                        BTM_BLE_LOW_LATENCY_SCAN_INT,
2811                                        BTM_BLE_LOW_LATENCY_SCAN_WIN,
2812                                        btm_cb.ble_ctr_cb.addr_mgnt_cb.own_addr_type,
2813                                        SP_ADV_ALL);
2814         btsnd_hcic_ble_set_scan_enable(BTM_BLE_SCAN_ENABLE, BTM_BLE_DUPLICATE_DISABLE);
2815     }
2816 
2817     if (status == BTM_CMD_STARTED) {
2818         p_inq->inq_active |= mode;
2819         p_ble_cb->scan_activity |= mode;
2820 
2821         BTM_TRACE_DEBUG("btm_ble_start_inquiry inq_active = 0x%02x", p_inq->inq_active);
2822 
2823         if (duration != 0) {
2824             /* start inquiry timer */
2825             btu_start_timer (&p_ble_cb->inq_var.inq_timer_ent, BTU_TTYPE_BLE_INQUIRY, duration);
2826         }
2827     }
2828 
2829     return status;
2830 
2831 }
2832 
2833 /*******************************************************************************
2834 **
2835 ** Function         btm_ble_read_remote_name_cmpl
2836 **
2837 ** Description      This function is called when BLE remote name is received.
2838 **
2839 ** Returns          void
2840 **
2841 *******************************************************************************/
btm_ble_read_remote_name_cmpl(BOOLEAN status,BD_ADDR bda,UINT16 length,char * p_name)2842 void btm_ble_read_remote_name_cmpl(BOOLEAN status, BD_ADDR bda, UINT16 length, char *p_name)
2843 {
2844     UINT8   hci_status = HCI_SUCCESS;
2845     BD_NAME bd_name;
2846 
2847     memset(bd_name, 0, (BD_NAME_LEN + 1));
2848     if (length > BD_NAME_LEN) {
2849         length = BD_NAME_LEN;
2850     }
2851     memcpy((UINT8 *)bd_name, p_name, length);
2852 
2853     if ((!status) || (length == 0)) {
2854         hci_status = HCI_ERR_HOST_TIMEOUT;
2855     }
2856 
2857     btm_process_remote_name(bda, bd_name, length + 1, hci_status);
2858 #if (SMP_INCLUDED == TRUE)
2859     btm_sec_rmt_name_request_complete (bda, (UINT8 *)p_name, hci_status);
2860 #endif  ///SMP_INCLUDED == TRUE
2861 }
2862 
2863 /*******************************************************************************
2864 **
2865 ** Function         btm_ble_read_remote_name
2866 **
2867 ** Description      This function read remote LE device name using GATT read
2868 **                  procedure.
2869 **
2870 ** Parameters:       None.
2871 **
2872 ** Returns          void
2873 **
2874 *******************************************************************************/
btm_ble_read_remote_name(BD_ADDR remote_bda,tBTM_INQ_INFO * p_cur,tBTM_CMPL_CB * p_cb)2875 tBTM_STATUS btm_ble_read_remote_name(BD_ADDR remote_bda, tBTM_INQ_INFO *p_cur, tBTM_CMPL_CB *p_cb)
2876 {
2877     tBTM_INQUIRY_VAR_ST      *p_inq = &btm_cb.btm_inq_vars;
2878 
2879     if (!controller_get_interface()->supports_ble()) {
2880         return BTM_ERR_PROCESSING;
2881     }
2882 
2883     if (p_cur &&
2884             p_cur->results.ble_evt_type != BTM_BLE_EVT_CONN_ADV &&
2885             p_cur->results.ble_evt_type != BTM_BLE_EVT_CONN_DIR_ADV) {
2886         BTM_TRACE_DEBUG("name request to non-connectable device failed.");
2887         return BTM_ERR_PROCESSING;
2888     }
2889 
2890     /* read remote device name using GATT procedure */
2891     if (p_inq->remname_active) {
2892         return BTM_BUSY;
2893     }
2894 
2895 #if (defined(GAP_INCLUDED) && GAP_INCLUDED == TRUE && GATTS_INCLUDED == TRUE)
2896     if (!GAP_BleReadPeerDevName(remote_bda, btm_ble_read_remote_name_cmpl)) {
2897         return BTM_BUSY;
2898     }
2899 #endif
2900 
2901     p_inq->p_remname_cmpl_cb = p_cb;
2902     p_inq->remname_active = TRUE;
2903 
2904     memcpy(p_inq->remname_bda, remote_bda, BD_ADDR_LEN);
2905 
2906     btu_start_timer (&p_inq->rmt_name_timer_ent,
2907                      BTU_TTYPE_BTM_RMT_NAME,
2908                      BTM_EXT_BLE_RMT_NAME_TIMEOUT);
2909 
2910     return BTM_CMD_STARTED;
2911 }
2912 
2913 /*******************************************************************************
2914 **
2915 ** Function         btm_ble_cancel_remote_name
2916 **
2917 ** Description      This function cancel read remote LE device name.
2918 **
2919 ** Parameters:       None.
2920 **
2921 ** Returns          void
2922 **
2923 *******************************************************************************/
btm_ble_cancel_remote_name(BD_ADDR remote_bda)2924 BOOLEAN btm_ble_cancel_remote_name(BD_ADDR remote_bda)
2925 {
2926     tBTM_INQUIRY_VAR_ST      *p_inq = &btm_cb.btm_inq_vars;
2927     BOOLEAN     status = TRUE;
2928 
2929 #if (defined(GAP_INCLUDED) && GAP_INCLUDED == TRUE && GATTS_INCLUDED == TRUE)
2930     status = GAP_BleCancelReadPeerDevName(remote_bda);
2931 #endif
2932 
2933     p_inq->remname_active = FALSE;
2934     memset(p_inq->remname_bda, 0, BD_ADDR_LEN);
2935     btu_stop_timer(&p_inq->rmt_name_timer_ent);
2936 
2937     return status;
2938 }
2939 
2940 /*******************************************************************************
2941 **
2942 ** Function         btm_ble_update_adv_flag
2943 **
2944 ** Description      This function update the limited discoverable flag in the adv
2945 **                  data.
2946 **
2947 ** Parameters:       None.
2948 **
2949 ** Returns          void
2950 **
2951 *******************************************************************************/
btm_ble_update_adv_flag(UINT8 flag)2952 static void btm_ble_update_adv_flag(UINT8 flag)
2953 {
2954     tBTM_BLE_LOCAL_ADV_DATA *p_adv_data = &btm_cb.ble_ctr_cb.inq_var.adv_data;
2955     UINT8   *p;
2956 
2957     BTM_TRACE_DEBUG ("btm_ble_update_adv_flag new=0x%x", flag);
2958 
2959     if (p_adv_data->p_flags != NULL) {
2960         BTM_TRACE_DEBUG ("btm_ble_update_adv_flag old=0x%x",   *p_adv_data->p_flags);
2961         *p_adv_data->p_flags = flag;
2962     } else { /* no FLAGS in ADV data*/
2963         p = (p_adv_data->p_pad == NULL) ? p_adv_data->ad_data : p_adv_data->p_pad;
2964         /* need 3 bytes space to stuff in the flags, if not */
2965         /* erase all written data, just for flags */
2966         if ((BTM_BLE_AD_DATA_LEN - (p - p_adv_data->ad_data)) < 3) {
2967             p = p_adv_data->p_pad = p_adv_data->ad_data;
2968             memset(p_adv_data->ad_data, 0, BTM_BLE_AD_DATA_LEN);
2969         }
2970 
2971         *p++ = 2;
2972         *p++ = BTM_BLE_AD_TYPE_FLAG;
2973         p_adv_data->p_flags = p;
2974         *p++ = flag;
2975         p_adv_data->p_pad = p;
2976     }
2977 
2978     if (btsnd_hcic_ble_set_adv_data((UINT8)(p_adv_data->p_pad - p_adv_data->ad_data),
2979                                     p_adv_data->ad_data)) {
2980         p_adv_data->data_mask |= BTM_BLE_AD_BIT_FLAGS;
2981     }
2982 
2983 }
2984 
2985 #if 0
2986 /*******************************************************************************
2987 **
2988 ** Function         btm_ble_parse_adv_data
2989 **
2990 ** Description      This function parse the adv data into a structure.
2991 **
2992 ** Returns          pointer to entry, or NULL if not found
2993 **
2994 *******************************************************************************/
2995 static void btm_ble_parse_adv_data(tBTM_INQ_INFO *p_info, UINT8 *p_data,
2996                                    UINT8 len, tBTM_BLE_INQ_DATA *p_adv_data, UINT8 *p_buf)
2997 {
2998     UINT8   *p_cur = p_data;
2999     UINT8   ad_len, ad_type, ad_flag;
3000 
3001     BTM_TRACE_EVENT (" btm_ble_parse_adv_data");
3002 
3003     while (len > 0) {
3004         BTM_TRACE_DEBUG("btm_ble_parse_adv_data: len = %d", len);
3005         if ((ad_len = *p_cur ++) == 0) {
3006             break;
3007         }
3008 
3009         ad_type = *p_cur ++;
3010 
3011         BTM_TRACE_DEBUG("     ad_type = %02x ad_len = %d", ad_type, ad_len);
3012 
3013         switch (ad_type) {
3014         case BTM_BLE_AD_TYPE_NAME_SHORT:
3015 
3016         case BTM_BLE_AD_TYPE_NAME_CMPL:
3017             p_adv_data->ad_mask |= BTM_BLE_AD_BIT_DEV_NAME;
3018             if (p_info) {
3019                 p_info->remote_name_type = (ad_type == BTM_BLE_AD_TYPE_NAME_SHORT) ?
3020                                            BTM_BLE_NAME_SHORT : BTM_BLE_NAME_CMPL;
3021                 memcpy(p_info->remote_name, p_cur, ad_len - 1);
3022                 p_info->remote_name[ad_len] = 0;
3023                 p_adv_data->p_remote_name = p_info->remote_name;
3024                 p_info->remote_name_len = p_adv_data->remote_name_len = ad_len - 1;
3025                 BTM_TRACE_DEBUG("BTM_BLE_AD_TYPE_NAME name = %s", p_adv_data->p_remote_name);
3026             }
3027             p_cur += (ad_len - 1);
3028 
3029             break;
3030 
3031         case BTM_BLE_AD_TYPE_FLAG:
3032             p_adv_data->ad_mask |= BTM_BLE_AD_BIT_FLAGS;
3033             ad_flag = *p_cur ++;
3034             p_adv_data->flag = (UINT8)(ad_flag & BTM_BLE_ADV_FLAG_MASK) ;
3035             BTM_TRACE_DEBUG("BTM_BLE_AD_TYPE_FLAG flag = %s | %s | %s",
3036                             (p_adv_data->flag & BTM_BLE_LIMIT_DISC_FLAG) ? "LE_LIMIT_DISC" : "",
3037                             (p_adv_data->flag & BTM_BLE_GEN_DISC_FLAG) ? "LE_GENERAL_DISC" : "",
3038                             (p_adv_data->flag & BTM_BLE_BREDR_NOT_SPT) ? "LE Only device" : "");
3039             break;
3040 
3041         case BTM_BLE_AD_TYPE_TX_PWR:
3042             p_adv_data->ad_mask |= BTM_BLE_AD_BIT_TX_PWR;
3043             p_adv_data->tx_power_level = (INT8) * p_cur ++;
3044             BTM_TRACE_DEBUG("BTM_BLE_AD_TYPE_TX_PWR tx_level = %d", p_adv_data->tx_power_level);
3045             break;
3046 
3047         case BTM_BLE_AD_TYPE_MANU:
3048 
3049         case BTM_BLE_AD_TYPE_16SRV_PART:
3050         case BTM_BLE_AD_TYPE_16SRV_CMPL:
3051             p_adv_data->ad_mask |= BTM_BLE_AD_BIT_SERVICE;
3052             /* need allocate memory to store UUID list */
3053             p_adv_data->service.num_service = (ad_len - 1) / 2;
3054             BTM_TRACE_DEBUG("service UUID list, num = %d", p_adv_data->service.num_service);
3055             p_cur += (ad_len - 1);
3056             break;
3057 
3058         case BTM_BLE_AD_TYPE_SOL_SRV_UUID:
3059             p_adv_data->ad_mask |= BTM_BLE_AD_BIT_SERVICE_SOL;
3060             /* need allocate memory to store UUID list */
3061             p_adv_data->service.num_service = (ad_len - 1) / 2;
3062             BTM_TRACE_DEBUG("service UUID list, num = %d", p_adv_data->service.num_service);
3063             p_cur += (ad_len - 1);
3064             break;
3065 
3066         case BTM_BLE_AD_TYPE_128SOL_SRV_UUID:
3067             p_adv_data->ad_mask |= BTM_BLE_AD_BIT_SERVICE_128SOL;
3068             /* need allocate memory to store UUID list */
3069             p_adv_data->service.num_service = (ad_len - 1) / 16;
3070             BTM_TRACE_DEBUG("service UUID list, num = %d", p_adv_data->service.num_service);
3071             p_cur += (ad_len - 1);
3072             break;
3073 
3074         case BTM_BLE_AD_TYPE_APPEARANCE:
3075         case BTM_BLE_AD_TYPE_PUBLIC_TARGET:
3076         case BTM_BLE_AD_TYPE_RANDOM_TARGET:
3077         default:
3078             break;
3079         }
3080         len -= (ad_len + 1);
3081     }
3082 }
3083 #endif
3084 
3085 /*******************************************************************************
3086 **
3087 ** Function         btm_ble_cache_adv_data
3088 **
3089 ** Description      Update advertising cache data.
3090 **
3091 ** Returns          void
3092 **
3093 *******************************************************************************/
btm_ble_cache_adv_data(BD_ADDR bda,tBTM_INQ_RESULTS * p_cur,UINT8 data_len,UINT8 * p,UINT8 evt_type)3094 void btm_ble_cache_adv_data(BD_ADDR bda, tBTM_INQ_RESULTS *p_cur, UINT8 data_len, UINT8 *p, UINT8 evt_type)
3095 {
3096     tBTM_BLE_INQ_CB     *p_le_inq_cb = &btm_cb.ble_ctr_cb.inq_var;
3097     UINT8 *p_cache;
3098     //UINT8 length;
3099 
3100     /* cache adv report/scan response data */
3101     if (evt_type != BTM_BLE_SCAN_RSP_EVT) {
3102         p_le_inq_cb->adv_len = 0;
3103         memset(p_le_inq_cb->adv_data_cache, 0, BTM_BLE_CACHE_ADV_DATA_MAX);
3104         p_cur->adv_data_len = 0;
3105         p_cur->scan_rsp_len = 0;
3106     }
3107 
3108     //Clear the adv cache if the addresses are not equal
3109     if(memcmp(bda, p_le_inq_cb->adv_addr, BD_ADDR_LEN) != 0) {
3110         p_le_inq_cb->adv_len = 0;
3111         memcpy(p_le_inq_cb->adv_addr, bda, BD_ADDR_LEN);
3112         memset(p_le_inq_cb->adv_data_cache, 0, BTM_BLE_CACHE_ADV_DATA_MAX);
3113         p_cur->adv_data_len = 0;
3114         p_cur->scan_rsp_len = 0;
3115     }
3116 
3117     if (data_len > 0) {
3118         p_cache = &p_le_inq_cb->adv_data_cache[p_le_inq_cb->adv_len];
3119         if((data_len + p_le_inq_cb->adv_len) <= BTM_BLE_CACHE_ADV_DATA_MAX) {
3120             memcpy(p_cache, p, data_len);
3121             p_le_inq_cb->adv_len += data_len;
3122         }
3123     }
3124 
3125     if (evt_type != BTM_BLE_SCAN_RSP_EVT) {
3126         p_cur->adv_data_len = p_le_inq_cb->adv_len;
3127     }
3128     else {
3129         p_cur->scan_rsp_len = p_le_inq_cb->adv_len - p_cur->adv_data_len;
3130     }
3131 
3132     /* parse service UUID from adv packet and save it in inq db eir_uuid */
3133     /* TODO */
3134 }
3135 
3136 /*******************************************************************************
3137 **
3138 ** Function         btm_ble_is_discoverable
3139 **
3140 ** Description      check ADV flag to make sure device is discoverable and match
3141 **                  the search condition
3142 **
3143 ** Parameters
3144 **
3145 ** Returns          void
3146 **
3147 *******************************************************************************/
btm_ble_is_discoverable(BD_ADDR bda,UINT8 evt_type,UINT8 * p)3148 UINT8 btm_ble_is_discoverable(BD_ADDR bda, UINT8 evt_type, UINT8 *p)
3149 {
3150     UINT8               *p_flag, flag = 0, rt = 0;
3151     UINT8                data_len;
3152     tBTM_INQ_PARMS      *p_cond = &btm_cb.btm_inq_vars.inqparms;
3153     tBTM_BLE_INQ_CB     *p_le_inq_cb = &btm_cb.ble_ctr_cb.inq_var;
3154 
3155     UNUSED(p);
3156 
3157     /* for observer, always "discoverable */
3158     if (BTM_BLE_IS_OBS_ACTIVE(btm_cb.ble_ctr_cb.scan_activity)) {
3159         rt |= BTM_BLE_OBS_RESULT;
3160     }
3161     /* for discover, always "discoverable */
3162     if (BTM_BLE_IS_DISCO_ACTIVE(btm_cb.ble_ctr_cb.scan_activity)) {
3163         rt |= BTM_BLE_DISCO_RESULT;
3164     }
3165 
3166     if (BTM_BLE_IS_SEL_CONN_ACTIVE(btm_cb.ble_ctr_cb.scan_activity) &&
3167             (evt_type == BTM_BLE_CONNECT_EVT || evt_type == BTM_BLE_CONNECT_DIR_EVT)) {
3168         rt |= BTM_BLE_SEL_CONN_RESULT;
3169     }
3170 
3171     /* does not match filter condition */
3172     if (p_cond->filter_cond_type == BTM_FILTER_COND_BD_ADDR &&
3173             memcmp(bda, p_cond->filter_cond.bdaddr_cond, BD_ADDR_LEN) != 0) {
3174         BTM_TRACE_DEBUG("BD ADDR does not meet filter condition");
3175         return rt;
3176     }
3177 
3178     if (p_le_inq_cb->adv_len != 0) {
3179         if ((p_flag = BTM_CheckAdvData(p_le_inq_cb->adv_data_cache, p_le_inq_cb->adv_len,
3180                                        BTM_BLE_AD_TYPE_FLAG, &data_len)) != NULL) {
3181             flag = * p_flag;
3182 
3183             if ((btm_cb.btm_inq_vars.inq_active & BTM_BLE_GENERAL_INQUIRY) &&
3184                     (flag & (BTM_BLE_LIMIT_DISC_FLAG | BTM_BLE_GEN_DISC_FLAG)) != 0) {
3185                 BTM_TRACE_DEBUG("Find Generable Discoverable device");
3186                 rt |= BTM_BLE_INQ_RESULT;
3187             }
3188 
3189             else if (btm_cb.btm_inq_vars.inq_active & BTM_BLE_LIMITED_INQUIRY &&
3190                      (flag & BTM_BLE_LIMIT_DISC_FLAG) != 0) {
3191                 BTM_TRACE_DEBUG("Find limited discoverable device");
3192                 rt |= BTM_BLE_INQ_RESULT;
3193             }
3194         }
3195     }
3196     return rt;
3197 }
3198 
btm_ble_appearance_to_cod(UINT16 appearance,UINT8 * dev_class)3199 static void btm_ble_appearance_to_cod(UINT16 appearance, UINT8 *dev_class)
3200 {
3201     dev_class[0] = 0;
3202 
3203     switch (appearance) {
3204     case BTM_BLE_APPEARANCE_GENERIC_PHONE:
3205         dev_class[1] = BTM_COD_MAJOR_PHONE;
3206         dev_class[2] = BTM_COD_MINOR_UNCLASSIFIED;
3207         break;
3208     case BTM_BLE_APPEARANCE_GENERIC_COMPUTER:
3209         dev_class[1] = BTM_COD_MAJOR_COMPUTER;
3210         dev_class[2] = BTM_COD_MINOR_UNCLASSIFIED;
3211         break;
3212     case BTM_BLE_APPEARANCE_GENERIC_REMOTE:
3213         dev_class[1] = BTM_COD_MAJOR_PERIPHERAL;
3214         dev_class[2] = BTM_COD_MINOR_REMOTE_CONTROL;
3215         break;
3216     case BTM_BLE_APPEARANCE_GENERIC_THERMOMETER:
3217     case BTM_BLE_APPEARANCE_THERMOMETER_EAR:
3218         dev_class[1] = BTM_COD_MAJOR_HEALTH;
3219         dev_class[2] = BTM_COD_MINOR_THERMOMETER;
3220         break;
3221     case BTM_BLE_APPEARANCE_GENERIC_HEART_RATE:
3222     case BTM_BLE_APPEARANCE_HEART_RATE_BELT:
3223         dev_class[1] = BTM_COD_MAJOR_HEALTH;
3224         dev_class[2] = BTM_COD_MINOR_HEART_PULSE_MONITOR;
3225         break;
3226     case BTM_BLE_APPEARANCE_GENERIC_BLOOD_PRESSURE:
3227     case BTM_BLE_APPEARANCE_BLOOD_PRESSURE_ARM:
3228     case BTM_BLE_APPEARANCE_BLOOD_PRESSURE_WRIST:
3229         dev_class[1] = BTM_COD_MAJOR_HEALTH;
3230         dev_class[2] = BTM_COD_MINOR_BLOOD_MONITOR;
3231         break;
3232     case BTM_BLE_APPEARANCE_GENERIC_PULSE_OXIMETER:
3233     case BTM_BLE_APPEARANCE_PULSE_OXIMETER_FINGERTIP:
3234     case BTM_BLE_APPEARANCE_PULSE_OXIMETER_WRIST:
3235         dev_class[1] = BTM_COD_MAJOR_HEALTH;
3236         dev_class[2] = BTM_COD_MINOR_PULSE_OXIMETER;
3237         break;
3238     case BTM_BLE_APPEARANCE_GENERIC_GLUCOSE:
3239         dev_class[1] = BTM_COD_MAJOR_HEALTH;
3240         dev_class[2] = BTM_COD_MINOR_GLUCOSE_METER;
3241         break;
3242     case BTM_BLE_APPEARANCE_GENERIC_WEIGHT:
3243         dev_class[1] = BTM_COD_MAJOR_HEALTH;
3244         dev_class[2] = BTM_COD_MINOR_WEIGHING_SCALE;
3245         break;
3246     case BTM_BLE_APPEARANCE_GENERIC_WALKING:
3247     case BTM_BLE_APPEARANCE_WALKING_IN_SHOE:
3248     case BTM_BLE_APPEARANCE_WALKING_ON_SHOE:
3249     case BTM_BLE_APPEARANCE_WALKING_ON_HIP:
3250         dev_class[1] = BTM_COD_MAJOR_HEALTH;
3251         dev_class[2] = BTM_COD_MINOR_STEP_COUNTER;
3252         break;
3253     case BTM_BLE_APPEARANCE_GENERIC_WATCH:
3254     case BTM_BLE_APPEARANCE_SPORTS_WATCH:
3255         dev_class[1] = BTM_COD_MAJOR_WEARABLE;
3256         dev_class[2] = BTM_COD_MINOR_WRIST_WATCH;
3257         break;
3258     case BTM_BLE_APPEARANCE_GENERIC_EYEGLASSES:
3259         dev_class[1] = BTM_COD_MAJOR_WEARABLE;
3260         dev_class[2] = BTM_COD_MINOR_GLASSES;
3261         break;
3262     case BTM_BLE_APPEARANCE_GENERIC_DISPLAY:
3263         dev_class[1] = BTM_COD_MAJOR_IMAGING;
3264         dev_class[2] = BTM_COD_MINOR_DISPLAY;
3265         break;
3266     case BTM_BLE_APPEARANCE_GENERIC_MEDIA_PLAYER:
3267         dev_class[1] = BTM_COD_MAJOR_AUDIO;
3268         dev_class[2] = BTM_COD_MINOR_UNCLASSIFIED;
3269         break;
3270     case BTM_BLE_APPEARANCE_GENERIC_BARCODE_SCANNER:
3271     case BTM_BLE_APPEARANCE_HID_BARCODE_SCANNER:
3272     case BTM_BLE_APPEARANCE_GENERIC_HID:
3273         dev_class[1] = BTM_COD_MAJOR_PERIPHERAL;
3274         dev_class[2] = BTM_COD_MINOR_UNCLASSIFIED;
3275         break;
3276     case BTM_BLE_APPEARANCE_HID_KEYBOARD:
3277         dev_class[1] = BTM_COD_MAJOR_PERIPHERAL;
3278         dev_class[2] = BTM_COD_MINOR_KEYBOARD;
3279         break;
3280     case BTM_BLE_APPEARANCE_HID_MOUSE:
3281         dev_class[1] = BTM_COD_MAJOR_PERIPHERAL;
3282         dev_class[2] = BTM_COD_MINOR_POINTING;
3283         break;
3284     case BTM_BLE_APPEARANCE_HID_JOYSTICK:
3285         dev_class[1] = BTM_COD_MAJOR_PERIPHERAL;
3286         dev_class[2] = BTM_COD_MINOR_JOYSTICK;
3287         break;
3288     case BTM_BLE_APPEARANCE_HID_GAMEPAD:
3289         dev_class[1] = BTM_COD_MAJOR_PERIPHERAL;
3290         dev_class[2] = BTM_COD_MINOR_GAMEPAD;
3291         break;
3292     case BTM_BLE_APPEARANCE_HID_DIGITIZER_TABLET:
3293         dev_class[1] = BTM_COD_MAJOR_PERIPHERAL;
3294         dev_class[2] = BTM_COD_MINOR_DIGITIZING_TABLET;
3295         break;
3296     case BTM_BLE_APPEARANCE_HID_CARD_READER:
3297         dev_class[1] = BTM_COD_MAJOR_PERIPHERAL;
3298         dev_class[2] = BTM_COD_MINOR_CARD_READER;
3299         break;
3300     case BTM_BLE_APPEARANCE_HID_DIGITAL_PEN:
3301         dev_class[1] = BTM_COD_MAJOR_PERIPHERAL;
3302         dev_class[2] = BTM_COD_MINOR_DIGITAL_PAN;
3303         break;
3304     case BTM_BLE_APPEARANCE_UNKNOWN:
3305     case BTM_BLE_APPEARANCE_GENERIC_CLOCK:
3306     case BTM_BLE_APPEARANCE_GENERIC_TAG:
3307     case BTM_BLE_APPEARANCE_GENERIC_KEYRING:
3308     case BTM_BLE_APPEARANCE_GENERIC_CYCLING:
3309     case BTM_BLE_APPEARANCE_CYCLING_COMPUTER:
3310     case BTM_BLE_APPEARANCE_CYCLING_SPEED:
3311     case BTM_BLE_APPEARANCE_CYCLING_CADENCE:
3312     case BTM_BLE_APPEARANCE_CYCLING_POWER:
3313     case BTM_BLE_APPEARANCE_CYCLING_SPEED_CADENCE:
3314     case BTM_BLE_APPEARANCE_STANDALONE_SPEAKER:
3315     case BTM_BLE_APPEARANCE_GENERIC_OUTDOOR_SPORTS:
3316     case BTM_BLE_APPEARANCE_OUTDOOR_SPORTS_LOCATION:
3317     case BTM_BLE_APPEARANCE_OUTDOOR_SPORTS_LOCATION_AND_NAV:
3318     case BTM_BLE_APPEARANCE_OUTDOOR_SPORTS_LOCATION_POD:
3319     case BTM_BLE_APPEARANCE_OUTDOOR_SPORTS_LOCATION_POD_AND_NAV:
3320     default:
3321         dev_class[1] = BTM_COD_MAJOR_UNCLASSIFIED;
3322         dev_class[2] = BTM_COD_MINOR_UNCLASSIFIED;
3323     };
3324 }
3325 
3326 /*******************************************************************************
3327 **
3328 ** Function         btm_ble_update_inq_result
3329 **
3330 ** Description      Update adv packet information into inquiry result.
3331 **
3332 ** Parameters
3333 **
3334 ** Returns          void
3335 **
3336 *******************************************************************************/
btm_ble_update_inq_result(BD_ADDR bda,tINQ_DB_ENT * p_i,UINT8 addr_type,UINT8 evt_type,UINT8 * p)3337 BOOLEAN btm_ble_update_inq_result(BD_ADDR bda, tINQ_DB_ENT *p_i, UINT8 addr_type, UINT8 evt_type, UINT8 *p)
3338 {
3339     BOOLEAN             to_report = TRUE;
3340     tBTM_INQ_RESULTS     *p_cur = &p_i->inq_info.results;
3341     UINT8               len;
3342     UINT8               *p_flag;
3343     tBTM_INQUIRY_VAR_ST  *p_inq = &btm_cb.btm_inq_vars;
3344     UINT8                data_len, rssi;
3345     tBTM_BLE_INQ_CB     *p_le_inq_cb = &btm_cb.ble_ctr_cb.inq_var;
3346     UINT8 *p1;
3347     UINT8               *p_uuid16;
3348 
3349     STREAM_TO_UINT8    (data_len, p);
3350 
3351     if (data_len > BTM_BLE_ADV_DATA_LEN_MAX) {
3352         BTM_TRACE_WARNING("EIR data too long %d. discard", data_len);
3353         return FALSE;
3354     }
3355     btm_ble_cache_adv_data(bda, p_cur, data_len, p, evt_type);
3356 
3357     p1 = (p + data_len);
3358     STREAM_TO_UINT8 (rssi, p1);
3359 
3360     /* Save the info */
3361     p_cur->inq_result_type = BTM_INQ_RESULT_BLE;
3362     p_cur->ble_addr_type    = addr_type;
3363     p_cur->rssi = rssi;
3364 
3365     /* active scan, always wait until get scan_rsp to report the result */
3366     if ((btm_cb.ble_ctr_cb.inq_var.scan_type == BTM_BLE_SCAN_MODE_ACTI &&
3367             (evt_type == BTM_BLE_CONNECT_EVT || evt_type == BTM_BLE_DISCOVER_EVT))) {
3368         BTM_TRACE_DEBUG("btm_ble_update_inq_result scan_rsp=false, to_report=false,\
3369                               scan_type_active=%d", btm_cb.ble_ctr_cb.inq_var.scan_type);
3370         p_i->scan_rsp = FALSE;
3371 #if BTM_BLE_ACTIVE_SCAN_REPORT_ADV_SCAN_RSP_INDIVIDUALLY == FALSE
3372         to_report = FALSE;
3373 #endif
3374     } else {
3375         p_i->scan_rsp = TRUE;
3376     }
3377 
3378     if (p_i->inq_count != p_inq->inq_counter) {
3379         p_cur->device_type = BT_DEVICE_TYPE_BLE;
3380     } else {
3381         p_cur->device_type |= BT_DEVICE_TYPE_BLE;
3382     }
3383 
3384     if (evt_type != BTM_BLE_SCAN_RSP_EVT) {
3385         p_cur->ble_evt_type     = evt_type;
3386     }
3387 #if BTM_BLE_ACTIVE_SCAN_REPORT_ADV_SCAN_RSP_INDIVIDUALLY
3388     if (evt_type == BTM_BLE_SCAN_RSP_EVT) {
3389         p_cur->ble_evt_type = evt_type;
3390     }
3391 #endif
3392     p_i->inq_count = p_inq->inq_counter;   /* Mark entry for current inquiry */
3393 
3394     if (p_le_inq_cb->adv_len != 0) {
3395         if ((p_flag = BTM_CheckAdvData(p_le_inq_cb->adv_data_cache, p_le_inq_cb->adv_len, BTM_BLE_AD_TYPE_FLAG, &len)) != NULL) {
3396             p_cur->flag = * p_flag;
3397         }
3398     }
3399 
3400     if (p_le_inq_cb->adv_len != 0) {
3401         /* Check to see the BLE device has the Appearance UUID in the advertising data.  If it does
3402          * then try to convert the appearance value to a class of device value Bluedroid can use.
3403          * Otherwise fall back to trying to infer if it is a HID device based on the service class.
3404          */
3405         p_uuid16 = BTM_CheckAdvData(p_le_inq_cb->adv_data_cache, p_le_inq_cb->adv_len, BTM_BLE_AD_TYPE_APPEARANCE, &len);
3406         if (p_uuid16 && len == 2) {
3407             btm_ble_appearance_to_cod((UINT16)p_uuid16[0] | (p_uuid16[1] << 8), p_cur->dev_class);
3408         } else {
3409             if ((p_uuid16 = BTM_CheckAdvData(p_le_inq_cb->adv_data_cache, p_le_inq_cb->adv_len,
3410                                              BTM_BLE_AD_TYPE_16SRV_CMPL, &len)) != NULL) {
3411                 UINT8 i;
3412                 for (i = 0; i + 2 <= len; i = i + 2) {
3413 #if BTA_HH_LE_INCLUDED == TRUE
3414 					/* if this BLE device support HID over LE, set HID Major in class of device */
3415                     if ((p_uuid16[i] | (p_uuid16[i + 1] << 8)) == UUID_SERVCLASS_LE_HID) {
3416                         p_cur->dev_class[0] = 0;
3417                         p_cur->dev_class[1] = BTM_COD_MAJOR_PERIPHERAL;
3418                         p_cur->dev_class[2] = 0;
3419                         break;
3420                     }
3421 #endif /* BTA_HH_LE_INCLUDED */
3422                 }
3423             }
3424         }
3425     }
3426 
3427     /* if BR/EDR not supported is not set, assume is a DUMO device */
3428     if ((p_cur->flag & BTM_BLE_BREDR_NOT_SPT) == 0 &&
3429             evt_type != BTM_BLE_CONNECT_DIR_EVT) {
3430         if (p_cur->ble_addr_type != BLE_ADDR_RANDOM) {
3431             BTM_TRACE_DEBUG("BR/EDR NOT support bit not set, treat as DUMO");
3432             p_cur->device_type |= BT_DEVICE_TYPE_DUMO;
3433         } else {
3434             BTM_TRACE_DEBUG("Random address, treating device as LE only");
3435         }
3436     } else {
3437         BTM_TRACE_DEBUG("BR/EDR NOT SUPPORT bit set, LE only device");
3438     }
3439 
3440     return to_report;
3441 
3442 }
3443 
3444 /*******************************************************************************
3445 **
3446 ** Function         btm_clear_all_pending_le_entry
3447 **
3448 ** Description      This function is called to clear all LE pending entry in
3449 **                  inquiry database.
3450 **
3451 ** Returns          void
3452 **
3453 *******************************************************************************/
btm_clear_all_pending_le_entry(void)3454 void btm_clear_all_pending_le_entry(void)
3455 {
3456     UINT16       xx;
3457     tINQ_DB_ENT  *p_ent = btm_cb.btm_inq_vars.inq_db;
3458 
3459     for (xx = 0; xx < BTM_INQ_DB_SIZE; xx++, p_ent++) {
3460         /* mark all pending LE entry as unused if an LE only device has scan response outstanding */
3461         if ((p_ent->in_use) &&
3462                 (p_ent->inq_info.results.device_type == BT_DEVICE_TYPE_BLE) &&
3463                 !p_ent->scan_rsp) {
3464             p_ent->in_use = FALSE;
3465         }
3466     }
3467 }
3468 
3469 /*******************************************************************************
3470 **
3471 ** Function         btm_send_sel_conn_callback
3472 **
3473 ** Description      send selection connection request callback.
3474 **
3475 ** Parameters
3476 **
3477 ** Returns          void
3478 **
3479 *******************************************************************************/
btm_send_sel_conn_callback(BD_ADDR remote_bda,UINT8 evt_type,UINT8 * p_data,UINT8 addr_type)3480 void btm_send_sel_conn_callback(BD_ADDR remote_bda, UINT8 evt_type, UINT8 *p_data, UINT8 addr_type)
3481 {
3482     UINT8   data_len, len;
3483     UINT8   *p_dev_name, remname[31] = {0};
3484     UNUSED(addr_type);
3485 
3486     if (btm_cb.ble_ctr_cb.p_select_cback == NULL ||
3487             /* non-connectable device */
3488             (evt_type != BTM_BLE_EVT_CONN_ADV && evt_type != BTM_BLE_EVT_CONN_DIR_ADV)) {
3489         return;
3490     }
3491 
3492     STREAM_TO_UINT8    (data_len, p_data);
3493 
3494     /* get the device name if exist in ADV data */
3495     if (data_len != 0) {
3496         p_dev_name = BTM_CheckAdvData(p_data, data_len, BTM_BLE_AD_TYPE_NAME_CMPL, &len);
3497 
3498         if (p_dev_name == NULL) {
3499             p_dev_name = BTM_CheckAdvData(p_data, data_len, BTM_BLE_AD_TYPE_NAME_SHORT, &len);
3500         }
3501 
3502         if (p_dev_name) {
3503             memcpy(remname, p_dev_name, len);
3504         }
3505     }
3506     /* allow connection */
3507     if ((* btm_cb.ble_ctr_cb.p_select_cback)(remote_bda, remname)) {
3508         /* terminate selective connection, initiate connection */
3509         btm_ble_initiate_select_conn(remote_bda);
3510     }
3511 }
3512 
btm_adv_pkt_handler(void * arg)3513 static void btm_adv_pkt_handler(void *arg)
3514 {
3515     UINT8   hci_evt_code, hci_evt_len;
3516     UINT8   ble_sub_code;
3517 
3518     tBTM_BLE_CB *p_cb = &btm_cb.ble_ctr_cb;
3519     size_t pkts_to_process = pkt_queue_length(p_cb->adv_rpt_queue);
3520     if (pkts_to_process > BTM_BLE_GAP_ADV_RPT_BATCH_SIZE) {
3521         pkts_to_process = BTM_BLE_GAP_ADV_RPT_BATCH_SIZE;
3522     }
3523 
3524     for (size_t i = 0; i < pkts_to_process; i++) {
3525         pkt_linked_item_t *linked_pkt = pkt_queue_dequeue(p_cb->adv_rpt_queue);
3526         assert(linked_pkt != NULL);
3527         BT_HDR *packet = (BT_HDR *)linked_pkt->data;
3528         uint8_t *p = packet->data + packet->offset;
3529         STREAM_TO_UINT8  (hci_evt_code, p);
3530         STREAM_TO_UINT8  (hci_evt_len, p);
3531         STREAM_TO_UINT8  (ble_sub_code, p);
3532         if (ble_sub_code == HCI_BLE_ADV_PKT_RPT_EVT) {
3533             btm_ble_process_adv_pkt(p);
3534         } else if (ble_sub_code == HCI_BLE_ADV_DISCARD_REPORT_EVT) {
3535             btm_ble_process_adv_discard_evt(p);
3536         } else if (ble_sub_code == HCI_BLE_DIRECT_ADV_EVT) {
3537             btm_ble_process_direct_adv_pkt(p);
3538         } else {
3539             assert (0);
3540         }
3541 
3542         osi_free(linked_pkt);
3543 #if (BLE_ADV_REPORT_FLOW_CONTROL == TRUE)
3544         hci_adv_credits_try_release(1);
3545 #endif
3546     }
3547 
3548     if (pkt_queue_length(p_cb->adv_rpt_queue) != 0) {
3549         btu_task_post(SIG_BTU_HCI_ADV_RPT_MSG, NULL, OSI_THREAD_MAX_TIMEOUT);
3550     }
3551 
3552     UNUSED(hci_evt_code);
3553     UNUSED(hci_evt_len);
3554 }
3555 
3556 /*******************************************************************************
3557 **
3558 ** Function         btm_ble_process_adv_pkt
3559 **
3560 ** Description      This function is called when adv packet report events are
3561 **                  received from the device. It updates the inquiry database.
3562 **                  If the inquiry database is full, the oldest entry is discarded.
3563 **
3564 ** Parameters
3565 **
3566 ** Returns          void
3567 **
3568 *******************************************************************************/
btm_ble_process_adv_pkt(UINT8 * p_data)3569 void btm_ble_process_adv_pkt (UINT8 *p_data)
3570 {
3571     BD_ADDR             bda;
3572     UINT8               evt_type = 0, *p = p_data;
3573     UINT8               addr_type = 0;
3574     UINT8               num_reports;
3575     UINT8               data_len;
3576 #if (defined BLE_PRIVACY_SPT && BLE_PRIVACY_SPT == TRUE)
3577     BOOLEAN             match = FALSE;
3578 #if (!CONTROLLER_RPA_LIST_ENABLE)
3579     BD_ADDR             temp_bda;
3580     UINT8               temp_addr_type = 0;
3581 #endif // (!CONTROLLER_RPA_LIST_ENABLE)
3582 #endif//(defined BLE_PRIVACY_SPT && BLE_PRIVACY_SPT == TRUE)
3583 
3584     /* Only process the results if the inquiry is still active */
3585     if (!BTM_BLE_IS_SCAN_ACTIVE(btm_cb.ble_ctr_cb.scan_activity)) {
3586         return;
3587     }
3588 
3589     /* Extract the number of reports in this event. */
3590     STREAM_TO_UINT8(num_reports, p);
3591 
3592     while (num_reports--) {
3593         /* Extract inquiry results */
3594         STREAM_TO_UINT8    (evt_type, p);
3595         STREAM_TO_UINT8    (addr_type, p);
3596         STREAM_TO_BDADDR   (bda, p);
3597         //BTM_TRACE_ERROR("btm_ble_process_adv_pkt:bda= %0x:%0x:%0x:%0x:%0x:%0x\n",
3598         //                              bda[0],bda[1],bda[2],bda[3],bda[4],bda[5]);
3599 #if (defined BLE_PRIVACY_SPT && BLE_PRIVACY_SPT == TRUE)
3600 
3601 #if (!CONTROLLER_RPA_LIST_ENABLE)
3602         temp_addr_type = addr_type;
3603         memcpy(temp_bda, bda, BD_ADDR_LEN);
3604 #endif // (!CONTROLLER_RPA_LIST_ENABLE)
3605 
3606         /* map address to security record */
3607         match = btm_identity_addr_to_random_pseudo(bda, &addr_type, FALSE);
3608 
3609         // BTM_TRACE_ERROR("btm_ble_process_adv_pkt:bda= %0x:%0x:%0x:%0x:%0x:%0x\n",
3610         //                             bda[0],bda[1],bda[2],bda[3],bda[4],bda[5]);
3611         /* always do RRA resolution on host */
3612         if (!match && BTM_BLE_IS_RESOLVE_BDA(bda)) {
3613             btm_ble_resolve_random_addr(bda, btm_ble_resolve_random_addr_on_adv, p_data);
3614         } else
3615 #endif
3616         btm_ble_process_adv_pkt_cont(bda, addr_type, evt_type, p);
3617 #if (defined BLE_PRIVACY_SPT && BLE_PRIVACY_SPT == TRUE && (!CONTROLLER_RPA_LIST_ENABLE))
3618         //save current adv addr information if p_dev_rec!= NULL
3619         tBTM_SEC_DEV_REC *p_dev_rec = btm_find_dev (bda);
3620         if(p_dev_rec) {
3621             p_dev_rec->ble.current_addr_type = temp_addr_type;
3622             memcpy(p_dev_rec->ble.current_addr, temp_bda, BD_ADDR_LEN);
3623             p_dev_rec->ble.current_addr_valid = true;
3624         }
3625 #endif
3626         STREAM_TO_UINT8(data_len, p);
3627 
3628         /* Advance to the next event data_len + rssi byte */
3629         p += data_len + 1;
3630     }
3631 }
3632 
3633 /*******************************************************************************
3634 **
3635 ** Function         btm_ble_process_last_adv_pkt
3636 **
3637 ** Description      This function is called to report last adv packet
3638 **
3639 ** Parameters
3640 **
3641 ** Returns          void
3642 **
3643 *******************************************************************************/
3644 
btm_ble_process_last_adv_pkt(void)3645 static void btm_ble_process_last_adv_pkt(void)
3646 {
3647     UINT8       result = 0;
3648     UINT8       null_bda[6] = {0};
3649     tBTM_INQUIRY_VAR_ST  *p_inq = &btm_cb.btm_inq_vars;
3650     tBTM_INQ_RESULTS_CB  *p_inq_results_cb = p_inq->p_inq_results_cb;
3651     tBTM_INQ_RESULTS_CB  *p_obs_results_cb = btm_cb.ble_ctr_cb.p_obs_results_cb;
3652     tBTM_INQ_RESULTS_CB  *p_scan_results_cb = btm_cb.ble_ctr_cb.p_scan_results_cb;
3653     tBTM_BLE_INQ_CB      *p_le_inq_cb = &btm_cb.ble_ctr_cb.inq_var;
3654     tINQ_DB_ENT          *p_i = btm_inq_db_find (p_le_inq_cb->adv_addr);
3655 
3656     if(memcmp(null_bda, p_le_inq_cb->adv_addr, BD_ADDR_LEN) == 0) {
3657         return;
3658     }
3659 
3660     if(p_i == NULL) {
3661         BTM_TRACE_DEBUG("no last adv");
3662         return;
3663     }
3664 
3665     if ((result = btm_ble_is_discoverable(p_le_inq_cb->adv_addr, p_i->inq_info.results.ble_evt_type, NULL)) == 0) {
3666         BTM_TRACE_WARNING("%s device is no longer discoverable so discarding advertising packet pkt",
3667                  __func__);
3668         return;
3669     }
3670     /* background connection in selective connection mode */
3671     if (btm_cb.ble_ctr_cb.bg_conn_type == BTM_BLE_CONN_SELECTIVE) {
3672         //do nothing
3673     } else {
3674         if (p_inq_results_cb && (result & BTM_BLE_INQ_RESULT)) {
3675             (p_inq_results_cb)((tBTM_INQ_RESULTS *) &p_i->inq_info.results, p_le_inq_cb->adv_data_cache);
3676             p_le_inq_cb->adv_len = 0;
3677             memset(p_le_inq_cb->adv_addr, 0, BD_ADDR_LEN);
3678             p_i->inq_info.results.adv_data_len = 0;
3679             p_i->inq_info.results.scan_rsp_len = 0;
3680         }
3681         if (p_obs_results_cb && (result & BTM_BLE_OBS_RESULT)) {
3682             (p_obs_results_cb)((tBTM_INQ_RESULTS *) &p_i->inq_info.results, p_le_inq_cb->adv_data_cache);
3683             p_le_inq_cb->adv_len = 0;
3684             memset(p_le_inq_cb->adv_addr, 0, BD_ADDR_LEN);
3685             p_i->inq_info.results.adv_data_len = 0;
3686             p_i->inq_info.results.scan_rsp_len = 0;
3687         }
3688         if (p_scan_results_cb && (result & BTM_BLE_DISCO_RESULT)) {
3689             (p_scan_results_cb)((tBTM_INQ_RESULTS *) &p_i->inq_info.results, p_le_inq_cb->adv_data_cache);
3690             p_le_inq_cb->adv_len = 0;
3691             memset(p_le_inq_cb->adv_addr, 0, BD_ADDR_LEN);
3692             p_i->inq_info.results.adv_data_len = 0;
3693             p_i->inq_info.results.scan_rsp_len = 0;
3694         }
3695     }
3696 }
3697 
3698 /*******************************************************************************
3699 **
3700 ** Function         btm_ble_process_adv_pkt_cont
3701 **
3702 ** Description      This function is called after random address resolution is
3703 **                  done, and proceed to process adv packet.
3704 **
3705 ** Parameters
3706 **
3707 ** Returns          void
3708 **
3709 *******************************************************************************/
btm_ble_process_adv_pkt_cont(BD_ADDR bda,UINT8 addr_type,UINT8 evt_type,UINT8 * p)3710 static void btm_ble_process_adv_pkt_cont(BD_ADDR bda, UINT8 addr_type, UINT8 evt_type, UINT8 *p)
3711 {
3712 
3713     tINQ_DB_ENT          *p_i;
3714     tBTM_INQUIRY_VAR_ST  *p_inq = &btm_cb.btm_inq_vars;
3715     tBTM_INQ_RESULTS_CB  *p_inq_results_cb = p_inq->p_inq_results_cb;
3716     tBTM_INQ_RESULTS_CB  *p_obs_results_cb = btm_cb.ble_ctr_cb.p_obs_results_cb;
3717     tBTM_INQ_RESULTS_CB  *p_scan_results_cb = btm_cb.ble_ctr_cb.p_scan_results_cb;
3718     tBTM_BLE_INQ_CB      *p_le_inq_cb = &btm_cb.ble_ctr_cb.inq_var;
3719     BOOLEAN     update = TRUE;
3720     UINT8       result = 0;
3721 
3722     /* Event_Type:
3723         0x00 Connectable undirected advertising (ADV_IND).
3724         0x01 Connectable directed advertising (ADV_DIRECT_IND)
3725         0x02 Scannable undirected advertising (ADV_SCAN_IND)
3726         0x03 Non connectable undirected advertising (ADV_NONCONN_IND)
3727         0x04 Scan Response (SCAN_RSP)
3728         0x05-0xFF Reserved for future use
3729     */
3730     // The adv packet without scan response is allowed to report to higher layer
3731     /*
3732     Bluedroid will put the advertising packet and scan response into a packet and send it to the higher layer.
3733     If two advertising packets are not with the same address, or can't be combined into a packet, then the first advertising
3734     packet will be discarded. So we added the following judgment:
3735     1. For different addresses, send the last advertising packet to higher layer
3736     2. For same address and same advertising type (not scan response), send the last advertising packet to higher layer
3737     3. For same address and scan response, do nothing
3738     */
3739     int same_addr = memcmp(bda, p_le_inq_cb->adv_addr, BD_ADDR_LEN);
3740     if (same_addr != 0 || (same_addr == 0 && evt_type != BTM_BLE_SCAN_RSP_EVT)) {
3741         btm_ble_process_last_adv_pkt();
3742     }
3743 
3744 
3745     p_i = btm_inq_db_find (bda);
3746 
3747     /* Check if this address has already been processed for this inquiry */
3748     if (btm_inq_find_bdaddr(bda)) {
3749         /* never been report as an LE device */
3750         if (p_i &&
3751                 (!(p_i->inq_info.results.device_type & BT_DEVICE_TYPE_BLE) ||
3752                  /* scan response to be updated */
3753                  (!p_i->scan_rsp))) {
3754             update = TRUE;
3755         } else if (BTM_BLE_IS_DISCO_ACTIVE(btm_cb.ble_ctr_cb.scan_activity)) {
3756             update = FALSE;
3757         } else {
3758             /* if yes, skip it */
3759             return; /* assumption: one result per event */
3760         }
3761     }
3762     /* If existing entry, use that, else get  a new one (possibly reusing the oldest) */
3763     if (p_i == NULL) {
3764         if ((p_i = btm_inq_db_new (bda)) != NULL) {
3765             p_inq->inq_cmpl_info.num_resp++;
3766         } else {
3767             return;
3768         }
3769     } else if (p_i->inq_count != p_inq->inq_counter) { /* first time seen in this inquiry */
3770         p_inq->inq_cmpl_info.num_resp++;
3771     }
3772     /* update the LE device information in inquiry database */
3773     if (!btm_ble_update_inq_result(bda, p_i, addr_type, evt_type, p)) {
3774         return;
3775     }
3776 
3777     if ((result = btm_ble_is_discoverable(bda, evt_type, p)) == 0) {
3778         BTM_TRACE_WARNING("%s device is no longer discoverable so discarding advertising packet pkt",
3779                  __func__);
3780         return;
3781     }
3782     if (!update) {
3783         result &= ~BTM_BLE_INQ_RESULT;
3784     }
3785     /* If the number of responses found and limited, issue a cancel inquiry */
3786     if (p_inq->inqparms.max_resps &&
3787             p_inq->inq_cmpl_info.num_resp == p_inq->inqparms.max_resps) {
3788         /* new device */
3789         if (p_i == NULL ||
3790                 /* assume a DUMO device, BR/EDR inquiry is always active */
3791                 (p_i &&
3792                  (p_i->inq_info.results.device_type & BT_DEVICE_TYPE_BLE) == BT_DEVICE_TYPE_BLE &&
3793                  p_i->scan_rsp)) {
3794             BTM_TRACE_WARNING("INQ RES: Extra Response Received...cancelling inquiry..");
3795 
3796             /* if is non-periodic inquiry active, cancel now */
3797             if ((p_inq->inq_active & BTM_BR_INQ_ACTIVE_MASK) != 0 &&
3798                     (p_inq->inq_active & BTM_PERIODIC_INQUIRY_ACTIVE) == 0) {
3799                 btsnd_hcic_inq_cancel();
3800             }
3801 
3802             btm_ble_stop_inquiry();
3803 
3804             btm_acl_update_busy_level (BTM_BLI_INQ_DONE_EVT);
3805         }
3806     }
3807     /* background connection in selective connection mode */
3808     if (btm_cb.ble_ctr_cb.bg_conn_type == BTM_BLE_CONN_SELECTIVE) {
3809         if (result & BTM_BLE_SEL_CONN_RESULT) {
3810             btm_send_sel_conn_callback(bda, evt_type, p, addr_type);
3811         } else {
3812             BTM_TRACE_DEBUG("None LE device, can not initiate selective connection\n");
3813         }
3814     } else {
3815         if (p_inq_results_cb && (result & BTM_BLE_INQ_RESULT)) {
3816             (p_inq_results_cb)((tBTM_INQ_RESULTS *) &p_i->inq_info.results, p_le_inq_cb->adv_data_cache);
3817             p_le_inq_cb->adv_len = 0;
3818             memset(p_le_inq_cb->adv_addr, 0, BD_ADDR_LEN);
3819             p_i->inq_info.results.adv_data_len = 0;
3820             p_i->inq_info.results.scan_rsp_len = 0;
3821         }
3822         if (p_obs_results_cb && (result & BTM_BLE_OBS_RESULT)) {
3823             (p_obs_results_cb)((tBTM_INQ_RESULTS *) &p_i->inq_info.results, p_le_inq_cb->adv_data_cache);
3824             p_le_inq_cb->adv_len = 0;
3825             memset(p_le_inq_cb->adv_addr, 0, BD_ADDR_LEN);
3826             p_i->inq_info.results.adv_data_len = 0;
3827             p_i->inq_info.results.scan_rsp_len = 0;
3828         }
3829         if (p_scan_results_cb && (result & BTM_BLE_DISCO_RESULT)) {
3830             (p_scan_results_cb)((tBTM_INQ_RESULTS *) &p_i->inq_info.results, p_le_inq_cb->adv_data_cache);
3831             p_le_inq_cb->adv_len = 0;
3832             memset(p_le_inq_cb->adv_addr, 0, BD_ADDR_LEN);
3833             p_i->inq_info.results.adv_data_len = 0;
3834             p_i->inq_info.results.scan_rsp_len = 0;
3835         }
3836     }
3837 }
3838 
btm_ble_process_adv_discard_evt(UINT8 * p)3839 void btm_ble_process_adv_discard_evt(UINT8 *p)
3840 {
3841 #if (BLE_ADV_REPORT_FLOW_CONTROL == TRUE)
3842     uint32_t num_dis = 0;
3843     STREAM_TO_UINT32 (num_dis, p);
3844     tBTM_INQ_DIS_CB *p_obs_discard_cb = btm_cb.ble_ctr_cb.p_obs_discard_cb;
3845     if(p_obs_discard_cb) {
3846         (p_obs_discard_cb)(num_dis);
3847     }
3848 #endif
3849 }
3850 
btm_ble_process_direct_adv_pkt(UINT8 * p)3851 void btm_ble_process_direct_adv_pkt(UINT8 *p)
3852 {
3853     // TODO
3854 }
3855 
3856 /*******************************************************************************
3857 **
3858 ** Function         btm_ble_start_scan
3859 **
3860 ** Description      Start the BLE scan.
3861 **
3862 ** Returns          void
3863 **
3864 *******************************************************************************/
btm_ble_start_scan(void)3865 tBTM_STATUS btm_ble_start_scan(void)
3866 {
3867     tBTM_BLE_INQ_CB *p_inq = &btm_cb.ble_ctr_cb.inq_var;
3868     tBTM_STATUS status = BTM_CMD_STARTED;
3869 
3870     osi_mutex_lock(&scan_enable_lock, OSI_MUTEX_MAX_TIMEOUT);
3871 
3872     if(p_inq->scan_duplicate_filter > BTM_BLE_DUPLICATE_MAX) {
3873         p_inq->scan_duplicate_filter = BTM_BLE_DUPLICATE_DISABLE;
3874     }
3875     /* start scan, disable duplicate filtering */
3876     if (!btsnd_hcic_ble_set_scan_enable (BTM_BLE_SCAN_ENABLE, p_inq->scan_duplicate_filter)) {
3877         status = BTM_NO_RESOURCES;
3878     } else {
3879         osi_sem_take(&scan_enable_sem, OSI_SEM_MAX_TIMEOUT);
3880         if(scan_enable_status != BTM_SUCCESS) {
3881             status = BTM_NO_RESOURCES;
3882         }
3883         btm_cb.ble_ctr_cb.inq_var.state |= BTM_BLE_SCANNING;
3884         if (p_inq->scan_type == BTM_BLE_SCAN_MODE_ACTI) {
3885             btm_ble_set_topology_mask(BTM_BLE_STATE_ACTIVE_SCAN_BIT);
3886         } else {
3887             btm_ble_set_topology_mask(BTM_BLE_STATE_PASSIVE_SCAN_BIT);
3888         }
3889     }
3890     osi_mutex_unlock(&scan_enable_lock);
3891     return status;
3892 }
3893 
3894 /*******************************************************************************
3895 **
3896 ** Function         btm_ble_stop_scan
3897 **
3898 ** Description      Stop the BLE scan.
3899 **
3900 ** Returns          void
3901 **
3902 *******************************************************************************/
btm_ble_stop_scan(void)3903 void btm_ble_stop_scan(void)
3904 {
3905     BTM_TRACE_EVENT ("btm_ble_stop_scan ");
3906 
3907     /* Clear the inquiry callback if set */
3908     btm_cb.ble_ctr_cb.inq_var.scan_type = BTM_BLE_SCAN_MODE_NONE;
3909     btm_cb.ble_ctr_cb.inq_var.state &= ~BTM_BLE_SCANNING;
3910     /* stop discovery now */
3911     btsnd_hcic_ble_set_scan_enable (BTM_BLE_SCAN_DISABLE, BTM_BLE_DUPLICATE_ENABLE);
3912 
3913     btm_update_scanner_filter_policy(SP_ADV_ALL);
3914 
3915     btm_cb.ble_ctr_cb.wl_state &= ~BTM_BLE_WL_SCAN;
3916 }
3917 
3918 /*******************************************************************************
3919 **
3920 ** Function         btm_ble_stop_inquiry
3921 **
3922 ** Description      Stop the BLE Inquiry.
3923 **
3924 ** Returns          void
3925 **
3926 *******************************************************************************/
btm_ble_stop_inquiry(void)3927 void btm_ble_stop_inquiry(void)
3928 {
3929     tBTM_INQUIRY_VAR_ST *p_inq = &btm_cb.btm_inq_vars;
3930     tBTM_BLE_CB *p_ble_cb = &btm_cb.ble_ctr_cb;
3931 
3932     btu_stop_timer (&p_ble_cb->inq_var.inq_timer_ent);
3933 
3934     p_ble_cb->scan_activity &=  ~BTM_BLE_INQUIRY_MASK;
3935 
3936     /* If no more scan activity, stop LE scan now */
3937     if (!BTM_BLE_IS_SCAN_ACTIVE(p_ble_cb->scan_activity)) {
3938         btm_ble_stop_scan();
3939     } else if ((p_ble_cb->inq_var.scan_interval != BTM_BLE_LOW_LATENCY_SCAN_INT) ||
3940                (p_ble_cb->inq_var.scan_window != BTM_BLE_LOW_LATENCY_SCAN_WIN)) {
3941         BTM_TRACE_DEBUG("%s: setting default params for ongoing observe", __FUNCTION__);
3942         btm_ble_stop_scan();
3943         btm_ble_start_scan();
3944     }
3945 
3946     /* If we have a callback registered for inquiry complete, call it */
3947     BTM_TRACE_DEBUG ("BTM Inq Compl Callback: status 0x%02x, num results %d",
3948                      p_inq->inq_cmpl_info.status, p_inq->inq_cmpl_info.num_resp);
3949 
3950     btm_process_inq_complete(HCI_SUCCESS, (UINT8)(p_inq->inqparms.mode & BTM_BLE_INQUIRY_MASK));
3951 }
3952 
3953 /*******************************************************************************
3954 **
3955 ** Function         btm_ble_stop_observe
3956 **
3957 ** Description      Stop the BLE Observe.
3958 **
3959 ** Returns          void
3960 **
3961 *******************************************************************************/
btm_ble_stop_observe(void)3962 static void btm_ble_stop_observe(void)
3963 {
3964     tBTM_BLE_CB *p_ble_cb = & btm_cb.ble_ctr_cb;
3965     tBTM_CMPL_CB *p_obs_cb = p_ble_cb->p_obs_cmpl_cb;
3966 
3967     btu_stop_timer (&p_ble_cb->obs_timer_ent);
3968 
3969     p_ble_cb->scan_activity &= ~BTM_LE_OBSERVE_ACTIVE;
3970 
3971     p_ble_cb->p_obs_results_cb = NULL;
3972     p_ble_cb->p_obs_cmpl_cb = NULL;
3973 
3974     if (!BTM_BLE_IS_SCAN_ACTIVE(p_ble_cb->scan_activity)) {
3975         btm_ble_stop_scan();
3976     }
3977 
3978     if (p_obs_cb) {
3979         (p_obs_cb)((tBTM_INQUIRY_CMPL *) &btm_cb.btm_inq_vars.inq_cmpl_info);
3980     }
3981 }
3982 
3983 /*******************************************************************************
3984 **
3985 ** Function         btm_ble_stop_observe
3986 **
3987 ** Description      Stop the BLE Observe.
3988 **
3989 ** Returns          void
3990 **
3991 *******************************************************************************/
btm_ble_stop_discover(void)3992 static void btm_ble_stop_discover(void)
3993 {
3994     tBTM_BLE_CB *p_ble_cb = & btm_cb.ble_ctr_cb;
3995     tBTM_CMPL_CB *p_scan_cb = p_ble_cb->p_scan_cmpl_cb;
3996     btu_stop_timer (&p_ble_cb->scan_timer_ent);
3997 
3998     osi_mutex_lock(&scan_enable_lock, OSI_MUTEX_MAX_TIMEOUT);
3999     p_ble_cb->scan_activity &= ~BTM_LE_DISCOVER_ACTIVE;
4000 
4001     p_ble_cb->p_scan_results_cb = NULL;
4002     p_ble_cb->p_scan_cmpl_cb = NULL;
4003 
4004     if (!BTM_BLE_IS_SCAN_ACTIVE(p_ble_cb->scan_activity)) {
4005         /* Clear the inquiry callback if set */
4006         btm_cb.ble_ctr_cb.inq_var.scan_type = BTM_BLE_SCAN_MODE_NONE;
4007         btm_cb.ble_ctr_cb.inq_var.state &= ~BTM_BLE_SCANNING;
4008         /* stop discovery now */
4009         if(btsnd_hcic_ble_set_scan_enable (BTM_BLE_SCAN_DISABLE, BTM_BLE_DUPLICATE_ENABLE)) {
4010             osi_sem_take(&scan_enable_sem, OSI_SEM_MAX_TIMEOUT);
4011         }
4012         /* reset status */
4013         btm_ble_clear_topology_mask(BTM_BLE_STATE_ACTIVE_SCAN_BIT);
4014         btm_ble_clear_topology_mask(BTM_BLE_STATE_PASSIVE_SCAN_BIT);
4015     }
4016 
4017     if (p_scan_cb) {
4018         (p_scan_cb)((tBTM_INQUIRY_CMPL *) &btm_cb.btm_inq_vars.inq_cmpl_info);
4019     }
4020     osi_mutex_unlock(&scan_enable_lock);
4021 }
4022 
4023 /*******************************************************************************
4024 **
4025 ** Function         btm_ble_adv_states_operation
4026 **
4027 ** Description      Set or clear adv states in topology mask
4028 **
4029 ** Returns          operation status. TRUE if successful, FALSE otherwise.
4030 **
4031 *******************************************************************************/
4032 typedef BOOLEAN (BTM_TOPOLOGY_FUNC_PTR)(tBTM_BLE_STATE_MASK);
btm_ble_adv_states_operation(BTM_TOPOLOGY_FUNC_PTR * p_handler,UINT8 adv_evt)4033 static BOOLEAN btm_ble_adv_states_operation(BTM_TOPOLOGY_FUNC_PTR *p_handler, UINT8 adv_evt)
4034 {
4035     BOOLEAN rt = FALSE;
4036 
4037     switch (adv_evt) {
4038     case BTM_BLE_CONNECT_EVT:
4039         rt  = (*p_handler)(BTM_BLE_STATE_CONN_ADV_BIT);
4040         break;
4041 
4042     case  BTM_BLE_NON_CONNECT_EVT:
4043         rt  = (*p_handler) (BTM_BLE_STATE_NON_CONN_ADV_BIT);
4044         break;
4045     case BTM_BLE_CONNECT_DIR_EVT:
4046         rt  =  (*p_handler) (BTM_BLE_STATE_HI_DUTY_DIR_ADV_BIT);
4047         break;
4048 
4049     case BTM_BLE_DISCOVER_EVT:
4050         rt  =  (*p_handler) (BTM_BLE_STATE_SCAN_ADV_BIT);
4051         break;
4052 
4053     case BTM_BLE_CONNECT_LO_DUTY_DIR_EVT:
4054         rt = (*p_handler) (BTM_BLE_STATE_LO_DUTY_DIR_ADV_BIT);
4055         break;
4056 
4057     default:
4058         BTM_TRACE_ERROR("unknown adv event : %d", adv_evt);
4059         break;
4060     }
4061 
4062     return rt;
4063 }
4064 
4065 
4066 /*******************************************************************************
4067 **
4068 ** Function         btm_ble_start_adv
4069 **
4070 ** Description      start the BLE advertising.
4071 **
4072 ** Returns          void
4073 **
4074 *******************************************************************************/
btm_ble_start_adv(void)4075 tBTM_STATUS btm_ble_start_adv(void)
4076 {
4077     tBTM_BLE_INQ_CB *p_cb = &btm_cb.ble_ctr_cb.inq_var;
4078     tBTM_STATUS     rt = BTM_NO_RESOURCES;
4079     BTM_TRACE_EVENT ("btm_ble_start_adv\n");
4080 
4081 
4082     if (!btm_ble_adv_states_operation (btm_ble_topology_check, p_cb->evt_type)) {
4083         return BTM_WRONG_MODE;
4084     }
4085 
4086     osi_mutex_lock(&adv_enable_lock, OSI_MUTEX_MAX_TIMEOUT);
4087 
4088 #if (defined BLE_PRIVACY_SPT && BLE_PRIVACY_SPT == TRUE)
4089     /* To relax resolving list,  always have resolving list enabled, unless directed adv */
4090     if (p_cb->evt_type != BTM_BLE_CONNECT_LO_DUTY_DIR_EVT &&
4091             p_cb->evt_type != BTM_BLE_CONNECT_DIR_EVT)
4092         /* enable resolving list is desired */
4093     {
4094         //btm_ble_enable_resolving_list_for_platform(BTM_BLE_RL_ADV);
4095     }
4096 #endif
4097     if (p_cb->afp != AP_SCAN_CONN_ALL) {
4098         //find the device in the btm dev buffer and write it to the controller white list
4099         btm_execute_wl_dev_operation();
4100         btm_cb.ble_ctr_cb.wl_state |= BTM_BLE_WL_ADV;
4101     }
4102     /* The complete event comes up immediately after the 'btsnd_hcic_ble_set_adv_enable' being called in dual core,
4103     this causes the 'adv_mode' and 'state' not be set yet, so we set the state first */
4104     tBTM_BLE_GAP_STATE temp_state = p_cb->state;
4105     UINT8 adv_mode = p_cb->adv_mode;
4106     p_cb->adv_mode = BTM_BLE_ADV_ENABLE;
4107     p_cb->state |= BTM_BLE_ADVERTISING;
4108     btm_ble_adv_states_operation(btm_ble_set_topology_mask, p_cb->evt_type);
4109     if (btsnd_hcic_ble_set_adv_enable (BTM_BLE_ADV_ENABLE)) {
4110         osi_sem_take(&adv_enable_sem, OSI_SEM_MAX_TIMEOUT);
4111         rt = adv_enable_status;
4112         BTM_TRACE_EVENT ("BTM_SUCCESS\n");
4113     } else {
4114         p_cb->adv_mode = BTM_BLE_ADV_DISABLE;
4115         p_cb->state = temp_state;
4116         p_cb->adv_mode = adv_mode;
4117         btm_ble_adv_states_operation(btm_ble_clear_topology_mask, p_cb->evt_type);
4118         btm_cb.ble_ctr_cb.wl_state &= ~BTM_BLE_WL_ADV;
4119     }
4120 
4121     if(adv_enable_status != HCI_SUCCESS) {
4122         p_cb->adv_mode = adv_mode;
4123     }
4124     osi_mutex_unlock(&adv_enable_lock);
4125     return rt;
4126 }
4127 
4128 /*******************************************************************************
4129 **
4130 ** Function         btm_ble_stop_adv
4131 **
4132 ** Description      Stop the BLE advertising.
4133 **
4134 ** Returns          void
4135 **
4136 *******************************************************************************/
btm_ble_stop_adv(void)4137 tBTM_STATUS btm_ble_stop_adv(void)
4138 {
4139     tBTM_BLE_INQ_CB *p_cb = &btm_cb.ble_ctr_cb.inq_var;
4140     tBTM_STATUS rt = BTM_SUCCESS;
4141     if (p_cb) {
4142         osi_mutex_lock(&adv_enable_lock, OSI_MUTEX_MAX_TIMEOUT);
4143         UINT8 temp_adv_mode = p_cb->adv_mode;
4144         BOOLEAN temp_fast_adv_on = p_cb->fast_adv_on;
4145         tBTM_BLE_GAP_STATE temp_state = p_cb->state;
4146         tBTM_BLE_WL_STATE temp_wl_state = btm_cb.ble_ctr_cb.wl_state;
4147         tBTM_BLE_STATE_MASK temp_mask = btm_ble_get_topology_mask ();
4148 
4149         p_cb->fast_adv_on = FALSE;
4150         p_cb->adv_mode = BTM_BLE_ADV_DISABLE;
4151         p_cb->state &= ~BTM_BLE_ADVERTISING;
4152         btm_cb.ble_ctr_cb.wl_state &= ~BTM_BLE_WL_ADV;
4153 
4154         /* clear all adv states */
4155         btm_ble_clear_topology_mask (BTM_BLE_STATE_ALL_ADV_MASK);
4156 
4157         if (btsnd_hcic_ble_set_adv_enable (BTM_BLE_ADV_DISABLE)) {
4158             osi_sem_take(&adv_enable_sem, OSI_SEM_MAX_TIMEOUT);
4159             rt = adv_enable_status;
4160         } else {
4161             // reset state
4162             p_cb->fast_adv_on = temp_fast_adv_on;
4163             p_cb->adv_mode = temp_adv_mode;
4164             p_cb->state = temp_state;
4165             btm_cb.ble_ctr_cb.wl_state = temp_wl_state;
4166             btm_ble_set_topology_mask (temp_mask);
4167 
4168             rt = BTM_NO_RESOURCES;
4169         }
4170         if(adv_enable_status != HCI_SUCCESS) {
4171             p_cb->adv_mode = temp_adv_mode;
4172         }
4173         osi_mutex_unlock(&adv_enable_lock);
4174     }
4175     return rt;
4176 }
4177 
btm_ble_set_random_addr(BD_ADDR random_bda)4178 tBTM_STATUS btm_ble_set_random_addr(BD_ADDR random_bda)
4179 {
4180     tBTM_STATUS rt = BTM_SUCCESS;
4181 
4182     osi_mutex_lock(&adv_enable_lock, OSI_MUTEX_MAX_TIMEOUT);
4183     osi_mutex_lock(&scan_enable_lock, OSI_MUTEX_MAX_TIMEOUT);
4184 
4185     if (btm_cb.ble_ctr_cb.inq_var.adv_mode == BTM_BLE_ADV_ENABLE) {
4186         if (btsnd_hcic_ble_set_adv_enable (BTM_BLE_ADV_DISABLE)) {
4187             osi_sem_take(&adv_enable_sem, OSI_SEM_MAX_TIMEOUT);
4188             rt = adv_enable_status;
4189         } else {
4190             rt = BTM_BAD_VALUE_RET;
4191         }
4192     }
4193 
4194     if (BTM_BLE_IS_DISCO_ACTIVE(btm_cb.ble_ctr_cb.scan_activity)) {
4195         if (btsnd_hcic_ble_set_scan_enable (BTM_BLE_SCAN_DISABLE, BTM_BLE_SCAN_DUPLICATE_DISABLE)) {
4196             osi_sem_take(&scan_enable_sem, OSI_SEM_MAX_TIMEOUT);
4197             rt = scan_enable_status;
4198         } else {
4199             rt = BTM_BAD_VALUE_RET;
4200         }
4201     }
4202 
4203     if (rt == BTM_SUCCESS) {
4204         btsnd_hcic_ble_set_random_addr(random_bda);
4205     }
4206 
4207     if (btm_cb.ble_ctr_cb.inq_var.adv_mode == BTM_BLE_ADV_ENABLE) {
4208         if (btsnd_hcic_ble_set_adv_enable (BTM_BLE_ADV_ENABLE)) {
4209             osi_sem_take(&adv_enable_sem, OSI_SEM_MAX_TIMEOUT);
4210             rt = adv_enable_status;
4211         } else {
4212             rt = BTM_BAD_VALUE_RET;
4213         }
4214     }
4215 
4216     if (BTM_BLE_IS_DISCO_ACTIVE(btm_cb.ble_ctr_cb.scan_activity)) {
4217         if (btsnd_hcic_ble_set_scan_enable (BTM_BLE_SCAN_ENABLE, btm_cb.ble_ctr_cb.inq_var.scan_duplicate_filter)) {
4218             osi_sem_take(&scan_enable_sem, OSI_SEM_MAX_TIMEOUT);
4219             rt = scan_enable_status;
4220         } else {
4221             rt = BTM_BAD_VALUE_RET;
4222         }
4223     }
4224 
4225     osi_mutex_unlock(&adv_enable_lock);
4226     osi_mutex_unlock(&scan_enable_lock);
4227 
4228     return rt;
4229 }
4230 
4231 
4232 /*******************************************************************************
4233 **
4234 ** Function         btm_ble_start_slow_adv
4235 **
4236 ** Description      Restart adv with slow adv interval
4237 **
4238 ** Returns          void
4239 **
4240 *******************************************************************************/
btm_ble_start_slow_adv(void)4241 static void btm_ble_start_slow_adv (void)
4242 {
4243     tBTM_BLE_INQ_CB *p_cb = &btm_cb.ble_ctr_cb.inq_var;
4244 
4245     if (p_cb->adv_mode == BTM_BLE_ADV_ENABLE) {
4246         tBTM_LE_RANDOM_CB *p_addr_cb = &btm_cb.ble_ctr_cb.addr_mgnt_cb;
4247         BD_ADDR p_addr_ptr = {0};
4248         tBLE_ADDR_TYPE init_addr_type = BLE_ADDR_PUBLIC;
4249         tBLE_ADDR_TYPE own_addr_type = p_addr_cb->own_addr_type;
4250 
4251         btm_ble_stop_adv();
4252 
4253         p_cb->evt_type = btm_set_conn_mode_adv_init_addr(p_cb, p_addr_ptr, &init_addr_type,
4254                          &own_addr_type);
4255 
4256         /* slow adv mode never goes into directed adv */
4257         btsnd_hcic_ble_write_adv_params (BTM_BLE_GAP_ADV_SLOW_INT, BTM_BLE_GAP_ADV_SLOW_INT,
4258                                          p_cb->evt_type, own_addr_type,
4259                                          init_addr_type, p_addr_ptr,
4260                                          p_cb->adv_chnl_map, p_cb->afp);
4261 
4262         btm_ble_start_adv();
4263     }
4264 }
4265 /*******************************************************************************
4266 **
4267 ** Function         btm_ble_timeout
4268 **
4269 ** Description      Called when BTM BLE inquiry timer expires
4270 **
4271 ** Returns          void
4272 **
4273 *******************************************************************************/
btm_ble_timeout(TIMER_LIST_ENT * p_tle)4274 void btm_ble_timeout(TIMER_LIST_ENT *p_tle)
4275 {
4276     BTM_TRACE_EVENT ("btm_ble_timeout");
4277 
4278     switch (p_tle->event) {
4279     case BTU_TTYPE_BLE_OBSERVE:
4280         btm_ble_stop_observe();
4281         break;
4282     case BTU_TTYPE_BLE_SCAN:
4283         btm_ble_stop_discover();
4284         break;
4285     case BTU_TTYPE_BLE_INQUIRY:
4286         btm_ble_stop_inquiry();
4287         break;
4288 
4289     case BTU_TTYPE_BLE_GAP_LIM_DISC:
4290         /* lim_timeout expired, limited discovery should exit now */
4291         btm_cb.btm_inq_vars.discoverable_mode &= ~BTM_BLE_LIMITED_DISCOVERABLE;
4292         btm_ble_set_adv_flag(btm_cb.btm_inq_vars.connectable_mode, btm_cb.btm_inq_vars.discoverable_mode);
4293         break;
4294 
4295     case BTU_TTYPE_BLE_RANDOM_ADDR:
4296         if (btm_cb.ble_ctr_cb.addr_mgnt_cb.own_addr_type == BLE_ADDR_RANDOM) {
4297             if (NULL == (void *)(p_tle->param)) {
4298 #if (CONTROLLER_RPA_LIST_ENABLE == FALSE)
4299                 /* refresh the random addr */
4300                 btm_gen_resolvable_private_addr((void *)btm_gen_resolve_paddr_low);
4301 #endif
4302             } else {
4303                 if (BTM_BleMaxMultiAdvInstanceCount() > 0) {
4304                     btm_ble_multi_adv_configure_rpa((tBTM_BLE_MULTI_ADV_INST *)p_tle->param);
4305                 }
4306             }
4307         }
4308         break;
4309 
4310     case BTU_TTYPE_BLE_GAP_FAST_ADV:
4311         /* fast adv is completed, fall back to slow adv interval */
4312         btm_ble_start_slow_adv();
4313         break;
4314 
4315     default:
4316         break;
4317 
4318     }
4319 }
4320 
4321 
4322 /*******************************************************************************
4323 **
4324 ** Function         btm_ble_read_remote_features_complete
4325 **
4326 ** Description      This function is called when the command complete message
4327 **                  is received from the HCI for the read LE remote feature supported
4328 **                  complete event.
4329 **
4330 ** Returns          void
4331 **
4332 *******************************************************************************/
btm_ble_read_remote_features_complete(UINT8 * p)4333 void btm_ble_read_remote_features_complete(UINT8 *p)
4334 {
4335     tACL_CONN        *p_acl_cb = NULL;
4336     UINT16            handle;
4337     UINT8             status;
4338 
4339     BTM_TRACE_EVENT ("btm_ble_read_remote_features_complete ");
4340 
4341     STREAM_TO_UINT8(status, p);
4342 
4343     // if LE read remote feature failed for HCI_ERR_CONN_FAILED_ESTABLISHMENT,
4344     // expect disconnect complete to be received
4345     if (status != HCI_ERR_CONN_FAILED_ESTABLISHMENT) {
4346         STREAM_TO_UINT16 (handle, p);
4347 
4348         /* Look up the connection by handle and copy features */
4349         p_acl_cb = btm_handle_to_acl(handle);
4350 	if (p_acl_cb) {
4351 	    {
4352                 STREAM_TO_ARRAY(p_acl_cb->peer_le_features, p, BD_FEATURES_LEN);
4353 #if BLE_INCLUDED == TRUE
4354                 /* In the original Bluedroid version, slave need to send LL_VERSION_IND(call btsnd_hcic_rmt_ver_req)
4355                  * to remote device if it has not received ll_version_ind.
4356                  * Delete it to resolve Android 7.0 incompatible problem. But it may cause that slave host
4357                  * can't get remote device's version.*/
4358                 if (p_acl_cb->link_role == HCI_ROLE_MASTER){
4359                     btsnd_hcic_rmt_ver_req (p_acl_cb->hci_handle);
4360                 }
4361                 else{
4362                     uint16_t data_length = controller_get_interface()->get_ble_default_data_packet_length();
4363                     uint16_t data_txtime = controller_get_interface()->get_ble_default_data_packet_txtime();
4364                     if (p_acl_cb->transport == BT_TRANSPORT_LE) {
4365                         if (HCI_LE_DATA_LEN_EXT_SUPPORTED(p_acl_cb->peer_le_features) &&
4366                             (p_acl_cb->data_length_params.tx_len != data_length)) {
4367                             p_acl_cb->data_len_updating = true;
4368                             btsnd_hcic_ble_set_data_length(p_acl_cb->hci_handle, data_length, data_txtime);
4369                         }
4370                         l2cble_notify_le_connection (p_acl_cb->remote_addr);
4371                     }
4372                 }
4373 #endif
4374             }
4375         }
4376     }
4377 
4378 }
4379 
4380 /*******************************************************************************
4381 **
4382 ** Function         btm_ble_write_adv_enable_complete
4383 **
4384 ** Description      This function process the write adv enable command complete.
4385 **
4386 ** Returns          void
4387 **
4388 *******************************************************************************/
btm_ble_write_adv_enable_complete(UINT8 * p)4389 void btm_ble_write_adv_enable_complete(UINT8 *p)
4390 {
4391     /* if write adv enable/disbale not succeed */
4392     if (*p != HCI_SUCCESS) {
4393         BTM_TRACE_ERROR("%s failed", __func__);
4394     }
4395 }
4396 
4397 /*******************************************************************************
4398 **
4399 ** Function         btm_ble_dir_adv_tout
4400 **
4401 ** Description      when directed adv time out
4402 **
4403 ** Returns          void
4404 **
4405 *******************************************************************************/
btm_ble_dir_adv_tout(void)4406 void btm_ble_dir_adv_tout(void)
4407 {
4408     btm_cb.ble_ctr_cb.inq_var.adv_mode = BTM_BLE_ADV_DISABLE;
4409 
4410     /* make device fall back into undirected adv mode by default */
4411     btm_cb.ble_ctr_cb.inq_var.directed_conn = FALSE;
4412 }
4413 
4414 /*******************************************************************************
4415 **
4416 ** Function         btm_ble_set_topology_mask
4417 **
4418 ** Description      set BLE topology mask
4419 **
4420 ** Returns          TRUE is request is allowed, FALSE otherwise.
4421 **
4422 *******************************************************************************/
btm_ble_set_topology_mask(tBTM_BLE_STATE_MASK request_state_mask)4423 BOOLEAN btm_ble_set_topology_mask(tBTM_BLE_STATE_MASK request_state_mask)
4424 {
4425     request_state_mask &= BTM_BLE_STATE_ALL_MASK;
4426     btm_cb.ble_ctr_cb.cur_states |= (request_state_mask & BTM_BLE_STATE_ALL_MASK);
4427     return TRUE;
4428 }
4429 
4430 /*******************************************************************************
4431 **
4432 ** Function         btm_ble_clear_topology_mask
4433 **
4434 ** Description      Clear BLE topology bit mask
4435 **
4436 ** Returns          TRUE is request is allowed, FALSE otherwise.
4437 **
4438 *******************************************************************************/
btm_ble_clear_topology_mask(tBTM_BLE_STATE_MASK request_state_mask)4439 BOOLEAN btm_ble_clear_topology_mask (tBTM_BLE_STATE_MASK request_state_mask)
4440 {
4441     request_state_mask &= BTM_BLE_STATE_ALL_MASK;
4442     btm_cb.ble_ctr_cb.cur_states &= ~request_state_mask;
4443     return TRUE;
4444 }
4445 
4446 /*******************************************************************************
4447 **
4448 ** Function         btm_ble_get_topology_mask
4449 **
4450 ** Description      Get BLE topology bit mask
4451 **
4452 ** Returns          state mask.
4453 **
4454 *******************************************************************************/
btm_ble_get_topology_mask(void)4455 tBTM_BLE_STATE_MASK btm_ble_get_topology_mask (void)
4456 {
4457     return btm_cb.ble_ctr_cb.cur_states;
4458 }
4459 
4460 /*******************************************************************************
4461 **
4462 ** Function         btm_ble_update_link_topology_mask
4463 **
4464 ** Description      This function update the link topology mask
4465 **
4466 ** Returns          void
4467 **
4468 *******************************************************************************/
btm_ble_update_link_topology_mask(UINT8 link_role,BOOLEAN increase)4469 void btm_ble_update_link_topology_mask(UINT8 link_role, BOOLEAN increase)
4470 {
4471     btm_ble_clear_topology_mask (BTM_BLE_STATE_ALL_CONN_MASK);
4472 
4473     if (increase) {
4474         btm_cb.ble_ctr_cb.link_count[link_role]++;
4475     } else if (btm_cb.ble_ctr_cb.link_count[link_role] > 0) {
4476         btm_cb.ble_ctr_cb.link_count[link_role]--;
4477     }
4478 
4479     if (btm_cb.ble_ctr_cb.link_count[HCI_ROLE_MASTER]) {
4480         btm_ble_set_topology_mask (BTM_BLE_STATE_MASTER_BIT);
4481     }
4482 
4483     if (btm_cb.ble_ctr_cb.link_count[HCI_ROLE_SLAVE]) {
4484         btm_ble_set_topology_mask(BTM_BLE_STATE_SLAVE_BIT);
4485     }
4486 
4487     if (link_role == HCI_ROLE_SLAVE && increase) {
4488         btm_cb.ble_ctr_cb.inq_var.adv_mode = BTM_BLE_ADV_DISABLE;
4489         /* make device fall back into undirected adv mode by default */
4490         btm_cb.ble_ctr_cb.inq_var.directed_conn = BTM_BLE_CONNECT_EVT;
4491         /* clear all adv states */
4492         btm_ble_clear_topology_mask(BTM_BLE_STATE_ALL_ADV_MASK);
4493     }
4494 }
4495 
4496 /*******************************************************************************
4497 **
4498 ** Function         btm_ble_update_mode_operation
4499 **
4500 ** Description      This function update the GAP role operation when a link status
4501 **                  is updated.
4502 **
4503 ** Returns          void
4504 **
4505 *******************************************************************************/
btm_ble_update_mode_operation(UINT8 link_role,BD_ADDR bd_addr,UINT8 status)4506 BOOLEAN btm_ble_update_mode_operation(UINT8 link_role, BD_ADDR bd_addr, UINT8 status)
4507 {
4508     BOOLEAN bg_con = FALSE;
4509     if (status == HCI_ERR_DIRECTED_ADVERTISING_TIMEOUT) {
4510         btm_cb.ble_ctr_cb.inq_var.adv_mode  = BTM_BLE_ADV_DISABLE;
4511         /* make device fall back into undirected adv mode by default */
4512         btm_cb.ble_ctr_cb.inq_var.directed_conn = BTM_BLE_CONNECT_EVT;
4513         /* clear all adv states */
4514         btm_ble_clear_topology_mask (BTM_BLE_STATE_ALL_ADV_MASK);
4515     }
4516 
4517     if (btm_cb.ble_ctr_cb.inq_var.connectable_mode == BTM_BLE_CONNECTABLE) {
4518         btm_ble_set_connectability(btm_cb.btm_inq_vars.connectable_mode |
4519                                    btm_cb.ble_ctr_cb.inq_var.connectable_mode);
4520     }
4521 
4522     /* when no connection is attempted, and controller is not rejecting last request
4523        due to resource limitation, start next direct connection or background connection
4524        now in order */
4525     if (btm_ble_get_conn_st() == BLE_CONN_IDLE && status != HCI_ERR_HOST_REJECT_RESOURCES &&
4526             !btm_send_pending_direct_conn()) {
4527         bg_con = btm_ble_resume_bg_conn();
4528     }
4529 
4530     return bg_con;
4531 }
4532 
4533 /*******************************************************************************
4534 **
4535 ** Function         btm_ble_init
4536 **
4537 ** Description      Initialize the control block variable values.
4538 **
4539 ** Returns          void
4540 **
4541 *******************************************************************************/
btm_ble_init(void)4542 void btm_ble_init (void)
4543 {
4544     BTM_TRACE_DEBUG("%s", __func__);
4545 
4546 #if BTM_DYNAMIC_MEMORY == TRUE
4547     cmn_ble_gap_vsc_cb_ptr = (tBTM_BLE_VSC_CB *)osi_malloc(sizeof(tBTM_BLE_VSC_CB));
4548     if (cmn_ble_gap_vsc_cb_ptr == NULL) {
4549         BTM_TRACE_ERROR("%s malloc failed", __func__);
4550         return;
4551     }
4552 #endif
4553 
4554     tBTM_BLE_CB *p_cb = &btm_cb.ble_ctr_cb;
4555 
4556     btu_free_timer(&p_cb->obs_timer_ent);
4557     btu_free_timer(&p_cb->scan_timer_ent);
4558     btu_free_timer(&p_cb->inq_var.fast_adv_timer);
4559     memset(p_cb, 0, sizeof(tBTM_BLE_CB));
4560     memset(&(btm_cb.cmn_ble_vsc_cb), 0 , sizeof(tBTM_BLE_VSC_CB));
4561     btm_cb.cmn_ble_vsc_cb.values_read = FALSE;
4562     p_cb->cur_states       = 0;
4563 
4564     p_cb->conn_pending_q = fixed_queue_new(QUEUE_SIZE_MAX);
4565 
4566     p_cb->inq_var.adv_mode = BTM_BLE_ADV_DISABLE;
4567     p_cb->inq_var.scan_type = BTM_BLE_SCAN_MODE_NONE;
4568     p_cb->inq_var.adv_chnl_map = BTM_BLE_DEFAULT_ADV_CHNL_MAP;
4569     p_cb->inq_var.afp = BTM_BLE_DEFAULT_AFP;
4570     p_cb->inq_var.sfp = BTM_BLE_DEFAULT_SFP;
4571     p_cb->inq_var.connectable_mode = BTM_BLE_NON_CONNECTABLE;
4572     p_cb->inq_var.discoverable_mode = BTM_BLE_NON_DISCOVERABLE;
4573 
4574     /* for background connection, reset connection params to be undefined */
4575     p_cb->scan_int = p_cb->scan_win = BTM_BLE_SCAN_PARAM_UNDEF;
4576 
4577     p_cb->inq_var.evt_type = BTM_BLE_NON_CONNECT_EVT;
4578 
4579     p_cb->adv_rpt_queue = pkt_queue_create();
4580     assert(p_cb->adv_rpt_queue != NULL);
4581 
4582     p_cb->adv_rpt_ready = osi_event_create(btm_adv_pkt_handler, NULL);
4583     assert(p_cb->adv_rpt_ready != NULL);
4584     osi_event_bind(p_cb->adv_rpt_ready, btu_get_current_thread(), 0);
4585 
4586 #if BLE_VND_INCLUDED == FALSE
4587     btm_ble_adv_filter_init();
4588 #endif
4589 }
4590 
4591 /*******************************************************************************
4592 **
4593 ** Function         btm_ble_free
4594 **
4595 ** Description      free the control block variable values.
4596 **
4597 ** Returns          void
4598 **
4599 *******************************************************************************/
btm_ble_free(void)4600 void btm_ble_free (void)
4601 {
4602     tBTM_BLE_CB *p_cb = &btm_cb.ble_ctr_cb;
4603 
4604     BTM_TRACE_DEBUG("%s", __func__);
4605 
4606     fixed_queue_free(p_cb->conn_pending_q, osi_free_func);
4607 
4608     pkt_queue_destroy(p_cb->adv_rpt_queue, NULL);
4609     p_cb->adv_rpt_queue = NULL;
4610 
4611     osi_event_delete(p_cb->adv_rpt_ready);
4612     p_cb->adv_rpt_ready = NULL;
4613 
4614 #if BTM_DYNAMIC_MEMORY == TRUE
4615     osi_free(cmn_ble_gap_vsc_cb_ptr);
4616     cmn_ble_gap_vsc_cb_ptr = NULL;
4617 #endif
4618 }
4619 
4620 static bool enable_topology_check_flag = true;
esp_qa_enable_topology_check(bool enable)4621 void esp_qa_enable_topology_check(bool enable)
4622 {
4623     // This is a workaround: If the topology check is disabled, the 'Supported States' will not be checked.
4624     enable_topology_check_flag = enable;
4625 }
4626 /*******************************************************************************
4627 **
4628 ** Function         btm_ble_topology_check
4629 **
4630 ** Description      check to see requested state is supported. One state check at
4631 **                  a time is supported
4632 **
4633 ** Returns          TRUE is request is allowed, FALSE otherwise.
4634 **
4635 *******************************************************************************/
btm_ble_topology_check(tBTM_BLE_STATE_MASK request_state_mask)4636 BOOLEAN btm_ble_topology_check(tBTM_BLE_STATE_MASK request_state_mask)
4637 {
4638     if(!enable_topology_check_flag) return TRUE;
4639     BOOLEAN rt = FALSE;
4640 
4641     UINT8   state_offset = 0;
4642     UINT16  cur_states = btm_cb.ble_ctr_cb.cur_states;
4643     UINT8   mask, offset;
4644     UINT8   request_state = 0;
4645 
4646     /* check only one bit is set and within valid range */
4647     if (request_state_mask == BTM_BLE_STATE_INVALID ||
4648             request_state_mask > BTM_BLE_STATE_SCAN_ADV_BIT ||
4649             (request_state_mask & (request_state_mask - 1 )) != 0) {
4650         BTM_TRACE_ERROR("illegal state requested: %d", request_state_mask);
4651         return rt;
4652     }
4653 
4654     while (request_state_mask) {
4655         request_state_mask >>= 1;
4656         request_state ++;
4657     }
4658 
4659     /* check if the requested state is supported or not */
4660     mask = btm_le_state_combo_tbl[0][request_state - 1][0];
4661     offset = btm_le_state_combo_tbl[0][request_state - 1][1];
4662 
4663     const uint8_t *ble_supported_states = controller_get_interface()->get_ble_supported_states();
4664 
4665     if (!BTM_LE_STATES_SUPPORTED(ble_supported_states, mask, offset)) {
4666         BTM_TRACE_ERROR("state requested not supported: %d", request_state);
4667         return rt;
4668     }
4669 
4670     rt = TRUE;
4671     /* make sure currently active states are all supported in conjunction with the requested
4672        state. If the bit in table is not set, the combination is not supported */
4673     while (cur_states != 0) {
4674         if (cur_states & 0x01) {
4675             mask = btm_le_state_combo_tbl[request_state][state_offset][0];
4676             offset = btm_le_state_combo_tbl[request_state][state_offset][1];
4677 
4678             if (mask != 0 && offset != 0) {
4679                 if (!BTM_LE_STATES_SUPPORTED(ble_supported_states, mask, offset)) {
4680                     rt = FALSE;
4681                     break;
4682                 }
4683             }
4684         }
4685         cur_states >>= 1;
4686         state_offset ++;
4687     }
4688     return rt;
4689 }
4690 
4691 /*******************************************************************************
4692  **
4693  ** Function         BTM_Ble_Authorization
4694  **
4695  ** Description      This function is used to authorize a specified device
4696  **
4697  ** Returns          TRUE or FALSE
4698  **
4699  *******************************************************************************/
BTM_Ble_Authorization(BD_ADDR bd_addr,BOOLEAN authorize)4700 BOOLEAN BTM_Ble_Authorization(BD_ADDR bd_addr, BOOLEAN authorize)
4701 {
4702     if (bd_addr == NULL) {
4703         BTM_TRACE_ERROR("bd_addr is NULL");
4704         return FALSE;
4705     }
4706 
4707     if (btm_sec_dev_authorization(bd_addr, authorize)) {
4708         return TRUE;
4709     }
4710 
4711     BTM_TRACE_ERROR("Authorization fail");
4712     return FALSE;
4713 }
4714 
4715 /*******************************************************************************
4716 **
4717 ** Function         BTM_BleClearAdv
4718 **
4719 ** Description      This function is called to clear legacy advertising
4720 **
4721 ** Parameter        p_clear_adv_cback - Command complete callback
4722 **
4723 *******************************************************************************/
BTM_BleClearAdv(tBTM_CLEAR_ADV_CMPL_CBACK * p_clear_adv_cback)4724 BOOLEAN BTM_BleClearAdv(tBTM_CLEAR_ADV_CMPL_CBACK *p_clear_adv_cback)
4725 {
4726     tBTM_BLE_CB *p_cb = &btm_cb.ble_ctr_cb;
4727 
4728     if (btsnd_hcic_ble_clear_adv() == FALSE) {
4729         BTM_TRACE_ERROR("%s: Unable to Clear Advertising", __FUNCTION__);
4730         return FALSE;
4731     }
4732 
4733     p_cb->inq_var.p_clear_adv_cb = p_clear_adv_cback;
4734     return TRUE;
4735 }
BTM_BleSetRpaTimeout(uint16_t rpa_timeout,tBTM_SET_RPA_TIMEOUT_CMPL_CBACK * p_set_rpa_timeout_cback)4736 BOOLEAN BTM_BleSetRpaTimeout(uint16_t rpa_timeout,tBTM_SET_RPA_TIMEOUT_CMPL_CBACK *p_set_rpa_timeout_cback)
4737 {
4738     if ((btsnd_hcic_ble_set_rand_priv_addr_timeout(rpa_timeout)) != TRUE) {
4739         BTM_TRACE_ERROR("Set RPA Timeout error, rpa_timeout:0x%04x",rpa_timeout);
4740         return FALSE;
4741     }
4742     btm_cb.devcb.p_ble_set_rpa_timeout_cmpl_cb = p_set_rpa_timeout_cback;
4743     return TRUE;
4744 }
4745 
BTM_BleAddDevToResolvingList(BD_ADDR addr,uint8_t addr_type,uint8_t irk[],tBTM_ADD_DEV_TO_RESOLVING_LIST_CMPL_CBACK * p_add_dev_to_resolving_list_callback)4746 BOOLEAN BTM_BleAddDevToResolvingList(BD_ADDR addr,
4747                                       uint8_t addr_type,
4748                                       uint8_t irk[],
4749                                       tBTM_ADD_DEV_TO_RESOLVING_LIST_CMPL_CBACK *p_add_dev_to_resolving_list_callback)
4750 {
4751     UINT8 *local_irk = btm_cb.devcb.id_keys.irk;
4752     if ((btsnd_hcic_ble_add_device_resolving_list(addr_type, addr, irk, local_irk)) != TRUE) {
4753         BTM_TRACE_ERROR("Add device to resolving list error");
4754         return FALSE;
4755     }
4756     btm_cb.devcb.p_add_dev_to_resolving_list_cmpl_cb = p_add_dev_to_resolving_list_callback;
4757     return TRUE;
4758 }
4759 
BTM_BleSetPrivacyMode(UINT8 addr_type,BD_ADDR bd_addr,UINT8 privacy_mode,tBTM_SET_PRIVACY_MODE_CMPL_CBACK * p_callback)4760 BOOLEAN BTM_BleSetPrivacyMode(UINT8 addr_type, BD_ADDR bd_addr, UINT8 privacy_mode, tBTM_SET_PRIVACY_MODE_CMPL_CBACK *p_callback)
4761 {
4762     if (btsnd_hcic_ble_set_privacy_mode(addr_type, bd_addr, privacy_mode) != TRUE) {
4763         BTM_TRACE_ERROR("LE SetPrivacyMode Mode=%d: error", privacy_mode);
4764         return FALSE;
4765     }
4766 
4767     btm_cb.devcb.p_set_privacy_mode_cmpl_cb = p_callback;
4768     return TRUE;
4769 }
4770 
BTM_BleSetCsaSupport(UINT8 csa_select,tBTM_SET_CSA_SUPPORT_CMPL_CBACK * p_callback)4771 BOOLEAN BTM_BleSetCsaSupport(UINT8 csa_select, tBTM_SET_CSA_SUPPORT_CMPL_CBACK *p_callback)
4772 {
4773     if (btsnd_hcic_ble_set_csa_support(csa_select) != TRUE) {
4774         BTM_TRACE_ERROR("LE SetCsaSupport csa_select=%d: error", csa_select);
4775         return FALSE;
4776     }
4777 
4778     btm_cb.ble_ctr_cb.set_csa_support_cmpl_cb = p_callback;
4779     return TRUE;
4780 }
4781 
btm_ble_adv_pkt_ready(void)4782 bool btm_ble_adv_pkt_ready(void)
4783 {
4784     tBTM_BLE_CB *p_cb = &btm_cb.ble_ctr_cb;
4785     osi_thread_post_event(p_cb->adv_rpt_ready, OSI_THREAD_MAX_TIMEOUT);
4786 
4787     return true;
4788 }
4789 
btm_ble_adv_pkt_post(pkt_linked_item_t * pkt)4790 bool btm_ble_adv_pkt_post(pkt_linked_item_t *pkt)
4791 {
4792     if (pkt == NULL) {
4793         return false;
4794     }
4795 
4796     tBTM_BLE_CB *p_cb = &btm_cb.ble_ctr_cb;
4797     pkt_queue_enqueue(p_cb->adv_rpt_queue, pkt);
4798     return true;
4799 }
4800 #endif  /* BLE_INCLUDED */
4801