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