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