1 /******************************************************************************
2 *
3 * Copyright (C) 1999-2012 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 whitelist operation.
22 *
23 ******************************************************************************/
24
25 #include <string.h>
26 #include "common/bt_trace.h"
27 #include "device/controller.h"
28 #include "osi/allocator.h"
29 #include "osi/hash_map.h"
30 #include "stack/bt_types.h"
31 #include "stack/btu.h"
32 #include "btm_int.h"
33 #include "l2c_int.h"
34 #include "stack/hcimsgs.h"
35 //#include "bt_utils.h"
36
37 #ifndef BTM_BLE_SCAN_PARAM_TOUT
38 #define BTM_BLE_SCAN_PARAM_TOUT 50 /* 50 seconds */
39 #endif
40
41 #if (BLE_INCLUDED == TRUE)
42
43 static void btm_suspend_wl_activity(tBTM_BLE_WL_STATE wl_state);
44 static void btm_wl_update_to_controller(void);
45
46 // Unfortunately (for now?) we have to maintain a copy of the device whitelist
47 // on the host to determine if a device is pending to be connected or not. This
48 // controls whether the host should keep trying to scan for whitelisted
49 // peripherals or not.
50 // TODO: Move all of this to controller/le/background_list or similar?
51 static const size_t background_connection_buckets = 42;
52 static hash_map_t *background_connections = NULL;
53
54 typedef struct background_connection_t {
55 bt_bdaddr_t address;
56 } background_connection_t;
57
bdaddr_equality_fn(const void * x,const void * y)58 static bool bdaddr_equality_fn(const void *x, const void *y)
59 {
60 return bdaddr_equals((bt_bdaddr_t *)x, (bt_bdaddr_t *)y);
61 }
62
background_connections_lazy_init(void)63 static void background_connections_lazy_init(void)
64 {
65 if (!background_connections) {
66 background_connections = hash_map_new(background_connection_buckets,
67 hash_function_bdaddr, NULL, osi_free_func, bdaddr_equality_fn);
68 assert(background_connections);
69 }
70 }
71
background_connection_add(bt_bdaddr_t * address)72 static BOOLEAN background_connection_add(bt_bdaddr_t *address)
73 {
74 assert(address);
75 background_connections_lazy_init();
76 background_connection_t *connection = hash_map_get(background_connections, address);
77 if (!connection) {
78 connection = osi_calloc(sizeof(background_connection_t));
79 connection->address = *address;
80 hash_map_set(background_connections, &(connection->address), connection);
81 return TRUE;
82 }
83 return FALSE;
84 }
85
background_connection_remove(bt_bdaddr_t * address)86 static BOOLEAN background_connection_remove(bt_bdaddr_t *address)
87 {
88 if (address && background_connections) {
89 return hash_map_erase(background_connections, address);
90 }
91 return FALSE;
92 }
93
background_connections_clear(void)94 static void background_connections_clear(void)
95 {
96 if (background_connections) {
97 hash_map_clear(background_connections);
98 }
99 }
100
background_connections_pending_cb(hash_map_entry_t * hash_entry,void * context)101 static bool background_connections_pending_cb(hash_map_entry_t *hash_entry, void *context)
102 {
103 bool *pending_connections = context;
104 background_connection_t *connection = hash_entry->data;
105 const bool connected = BTM_IsAclConnectionUp(connection->address.address, BT_TRANSPORT_LE);
106 if (!connected) {
107 *pending_connections = true;
108 return false;
109 }
110 return true;
111 }
112
background_connections_pending(void)113 static bool background_connections_pending(void)
114 {
115 bool pending_connections = false;
116 if (background_connections) {
117 hash_map_foreach(background_connections, background_connections_pending_cb, &pending_connections);
118 }
119 return pending_connections;
120 }
121
122 /*******************************************************************************
123 **
124 ** Function btm_update_scanner_filter_policy
125 **
126 ** Description This function updates the filter policy of scanner
127 *******************************************************************************/
btm_update_scanner_filter_policy(tBTM_BLE_SFP scan_policy)128 void btm_update_scanner_filter_policy(tBTM_BLE_SFP scan_policy)
129 {
130 tBTM_BLE_INQ_CB *p_inq = &btm_cb.ble_ctr_cb.inq_var;
131
132 UINT32 scan_interval = !p_inq->scan_interval ? BTM_BLE_GAP_DISC_SCAN_INT : p_inq->scan_interval;
133 UINT32 scan_window = !p_inq->scan_window ? BTM_BLE_GAP_DISC_SCAN_WIN : p_inq->scan_window;
134
135 BTM_TRACE_EVENT ("%s\n", __func__);
136
137 p_inq->sfp = scan_policy;
138 p_inq->scan_type = p_inq->scan_type == BTM_BLE_SCAN_MODE_NONE ? BTM_BLE_SCAN_MODE_ACTI : p_inq->scan_type;
139
140 if (btm_cb.cmn_ble_vsc_cb.extended_scan_support == 0) {
141 btsnd_hcic_ble_set_scan_params(p_inq->scan_type, (UINT16)scan_interval,
142 (UINT16)scan_window,
143 btm_cb.ble_ctr_cb.addr_mgnt_cb.own_addr_type,
144 scan_policy);
145 } else {
146 btm_ble_send_extended_scan_params(p_inq->scan_type, scan_interval, scan_window,
147 btm_cb.ble_ctr_cb.addr_mgnt_cb.own_addr_type,
148 scan_policy);
149 }
150 }
151 /*******************************************************************************
152 **
153 ** Function btm_add_dev_to_controller
154 **
155 ** Description This function load the device into controller white list
156 *******************************************************************************/
btm_add_dev_to_controller(BOOLEAN to_add,BD_ADDR bd_addr,tBLE_ADDR_TYPE wl_addr_type)157 BOOLEAN btm_add_dev_to_controller (BOOLEAN to_add, BD_ADDR bd_addr, tBLE_ADDR_TYPE wl_addr_type)
158 {
159 /*
160 tBTM_SEC_DEV_REC *p_dev_rec = btm_find_dev (bd_addr);
161 tBLE_ADDR_TYPE addr_type = BLE_ADDR_PUBLIC;
162 BOOLEAN started = FALSE;
163 BD_ADDR dummy_bda = {0};
164 tBT_DEVICE_TYPE dev_type;
165
166 if (p_dev_rec != NULL &&
167 p_dev_rec->device_type & BT_DEVICE_TYPE_BLE) {
168 if (to_add) {
169 if (p_dev_rec->ble.ble_addr_type == BLE_ADDR_PUBLIC || !BTM_BLE_IS_RESOLVE_BDA(bd_addr)) {
170 started = btsnd_hcic_ble_add_white_list (p_dev_rec->ble.ble_addr_type, bd_addr);
171 p_dev_rec->ble.in_controller_list |= BTM_WHITE_LIST_BIT;
172 } else if (memcmp(p_dev_rec->ble.static_addr, bd_addr, BD_ADDR_LEN) != 0 &&
173 memcmp(p_dev_rec->ble.static_addr, dummy_bda, BD_ADDR_LEN) != 0) {
174 started = btsnd_hcic_ble_add_white_list (p_dev_rec->ble.static_addr_type,
175 p_dev_rec->ble.static_addr);
176 p_dev_rec->ble.in_controller_list |= BTM_WHITE_LIST_BIT;
177 }
178 } else {
179 if (p_dev_rec->ble.ble_addr_type == BLE_ADDR_PUBLIC || !BTM_BLE_IS_RESOLVE_BDA(bd_addr)) {
180 started = btsnd_hcic_ble_remove_from_white_list (p_dev_rec->ble.ble_addr_type, bd_addr);
181 }
182 if (memcmp(p_dev_rec->ble.static_addr, dummy_bda, BD_ADDR_LEN) != 0 &&
183 memcmp(p_dev_rec->ble.static_addr, bd_addr, BD_ADDR_LEN) != 0) {
184 started = btsnd_hcic_ble_remove_from_white_list (p_dev_rec->ble.static_addr_type, p_dev_rec->ble.static_addr);
185 }
186 p_dev_rec->ble.in_controller_list &= ~BTM_WHITE_LIST_BIT;
187 }
188 } // if not a known device, shall we add it?
189 else {
190 BTM_ReadDevInfo(bd_addr, &dev_type, &addr_type);
191
192 if (to_add) {
193 started = btsnd_hcic_ble_add_white_list (addr_type, bd_addr);
194 }else{
195 started = btsnd_hcic_ble_remove_from_white_list (addr_type, bd_addr);
196 }
197 }
198
199 return started;
200 */
201
202 /* Controller do not support resolvable address now, only support public address and static random address */
203 BOOLEAN started = FALSE;
204 if(wl_addr_type > BLE_ADDR_RANDOM) {
205 BTM_TRACE_ERROR("wl_addr_type is error\n");
206 return started;
207 }
208
209 if (to_add) {
210 started = btsnd_hcic_ble_add_white_list (wl_addr_type, bd_addr);
211 }else{
212 started = btsnd_hcic_ble_remove_from_white_list (wl_addr_type, bd_addr);
213 }
214
215 return started;
216
217
218 }
219 /*******************************************************************************
220 **
221 ** Function btm_execute_wl_dev_operation
222 **
223 ** Description execute the pending whitelist device operation(loading or removing)
224 *******************************************************************************/
btm_execute_wl_dev_operation(void)225 BOOLEAN btm_execute_wl_dev_operation(void)
226 {
227 tBTM_BLE_WL_OP *p_dev_op = btm_cb.ble_ctr_cb.wl_op_q;
228 UINT8 i = 0;
229 BOOLEAN rt = TRUE;
230
231 for (i = 0; i < BTM_BLE_MAX_BG_CONN_DEV_NUM && rt; i ++, p_dev_op ++) {
232 if (p_dev_op->in_use) {
233 rt = btm_add_dev_to_controller(p_dev_op->to_add, p_dev_op->bd_addr, p_dev_op->addr_type);
234 memset(p_dev_op, 0, sizeof(tBTM_BLE_WL_OP));
235 } else {
236 break;
237 }
238 }
239 return rt;
240 }
241 /*******************************************************************************
242 **
243 ** Function btm_enq_wl_dev_operation
244 **
245 ** Description enqueue the pending whitelist device operation(loading or removing).
246 *******************************************************************************/
btm_enq_wl_dev_operation(BOOLEAN to_add,BD_ADDR bd_addr,tBLE_ADDR_TYPE addr_type)247 void btm_enq_wl_dev_operation(BOOLEAN to_add, BD_ADDR bd_addr, tBLE_ADDR_TYPE addr_type)
248 {
249 tBTM_BLE_WL_OP *p_dev_op = btm_cb.ble_ctr_cb.wl_op_q;
250 UINT8 i = 0;
251
252 for (i = 0; i < BTM_BLE_MAX_BG_CONN_DEV_NUM; i ++, p_dev_op ++) {
253 if (p_dev_op->in_use && p_dev_op->addr_type == addr_type && !memcmp(p_dev_op->bd_addr, bd_addr, BD_ADDR_LEN)) {
254 p_dev_op->to_add = to_add;
255 return;
256 } else if (!p_dev_op->in_use) {
257 break;
258 }
259 }
260 if (i != BTM_BLE_MAX_BG_CONN_DEV_NUM) {
261 p_dev_op->in_use = TRUE;
262 p_dev_op->to_add = to_add;
263 p_dev_op->addr_type = addr_type;
264 memcpy(p_dev_op->bd_addr, bd_addr, BD_ADDR_LEN);
265 } else {
266 BTM_TRACE_ERROR("max pending WL operation reached, discard");
267 }
268 return;
269 }
270
271 /*******************************************************************************
272 **
273 ** Function btm_update_dev_to_white_list
274 **
275 ** Description This function adds or removes a device into/from
276 ** the white list.
277 **
278 *******************************************************************************/
btm_update_dev_to_white_list(BOOLEAN to_add,BD_ADDR bd_addr,tBLE_ADDR_TYPE addr_type,tBTM_UPDATE_WHITELIST_CBACK * update_wl_cb)279 BOOLEAN btm_update_dev_to_white_list(BOOLEAN to_add, BD_ADDR bd_addr, tBLE_ADDR_TYPE addr_type, tBTM_UPDATE_WHITELIST_CBACK *update_wl_cb)
280 {
281 if(addr_type > BLE_ADDR_RANDOM) {
282 BTM_TRACE_ERROR("%s address type is error, unable to add device", __func__);
283 if (update_wl_cb){
284 update_wl_cb(HCI_ERR_ILLEGAL_PARAMETER_FMT,to_add);
285 }
286 return FALSE;
287 }
288
289 BD_ADDR invalid_rand_addr_a, invalid_rand_addr_b;
290 memset(invalid_rand_addr_a, 0xff, sizeof(BD_ADDR));
291 memset(invalid_rand_addr_b, 0x00, sizeof(BD_ADDR));
292
293 // look for public address information
294 tBTM_SEC_DEV_REC *p_dev_rec = btm_find_dev(bd_addr);
295 // p_dev_rec is created at bluetooth initialization, p_dev_rec->ble.static_addr maybe be all 0 before pairing
296 if(p_dev_rec && memcmp(invalid_rand_addr_b, p_dev_rec->ble.static_addr, BD_ADDR_LEN) != 0) {
297 memcpy(bd_addr, p_dev_rec->ble.static_addr, BD_ADDR_LEN);
298 addr_type = p_dev_rec->ble.static_addr_type;
299 }
300
301 // white list must be public address or static random address
302 if(addr_type == BLE_ADDR_RANDOM) {
303 /*
304 A static address is a 48-bit randomly generated address and shall meet the following requirements:
305 • The two most significant bits of the address shall be equal to 1
306 • All bits of the random part of the address shall not be equal to 1
307 • All bits of the random part of the address shall not be equal to 0
308 */
309 invalid_rand_addr_b[0] = invalid_rand_addr_b[0] | BT_STATIC_RAND_ADDR_MASK;
310 if((bd_addr[0] & BT_STATIC_RAND_ADDR_MASK) == BT_STATIC_RAND_ADDR_MASK
311 && memcmp(invalid_rand_addr_a, bd_addr, BD_ADDR_LEN) != 0
312 && memcmp(invalid_rand_addr_b, bd_addr, BD_ADDR_LEN) != 0){
313 // do nothing
314 } else {
315 BTC_TRACE_ERROR(" controller not support resolvable address");
316 if (update_wl_cb){
317 update_wl_cb(HCI_ERR_ILLEGAL_PARAMETER_FMT,to_add);
318 }
319 return FALSE;
320 }
321
322 }
323
324 tBTM_BLE_CB *p_cb = &btm_cb.ble_ctr_cb;
325
326 if (to_add && p_cb->white_list_avail_size == 0) {
327 BTM_TRACE_ERROR("%s Whitelist full, unable to add device", __func__);
328 if (update_wl_cb){
329 update_wl_cb(HCI_ERR_MEMORY_FULL,to_add);
330 }
331 return FALSE;
332 }
333
334 if (to_add) {
335 /* added the bd_addr to the connection hash map queue */
336 if(!background_connection_add((bt_bdaddr_t *)bd_addr)) {
337 /* if the bd_addr already exist in whitelist, just callback return TRUE */
338 if (update_wl_cb){
339 update_wl_cb(HCI_SUCCESS,to_add);
340 }
341 return TRUE;
342 }
343 } else {
344 /* remove the bd_addr to the connection hash map queue */
345 if(!background_connection_remove((bt_bdaddr_t *)bd_addr)){
346 /* if the bd_addr don't exist in whitelist, just callback return TRUE */
347 if (update_wl_cb){
348 update_wl_cb(HCI_SUCCESS,to_add);
349 }
350 return TRUE;
351 }
352 }
353
354 if (update_wl_cb){
355 //save add whitelist complete callback
356 p_cb->update_wl_cb = update_wl_cb;
357 }
358 /* stop the auto connect */
359 btm_suspend_wl_activity(p_cb->wl_state);
360 /* save the bd_addr to the btm_cb env */
361 btm_enq_wl_dev_operation(to_add, bd_addr, addr_type);
362 /* save the ba_addr to the controller white list */
363 btm_wl_update_to_controller();
364 return TRUE;
365 }
366
367 /*******************************************************************************
368 **
369 ** Function btm_ble_clear_white_list
370 **
371 ** Description This function clears the white list.
372 **
373 *******************************************************************************/
btm_ble_clear_white_list(tBTM_UPDATE_WHITELIST_CBACK * update_wl_cb)374 void btm_ble_clear_white_list (tBTM_UPDATE_WHITELIST_CBACK *update_wl_cb)
375 {
376 tBTM_BLE_CB *p_cb = &btm_cb.ble_ctr_cb;
377
378 BTM_TRACE_EVENT ("btm_ble_clear_white_list");
379 btsnd_hcic_ble_clear_white_list();
380 background_connections_clear();
381
382 if (update_wl_cb) {
383 p_cb->update_wl_cb = update_wl_cb;
384 }
385 }
386
387 /*******************************************************************************
388 **
389 ** Function btm_ble_clear_white_list_complete
390 **
391 ** Description Indicates white list cleared.
392 **
393 *******************************************************************************/
btm_ble_clear_white_list_complete(UINT8 * p_data,UINT16 evt_len)394 void btm_ble_clear_white_list_complete(UINT8 *p_data, UINT16 evt_len)
395 {
396 tBTM_BLE_CB *p_cb = &btm_cb.ble_ctr_cb;
397 UINT8 status;
398 UNUSED(evt_len);
399
400 BTM_TRACE_EVENT ("btm_ble_clear_white_list_complete");
401 STREAM_TO_UINT8 (status, p_data);
402
403 if (status == HCI_SUCCESS) {
404 p_cb->white_list_avail_size = controller_get_interface()->get_ble_white_list_size();
405 } else {
406 BTM_TRACE_ERROR ("%s failed, status 0x%x\n", __func__, status);
407 }
408
409 if (p_cb->update_wl_cb) {
410 (*p_cb->update_wl_cb)(status, BTM_WHITELIST_CLEAR);
411 }
412 }
413
414 /*******************************************************************************
415 **
416 ** Function btm_ble_white_list_init
417 **
418 ** Description Initialize white list size
419 **
420 *******************************************************************************/
btm_ble_white_list_init(UINT8 white_list_size)421 void btm_ble_white_list_init(UINT8 white_list_size)
422 {
423 BTM_TRACE_DEBUG("%s white_list_size = %d", __func__, white_list_size);
424 btm_cb.ble_ctr_cb.white_list_avail_size = white_list_size;
425 }
426
427 /*******************************************************************************
428 **
429 ** Function btm_ble_add_2_white_list_complete
430 **
431 ** Description White list element added
432 **
433 *******************************************************************************/
btm_ble_add_2_white_list_complete(UINT8 status)434 void btm_ble_add_2_white_list_complete(UINT8 status)
435 {
436 BTM_TRACE_EVENT("%s status=%d", __func__, status);
437 tBTM_BLE_CB *p_cb = &btm_cb.ble_ctr_cb;
438 if (status == HCI_SUCCESS) {
439 --btm_cb.ble_ctr_cb.white_list_avail_size;
440 }
441 // add whitelist complete callback
442 if (p_cb->update_wl_cb)
443 {
444 (*p_cb->update_wl_cb)(status, BTM_WHITELIST_ADD);
445 }
446
447 }
448
449 /*******************************************************************************
450 **
451 ** Function btm_ble_remove_from_white_list_complete
452 **
453 ** Description White list element removal complete
454 **
455 *******************************************************************************/
btm_ble_remove_from_white_list_complete(UINT8 * p,UINT16 evt_len)456 void btm_ble_remove_from_white_list_complete(UINT8 *p, UINT16 evt_len)
457 {
458 tBTM_BLE_CB *p_cb = &btm_cb.ble_ctr_cb;
459 UNUSED(evt_len);
460 BTM_TRACE_EVENT ("%s status=%d", __func__, *p);
461 if (*p == HCI_SUCCESS) {
462 ++btm_cb.ble_ctr_cb.white_list_avail_size;
463 }
464 if (p_cb->update_wl_cb)
465 {
466 (*p_cb->update_wl_cb)(*p, BTM_WHITELIST_REMOVE);
467 }
468 }
469
470 /*******************************************************************************
471 **
472 ** Function btm_ble_start_auto_conn
473 **
474 ** Description This function is to start/stop auto connection procedure.
475 **
476 ** Parameters start: TRUE to start; FALSE to stop.
477 **
478 ** Returns void
479 **
480 *******************************************************************************/
btm_ble_start_auto_conn(BOOLEAN start)481 BOOLEAN btm_ble_start_auto_conn(BOOLEAN start)
482 {
483 tBTM_BLE_CB *p_cb = &btm_cb.ble_ctr_cb;
484 BD_ADDR dummy_bda = {0};
485 BOOLEAN exec = TRUE;
486 UINT16 scan_int;
487 UINT16 scan_win;
488 UINT8 own_addr_type = p_cb->addr_mgnt_cb.own_addr_type;
489 UINT8 peer_addr_type = BLE_ADDR_PUBLIC;
490
491 if (start) {
492 if (p_cb->conn_state == BLE_CONN_IDLE && background_connections_pending()
493 && btm_ble_topology_check(BTM_BLE_STATE_INIT)) {
494 p_cb->wl_state |= BTM_BLE_WL_INIT;
495
496 btm_execute_wl_dev_operation();
497
498 #if BLE_PRIVACY_SPT == TRUE
499 btm_ble_enable_resolving_list_for_platform(BTM_BLE_RL_INIT);
500 #endif
501 scan_int = (p_cb->scan_int == BTM_BLE_SCAN_PARAM_UNDEF) ?
502 BTM_BLE_SCAN_SLOW_INT_1 : p_cb->scan_int;
503 scan_win = (p_cb->scan_win == BTM_BLE_SCAN_PARAM_UNDEF) ?
504 BTM_BLE_SCAN_SLOW_WIN_1 : p_cb->scan_win;
505
506 #if BLE_PRIVACY_SPT == TRUE
507 if (btm_cb.ble_ctr_cb.rl_state != BTM_BLE_RL_IDLE
508 && controller_get_interface()->supports_ble_privacy()) {
509 own_addr_type |= BLE_ADDR_TYPE_ID_BIT;
510 peer_addr_type |= BLE_ADDR_TYPE_ID_BIT;
511 }
512 #endif
513
514 if (!btsnd_hcic_ble_create_ll_conn (scan_int, /* UINT16 scan_int */
515 scan_win, /* UINT16 scan_win */
516 0x01, /* UINT8 white_list */
517 peer_addr_type, /* UINT8 addr_type_peer */
518 dummy_bda, /* BD_ADDR bda_peer */
519 own_addr_type, /* UINT8 addr_type_own */
520 BTM_BLE_CONN_INT_MIN_DEF, /* UINT16 conn_int_min */
521 BTM_BLE_CONN_INT_MAX_DEF, /* UINT16 conn_int_max */
522 BTM_BLE_CONN_SLAVE_LATENCY_DEF, /* UINT16 conn_latency */
523 BTM_BLE_CONN_TIMEOUT_DEF, /* UINT16 conn_timeout */
524 0, /* UINT16 min_len */
525 0)) { /* UINT16 max_len */
526 /* start auto connection failed */
527 exec = FALSE;
528 p_cb->wl_state &= ~BTM_BLE_WL_INIT;
529 } else {
530 btm_ble_set_conn_st (BLE_BG_CONN);
531 }
532 } else {
533 exec = FALSE;
534 }
535 } else {
536 if (p_cb->conn_state == BLE_BG_CONN) {
537 btsnd_hcic_ble_create_conn_cancel();
538 btm_ble_set_conn_st (BLE_CONN_CANCEL);
539 p_cb->wl_state &= ~BTM_BLE_WL_INIT;
540 } else {
541 BTM_TRACE_DEBUG("conn_st = %d, not in auto conn state, cannot stop", p_cb->conn_state);
542 exec = FALSE;
543 }
544 }
545 return exec;
546 }
547
548 /*******************************************************************************
549 **
550 ** Function btm_ble_start_select_conn
551 **
552 ** Description This function is to start/stop selective connection procedure.
553 **
554 ** Parameters start: TRUE to start; FALSE to stop.
555 ** p_select_cback: callback function to return application
556 ** selection.
557 **
558 ** Returns BOOLEAN: selective connection procedure is started.
559 **
560 *******************************************************************************/
btm_ble_start_select_conn(BOOLEAN start,tBTM_BLE_SEL_CBACK * p_select_cback)561 BOOLEAN btm_ble_start_select_conn(BOOLEAN start, tBTM_BLE_SEL_CBACK *p_select_cback)
562 {
563 tBTM_BLE_CB *p_cb = &btm_cb.ble_ctr_cb;
564 UINT32 scan_int = p_cb->scan_int == BTM_BLE_SCAN_PARAM_UNDEF ? BTM_BLE_SCAN_FAST_INT : p_cb->scan_int;
565 UINT32 scan_win = p_cb->scan_win == BTM_BLE_SCAN_PARAM_UNDEF ? BTM_BLE_SCAN_FAST_WIN : p_cb->scan_win;
566
567 BTM_TRACE_EVENT ("%s", __func__);
568
569 if (start) {
570 if (!BTM_BLE_IS_SCAN_ACTIVE(p_cb->scan_activity)) {
571 if (p_select_cback != NULL) {
572 btm_cb.ble_ctr_cb.p_select_cback = p_select_cback;
573 }
574
575 btm_execute_wl_dev_operation();
576
577 btm_update_scanner_filter_policy(SP_ADV_WL);
578 btm_cb.ble_ctr_cb.inq_var.scan_type = BTM_BLE_SCAN_MODE_PASS;
579
580 /* Process advertising packets only from devices in the white list */
581 if (btm_cb.cmn_ble_vsc_cb.extended_scan_support == 0) {
582 /* use passive scan by default */
583 if (!btsnd_hcic_ble_set_scan_params(BTM_BLE_SCAN_MODE_PASS,
584 scan_int,
585 scan_win,
586 p_cb->addr_mgnt_cb.own_addr_type,
587 SP_ADV_WL)) {
588 return FALSE;
589 }
590 } else {
591 if (!btm_ble_send_extended_scan_params(BTM_BLE_SCAN_MODE_PASS,
592 scan_int,
593 scan_win,
594 p_cb->addr_mgnt_cb.own_addr_type,
595 SP_ADV_WL)) {
596 return FALSE;
597 }
598 }
599
600 if (!btm_ble_topology_check(BTM_BLE_STATE_PASSIVE_SCAN)) {
601 BTM_TRACE_ERROR("peripheral device cannot initiate passive scan for a selective connection");
602 return FALSE;
603 } else if (background_connections_pending()) {
604 #if BLE_PRIVACY_SPT == TRUE
605 btm_ble_enable_resolving_list_for_platform(BTM_BLE_RL_SCAN);
606 #endif
607 if (!btsnd_hcic_ble_set_scan_enable(TRUE, TRUE)) { /* duplicate filtering enabled */
608 return FALSE;
609 }
610 /* mark up inquiry status flag */
611 p_cb->scan_activity |= BTM_LE_SELECT_CONN_ACTIVE;
612 p_cb->wl_state |= BTM_BLE_WL_SCAN;
613 }
614 } else {
615 BTM_TRACE_ERROR("scan active, can not start selective connection procedure");
616 return FALSE;
617 }
618 } else { /* disable selective connection mode */
619 p_cb->scan_activity &= ~BTM_LE_SELECT_CONN_ACTIVE;
620 p_cb->p_select_cback = NULL;
621 p_cb->wl_state &= ~BTM_BLE_WL_SCAN;
622
623 /* stop scanning */
624 if (!BTM_BLE_IS_SCAN_ACTIVE(p_cb->scan_activity)) {
625 btm_ble_stop_scan(); /* duplicate filtering enabled */
626 }
627 }
628 return TRUE;
629 }
630 /*******************************************************************************
631 **
632 ** Function btm_ble_initiate_select_conn
633 **
634 ** Description This function is to start/stop selective connection procedure.
635 **
636 ** Parameters start: TRUE to start; FALSE to stop.
637 ** p_select_cback: callback function to return application
638 ** selection.
639 **
640 ** Returns BOOLEAN: selective connection procedure is started.
641 **
642 *******************************************************************************/
btm_ble_initiate_select_conn(BD_ADDR bda)643 void btm_ble_initiate_select_conn(BD_ADDR bda)
644 {
645 BTM_TRACE_EVENT ("btm_ble_initiate_select_conn");
646
647 /* use direct connection procedure to initiate connection */
648 if (!L2CA_ConnectFixedChnl(L2CAP_ATT_CID, bda, BLE_ADDR_UNKNOWN_TYPE, FALSE)) {
649 BTM_TRACE_ERROR("btm_ble_initiate_select_conn failed");
650 }
651 }
652 /*******************************************************************************
653 **
654 ** Function btm_ble_suspend_bg_conn
655 **
656 ** Description This function is to suspend an active background connection
657 ** procedure.
658 **
659 ** Parameters none.
660 **
661 ** Returns none.
662 **
663 *******************************************************************************/
btm_ble_suspend_bg_conn(void)664 BOOLEAN btm_ble_suspend_bg_conn(void)
665 {
666 BTM_TRACE_EVENT ("%s\n", __func__);
667
668 if (btm_cb.ble_ctr_cb.bg_conn_type == BTM_BLE_CONN_AUTO) {
669 return btm_ble_start_auto_conn(FALSE);
670 } else if (btm_cb.ble_ctr_cb.bg_conn_type == BTM_BLE_CONN_SELECTIVE) {
671 return btm_ble_start_select_conn(FALSE, NULL);
672 }
673
674 return FALSE;
675 }
676 /*******************************************************************************
677 **
678 ** Function btm_suspend_wl_activity
679 **
680 ** Description This function is to suspend white list related activity
681 **
682 ** Returns none.
683 **
684 *******************************************************************************/
btm_suspend_wl_activity(tBTM_BLE_WL_STATE wl_state)685 static void btm_suspend_wl_activity(tBTM_BLE_WL_STATE wl_state)
686 {
687 if (wl_state & BTM_BLE_WL_INIT) {
688 btm_ble_start_auto_conn(FALSE);
689 }
690 if (wl_state & BTM_BLE_WL_SCAN) {
691 btm_ble_start_select_conn(FALSE, NULL);
692 }
693 if (wl_state & BTM_BLE_WL_ADV) {
694 btm_ble_stop_adv();
695 }
696
697 }
698 /*******************************************************************************
699 **
700 ** Function btm_resume_wl_activity
701 **
702 ** Description This function is to resume white list related activity
703 **
704 ** Returns none.
705 **
706 *******************************************************************************/
btm_resume_wl_activity(tBTM_BLE_WL_STATE wl_state)707 void btm_resume_wl_activity(tBTM_BLE_WL_STATE wl_state)
708 {
709 btm_ble_resume_bg_conn();
710 if (wl_state & BTM_BLE_WL_ADV) {
711 btm_ble_start_adv();
712 }
713
714 }
715
716 /*******************************************************************************
717 **
718 ** Function btm_wl_update_to_controller
719 **
720 ** Description This function is to update white list to controller
721 **
722 ** Returns none.
723 **
724 *******************************************************************************/
btm_wl_update_to_controller(void)725 static void btm_wl_update_to_controller(void)
726 {
727 /* whitelist will be added in the btm_ble_resume_bg_conn(), we do not
728 support background connection now, so we nedd to use btm_execute_wl_dev_operation
729 to add whitelist directly ,if we support background connection in the future,
730 please delete btm_execute_wl_dev_operation(). */
731 btm_execute_wl_dev_operation();
732
733 }
734 /*******************************************************************************
735 **
736 ** Function btm_ble_resume_bg_conn
737 **
738 ** Description This function is to resume a background auto connection
739 ** procedure.
740 **
741 ** Parameters none.
742 **
743 ** Returns none.
744 **
745 *******************************************************************************/
btm_ble_resume_bg_conn(void)746 BOOLEAN btm_ble_resume_bg_conn(void)
747 {
748 tBTM_BLE_CB *p_cb = &btm_cb.ble_ctr_cb;
749 BOOLEAN ret = FALSE;
750
751 if (p_cb->bg_conn_type != BTM_BLE_CONN_NONE) {
752 if (p_cb->bg_conn_type == BTM_BLE_CONN_AUTO) {
753 ret = btm_ble_start_auto_conn(TRUE);
754 }
755
756 if (p_cb->bg_conn_type == BTM_BLE_CONN_SELECTIVE) {
757 ret = btm_ble_start_select_conn(TRUE, btm_cb.ble_ctr_cb.p_select_cback);
758 }
759 }
760
761 return ret;
762 }
763 /*******************************************************************************
764 **
765 ** Function btm_ble_get_conn_st
766 **
767 ** Description This function get BLE connection state
768 **
769 ** Returns connection state
770 **
771 *******************************************************************************/
btm_ble_get_conn_st(void)772 tBTM_BLE_CONN_ST btm_ble_get_conn_st(void)
773 {
774 return btm_cb.ble_ctr_cb.conn_state;
775 }
776 /*******************************************************************************
777 **
778 ** Function btm_ble_set_conn_st
779 **
780 ** Description This function set BLE connection state
781 **
782 ** Returns None.
783 **
784 *******************************************************************************/
btm_ble_set_conn_st(tBTM_BLE_CONN_ST new_st)785 void btm_ble_set_conn_st(tBTM_BLE_CONN_ST new_st)
786 {
787 btm_cb.ble_ctr_cb.conn_state = new_st;
788
789 if (new_st == BLE_BG_CONN || new_st == BLE_DIR_CONN) {
790 btm_ble_set_topology_mask(BTM_BLE_STATE_INIT_BIT);
791 } else {
792 btm_ble_clear_topology_mask(BTM_BLE_STATE_INIT_BIT);
793 }
794 }
795
796 /*******************************************************************************
797 **
798 ** Function btm_ble_enqueue_direct_conn_req
799 **
800 ** Description This function enqueue the direct connection request
801 **
802 ** Returns None.
803 **
804 *******************************************************************************/
btm_ble_enqueue_direct_conn_req(void * p_param)805 void btm_ble_enqueue_direct_conn_req(void *p_param)
806 {
807 tBTM_BLE_CONN_REQ *p = (tBTM_BLE_CONN_REQ *)osi_malloc(sizeof(tBTM_BLE_CONN_REQ));
808
809 p->p_param = p_param;
810
811 fixed_queue_enqueue(btm_cb.ble_ctr_cb.conn_pending_q, p, FIXED_QUEUE_MAX_TIMEOUT);
812 }
813 /*******************************************************************************
814 **
815 ** Function btm_send_pending_direct_conn
816 **
817 ** Description This function send the pending direct connection request in queue
818 **
819 ** Returns TRUE if started, FALSE otherwise
820 **
821 *******************************************************************************/
btm_send_pending_direct_conn(void)822 BOOLEAN btm_send_pending_direct_conn(void)
823 {
824 tBTM_BLE_CONN_REQ *p_req;
825 BOOLEAN rt = FALSE;
826
827 p_req = (tBTM_BLE_CONN_REQ*)fixed_queue_dequeue(btm_cb.ble_ctr_cb.conn_pending_q, 0);
828 if (p_req != NULL) {
829 rt = l2cble_init_direct_conn((tL2C_LCB *)(p_req->p_param));
830
831 osi_free((void *)p_req);
832 }
833
834 return rt;
835 }
836
837 #endif
838
