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
27 #include "bt_types.h"
28 #include "btu.h"
29 #include "btm_int.h"
30 #include "l2c_int.h"
31 #include "hcimsgs.h"
32 #include "bt_utils.h"
33 #include "vendor_ble.h"
34
35 #ifndef BTM_BLE_SCAN_PARAM_TOUT
36 #define BTM_BLE_SCAN_PARAM_TOUT 50 /* 50 seconds */
37 #endif
38
39 #if (BLE_INCLUDED == TRUE)
40
41 static void btm_suspend_wl_activity(tBTM_BLE_WL_STATE wl_state);
42 static void btm_resume_wl_activity(tBTM_BLE_WL_STATE wl_state);
43
44 /*******************************************************************************
45 **
46 ** Function btm_update_scanner_filter_policy
47 **
48 ** Description This function update the filter policy of scnner or advertiser.
49 *******************************************************************************/
btm_update_scanner_filter_policy(tBTM_BLE_SFP scan_policy)50 void btm_update_scanner_filter_policy(tBTM_BLE_SFP scan_policy)
51 {
52 tBTM_BLE_INQ_CB *p_inq = &btm_cb.ble_ctr_cb.inq_var;
53 BTM_TRACE_EVENT ("btm_update_scanner_filter_policy");
54
55 p_inq->sfp = scan_policy;
56 p_inq->scan_type = (p_inq->scan_type == BTM_BLE_SCAN_MODE_NONE) ? BTM_BLE_SCAN_MODE_ACTI: p_inq->scan_type;
57
58 btsnd_hcic_ble_set_scan_params (p_inq->scan_type,
59 (UINT16)(!p_inq->scan_interval ? BTM_BLE_GAP_DISC_SCAN_INT : p_inq->scan_interval),
60 (UINT16)(!p_inq->scan_window ? BTM_BLE_GAP_DISC_SCAN_WIN : p_inq->scan_window),
61 btm_cb.ble_ctr_cb.addr_mgnt_cb.own_addr_type,
62 scan_policy);
63 }
64 /*******************************************************************************
65 **
66 ** Function btm_add_dev_to_controller
67 **
68 ** Description This function load the device into controller white list
69 *******************************************************************************/
btm_add_dev_to_controller(BOOLEAN to_add,BD_ADDR bd_addr)70 BOOLEAN btm_add_dev_to_controller (BOOLEAN to_add, BD_ADDR bd_addr)
71 {
72 tBTM_SEC_DEV_REC *p_dev_rec = btm_find_dev (bd_addr);
73 tBLE_ADDR_TYPE addr_type = BLE_ADDR_PUBLIC;
74 BOOLEAN started = FALSE;
75 BD_ADDR dummy_bda = {0};
76 tBT_DEVICE_TYPE dev_type;
77
78 if (p_dev_rec != NULL &&
79 p_dev_rec->device_type & BT_DEVICE_TYPE_BLE)
80 {
81
82 if (to_add)
83 {
84 if (p_dev_rec->ble.ble_addr_type == BLE_ADDR_PUBLIC || !BTM_BLE_IS_RESOLVE_BDA(bd_addr))
85 {
86 #if (defined BLE_PRIVACY_SPT && BLE_PRIVACY_SPT == TRUE)
87 /* add device into IRK list */
88 btm_ble_vendor_irk_list_load_dev(p_dev_rec);
89 #endif
90 started = btsnd_hcic_ble_add_white_list (p_dev_rec->ble.ble_addr_type, bd_addr);
91 }
92 if (memcmp(p_dev_rec->ble.static_addr, bd_addr, BD_ADDR_LEN) != 0 &&
93 memcmp(p_dev_rec->ble.static_addr, dummy_bda, BD_ADDR_LEN) != 0)
94 {
95 started = btsnd_hcic_ble_add_white_list (p_dev_rec->ble.static_addr_type,
96 p_dev_rec->ble.static_addr);
97 }
98 }
99 else
100 {
101 if (p_dev_rec->ble.ble_addr_type == BLE_ADDR_PUBLIC || !BTM_BLE_IS_RESOLVE_BDA(bd_addr))
102 {
103 started = btsnd_hcic_ble_remove_from_white_list (p_dev_rec->ble.ble_addr_type, bd_addr);
104 }
105 if (memcmp(p_dev_rec->ble.static_addr, dummy_bda, BD_ADDR_LEN) != 0 &&
106 memcmp(p_dev_rec->ble.static_addr, bd_addr, BD_ADDR_LEN) != 0)
107 {
108 started = btsnd_hcic_ble_remove_from_white_list (p_dev_rec->ble.static_addr_type, p_dev_rec->ble.static_addr);
109 }
110 }
111 } /* if not a known device, shall we add it? */
112 else
113 {
114 BTM_ReadDevInfo(bd_addr, &dev_type, &addr_type);
115
116 if (to_add)
117 started = btsnd_hcic_ble_add_white_list (addr_type, bd_addr);
118 else
119 started = btsnd_hcic_ble_remove_from_white_list (addr_type, bd_addr);
120 }
121
122 return started;
123
124 }
125 /*******************************************************************************
126 **
127 ** Function btm_execute_wl_dev_operation
128 **
129 ** Description execute the pending whitelist device operation(loading or removing)
130 *******************************************************************************/
btm_execute_wl_dev_operation(void)131 BOOLEAN btm_execute_wl_dev_operation(void)
132 {
133 tBTM_BLE_WL_OP *p_dev_op = btm_cb.ble_ctr_cb.wl_op_q;
134 UINT8 i = 0;
135 BOOLEAN rt = TRUE;
136
137 for (i = 0; i < BTM_BLE_MAX_BG_CONN_DEV_NUM && rt; i ++, p_dev_op ++)
138 {
139 if (p_dev_op->in_use)
140 {
141 rt = btm_add_dev_to_controller(p_dev_op->to_add, p_dev_op->bd_addr);
142 memset(p_dev_op, 0, sizeof(tBTM_BLE_WL_OP));
143 }
144 else
145 break;
146 }
147 return rt;
148 }
149 /*******************************************************************************
150 **
151 ** Function btm_enq_wl_dev_operation
152 **
153 ** Description enqueue the pending whitelist device operation(loading or removing).
154 *******************************************************************************/
btm_enq_wl_dev_operation(BOOLEAN to_add,BD_ADDR bd_addr)155 void btm_enq_wl_dev_operation(BOOLEAN to_add, BD_ADDR bd_addr)
156 {
157 tBTM_BLE_WL_OP *p_dev_op = btm_cb.ble_ctr_cb.wl_op_q;
158 UINT8 i = 0;
159
160 for (i = 0; i < BTM_BLE_MAX_BG_CONN_DEV_NUM; i ++, p_dev_op ++)
161 {
162 if (p_dev_op->in_use && !memcmp(p_dev_op->bd_addr, bd_addr, BD_ADDR_LEN))
163 {
164 p_dev_op->to_add = to_add;
165 return;
166 }
167 else if (!p_dev_op->in_use)
168 break;
169 }
170 if (i != BTM_BLE_MAX_BG_CONN_DEV_NUM)
171 {
172 p_dev_op->in_use = TRUE;
173 p_dev_op->to_add = to_add;
174 memcpy(p_dev_op->bd_addr, bd_addr, BD_ADDR_LEN);
175 }
176 else
177 {
178 BTM_TRACE_ERROR("max pending WL operation reached, discard");
179 }
180 return;
181 }
182 /*******************************************************************************
183 **
184 ** Function btm_update_dev_to_white_list
185 **
186 ** Description This function adds a device into white list.
187 *******************************************************************************/
btm_update_dev_to_white_list(BOOLEAN to_add,BD_ADDR bd_addr)188 BOOLEAN btm_update_dev_to_white_list(BOOLEAN to_add, BD_ADDR bd_addr)
189 {
190 /* look up the sec device record, and find the address */
191 tBTM_BLE_CB *p_cb = &btm_cb.ble_ctr_cb;
192 UINT8 wl_state = p_cb->wl_state;
193
194 if ((to_add && p_cb->num_empty_filter == 0) ||
195 (!to_add && p_cb->num_empty_filter == p_cb->max_filter_entries))
196 {
197 BTM_TRACE_ERROR("WL full or empty, unable to update to WL. num_entry available: %d",
198 p_cb->num_empty_filter);
199 return FALSE;
200 }
201
202 btm_suspend_wl_activity(wl_state);
203
204 /* enq pending WL device operation */
205 btm_enq_wl_dev_operation(to_add, bd_addr);
206
207 btm_resume_wl_activity(wl_state);
208
209 return TRUE;
210 }
211 /*******************************************************************************
212 **
213 ** Function btm_ble_clear_white_list
214 **
215 ** Description This function clears the white list.
216 *******************************************************************************/
btm_ble_clear_white_list(void)217 void btm_ble_clear_white_list (void)
218 {
219 BTM_TRACE_EVENT ("btm_ble_clear_white_list");
220 btsnd_hcic_ble_clear_white_list();
221 memset(&btm_cb.ble_ctr_cb.bg_dev_list, 0, (sizeof(tBTM_LE_BG_CONN_DEV)*BTM_BLE_MAX_BG_CONN_DEV_NUM));
222 }
223
224 /*******************************************************************************
225 **
226 ** Function btm_ble_clear_white_list_complete
227 **
228 ** Description This function clears the white list complete.
229 *******************************************************************************/
btm_ble_clear_white_list_complete(UINT8 * p_data,UINT16 evt_len)230 void btm_ble_clear_white_list_complete(UINT8 *p_data, UINT16 evt_len)
231 {
232 tBTM_BLE_CB *p_cb = &btm_cb.ble_ctr_cb;
233 UINT8 status;
234 UNUSED(evt_len);
235
236 BTM_TRACE_EVENT ("btm_ble_clear_white_list_complete");
237 STREAM_TO_UINT8 (status, p_data);
238
239 if (status == HCI_SUCCESS)
240 p_cb->num_empty_filter = p_cb->max_filter_entries;
241
242 }
243 /*******************************************************************************
244 **
245 ** Function btm_ble_add_2_white_list_complete
246 **
247 ** Description This function read the current white list size.
248 *******************************************************************************/
btm_ble_add_2_white_list_complete(UINT8 status)249 void btm_ble_add_2_white_list_complete(UINT8 status)
250 {
251 tBTM_BLE_CB *p_cb = &btm_cb.ble_ctr_cb;
252 BTM_TRACE_EVENT ("btm_ble_add_2_white_list_complete");
253
254 if (status == HCI_SUCCESS)
255 {
256 p_cb->num_empty_filter --;
257 }
258 }
259 /*******************************************************************************
260 **
261 ** Function btm_ble_remove_from_white_list_complete
262 **
263 ** Description This function remove the white list element complete.
264 *******************************************************************************/
btm_ble_remove_from_white_list_complete(UINT8 * p,UINT16 evt_len)265 void btm_ble_remove_from_white_list_complete(UINT8 *p, UINT16 evt_len)
266 {
267 tBTM_BLE_CB *p_cb = &btm_cb.ble_ctr_cb;
268 UNUSED(evt_len);
269
270 BTM_TRACE_EVENT ("btm_ble_remove_from_white_list_complete");
271 if (*p == HCI_SUCCESS)
272 {
273 p_cb->num_empty_filter ++;
274 }
275 }
276 /*******************************************************************************
277 **
278 ** Function btm_ble_count_unconn_dev_in_whitelist
279 **
280 ** Description This function find the number of un-connected background device
281 *******************************************************************************/
btm_ble_count_unconn_dev_in_whitelist(void)282 UINT8 btm_ble_count_unconn_dev_in_whitelist(void)
283 {
284 tBTM_BLE_CB *p_cb = &btm_cb.ble_ctr_cb;
285 UINT8 i, count = 0;
286
287 for (i = 0; i < BTM_BLE_MAX_BG_CONN_DEV_NUM; i ++)
288 {
289 if (p_cb->bg_dev_list[i].in_use &&
290 !BTM_IsAclConnectionUp(p_cb->bg_dev_list[i].bd_addr, BT_TRANSPORT_LE))
291 {
292 count ++;
293 }
294 }
295 return count;
296
297 }
298 /*******************************************************************************
299 **
300 ** Function btm_update_bg_conn_list
301 **
302 ** Description This function update the local background connection device list.
303 *******************************************************************************/
btm_update_bg_conn_list(BOOLEAN to_add,BD_ADDR bd_addr)304 BOOLEAN btm_update_bg_conn_list(BOOLEAN to_add, BD_ADDR bd_addr)
305 {
306 tBTM_BLE_CB *p_cb = &btm_cb.ble_ctr_cb;
307 tBTM_LE_BG_CONN_DEV *p_bg_dev = &p_cb->bg_dev_list[0], *p_next, *p_cur;
308 UINT8 i, j;
309 BOOLEAN ret = FALSE;
310
311 BTM_TRACE_EVENT ("btm_update_bg_conn_list");
312
313 if ((to_add && (p_cb->bg_dev_num == BTM_BLE_MAX_BG_CONN_DEV_NUM || p_cb->num_empty_filter == 0)))
314 {
315 BTM_TRACE_DEBUG("num_empty_filter = %d", p_cb->num_empty_filter);
316 return ret;
317 }
318
319 for (i = 0; i < BTM_BLE_MAX_BG_CONN_DEV_NUM; i ++, p_bg_dev ++)
320 {
321 if (p_bg_dev->in_use && memcmp(p_bg_dev->bd_addr, bd_addr, BD_ADDR_LEN) == 0)
322 {
323 if (!to_add)
324 {
325 memset(p_bg_dev, 0, sizeof(tBTM_LE_BG_CONN_DEV));
326 p_cb->bg_dev_num --;
327 p_cur = p_bg_dev;
328 p_next = p_bg_dev + 1;
329 for (j = i + 1; j < BTM_BLE_MAX_BG_CONN_DEV_NUM && p_next->in_use;
330 j ++, p_cur ++, p_next ++)
331 {
332 memcpy(p_cur, p_next, sizeof(tBTM_LE_BG_CONN_DEV));
333 memset(p_next, 0, sizeof(tBTM_LE_BG_CONN_DEV));
334 }
335 }
336 ret = TRUE;
337 break;
338 }
339 else if (!p_bg_dev->in_use && to_add)
340 {
341 BTM_TRACE_DEBUG("add new WL entry in bg_dev_list");
342
343 memcpy(p_bg_dev->bd_addr, bd_addr, BD_ADDR_LEN);
344 p_bg_dev->in_use = TRUE;
345 p_cb->bg_dev_num ++;
346
347 ret = TRUE;
348 break;
349 }
350 }
351
352
353 return ret;
354 }
355
356 /*******************************************************************************
357 **
358 ** Function btm_ble_start_auto_conn
359 **
360 ** Description This function is to start/stop auto connection procedure.
361 **
362 ** Parameters start: TRUE to start; FALSE to stop.
363 **
364 ** Returns void
365 **
366 *******************************************************************************/
btm_ble_start_auto_conn(BOOLEAN start)367 BOOLEAN btm_ble_start_auto_conn(BOOLEAN start)
368 {
369 tBTM_BLE_CB *p_cb = &btm_cb.ble_ctr_cb;
370 BD_ADDR dummy_bda = {0};
371 BOOLEAN exec = TRUE;
372 UINT16 scan_int, scan_win;
373
374 if (start)
375 {
376 if ( p_cb->conn_state == BLE_CONN_IDLE )
377 {
378 exec = btm_execute_wl_dev_operation();
379 }
380 if ((p_cb->conn_state == BLE_CONN_IDLE && btm_ble_count_unconn_dev_in_whitelist() > 0)
381 && btm_ble_topology_check(BTM_BLE_STATE_INIT))
382 {
383 scan_int = (p_cb->scan_int == BTM_BLE_CONN_PARAM_UNDEF) ? BTM_BLE_SCAN_SLOW_INT_1 : p_cb->scan_int;
384 scan_win = (p_cb->scan_win == BTM_BLE_CONN_PARAM_UNDEF) ? BTM_BLE_SCAN_SLOW_WIN_1 : p_cb->scan_win;
385
386 if (!btsnd_hcic_ble_create_ll_conn (scan_int, /* UINT16 scan_int */
387 scan_win, /* UINT16 scan_win */
388 0x01, /* UINT8 white_list */
389 BLE_ADDR_PUBLIC, /* UINT8 addr_type_peer */
390 dummy_bda, /* BD_ADDR bda_peer */
391 p_cb->addr_mgnt_cb.own_addr_type,
392 /* UINT8 addr_type_own,
393 not allow random address for central */
394 BTM_BLE_CONN_INT_MIN_DEF, /* UINT16 conn_int_min */
395 BTM_BLE_CONN_INT_MAX_DEF, /* UINT16 conn_int_max */
396 BTM_BLE_CONN_SLAVE_LATENCY_DEF, /* UINT16 conn_latency */
397 BTM_BLE_CONN_TIMEOUT_DEF, /* UINT16 conn_timeout */
398 0, /* UINT16 min_len */
399 0)) /* UINT16 max_len */
400 {
401 /* start auto connection failed */
402 exec = FALSE;
403 }
404 else
405 {
406 btm_ble_set_conn_st (BLE_BG_CONN);
407 p_cb->wl_state |= BTM_BLE_WL_INIT;
408 }
409 }
410 else
411 {
412 exec = FALSE;
413 }
414 }
415 else
416 {
417 if (p_cb->conn_state == BLE_BG_CONN)
418 {
419 btsnd_hcic_ble_create_conn_cancel();
420 btm_ble_set_conn_st (BLE_CONN_CANCEL);
421 p_cb->wl_state |= BTM_BLE_WL_INIT;
422
423 #if (defined BLE_PRIVACY_SPT && BLE_PRIVACY_SPT == TRUE)
424 if (btm_cb.cmn_ble_vsc_cb.rpa_offloading == TRUE)
425 btm_ble_vendor_disable_irk_list();
426 #endif
427 }
428 else
429 {
430 #if 0
431 BTM_TRACE_ERROR("conn_st = %d, not in auto conn state, can not stop.", p_cb->conn_state);
432 exec = FALSE;
433 #endif
434 }
435 }
436 return exec;
437 }
438
439 /*******************************************************************************
440 **
441 ** Function btm_ble_start_select_conn
442 **
443 ** Description This function is to start/stop selective connection procedure.
444 **
445 ** Parameters start: TRUE to start; FALSE to stop.
446 ** p_select_cback: callback function to return application
447 ** selection.
448 **
449 ** Returns BOOLEAN: selective connectino procedure is started.
450 **
451 *******************************************************************************/
btm_ble_start_select_conn(BOOLEAN start,tBTM_BLE_SEL_CBACK * p_select_cback)452 BOOLEAN btm_ble_start_select_conn(BOOLEAN start,tBTM_BLE_SEL_CBACK *p_select_cback)
453 {
454 tBTM_BLE_CB *p_cb = &btm_cb.ble_ctr_cb;
455 UINT16 scan_int, scan_win;
456
457 BTM_TRACE_EVENT ("btm_ble_start_select_conn");
458
459 scan_int = (p_cb->scan_int == BTM_BLE_CONN_PARAM_UNDEF) ? BTM_BLE_SCAN_FAST_INT : p_cb->scan_int;
460 scan_win = (p_cb->scan_win == BTM_BLE_CONN_PARAM_UNDEF) ? BTM_BLE_SCAN_FAST_WIN : p_cb->scan_win;
461
462 if (start)
463 {
464 if (!BTM_BLE_IS_SCAN_ACTIVE(p_cb->scan_activity))
465 {
466 if (p_select_cback != NULL)
467 btm_cb.ble_ctr_cb.p_select_cback = p_select_cback;
468
469 btm_execute_wl_dev_operation();
470
471 btm_update_scanner_filter_policy(SP_ADV_WL);
472 btm_cb.ble_ctr_cb.inq_var.scan_type = BTM_BLE_SCAN_MODE_PASS;
473
474 if (!btsnd_hcic_ble_set_scan_params(BTM_BLE_SCAN_MODE_PASS, /* use passive scan by default */
475 scan_int, /* scan interval */
476 scan_win, /* scan window */
477 p_cb->addr_mgnt_cb.own_addr_type,
478 SP_ADV_WL) /* process advertising packets only from devices in the White List */
479 )
480 return FALSE;
481
482 if (!btm_ble_topology_check(BTM_BLE_STATE_PASSIVE_SCAN))
483 {
484 BTM_TRACE_ERROR("peripheral device cannot initiate passive scan for a selective connection");
485 return FALSE;
486 }
487 else if (p_cb->bg_dev_num > 0 && btm_ble_count_unconn_dev_in_whitelist() > 0 )
488 {
489
490 if (!btsnd_hcic_ble_set_scan_enable(TRUE, TRUE)) /* duplicate filtering enabled */
491 return FALSE;
492
493 /* mark up inquiry status flag */
494 p_cb->scan_activity |= BTM_LE_SELECT_CONN_ACTIVE;
495 p_cb->wl_state |= BTM_BLE_WL_SCAN;
496 }
497 }
498 else
499 {
500 BTM_TRACE_ERROR("scan active, can not start selective connection procedure");
501 return FALSE;
502 }
503 }
504 else /* disable selective connection mode */
505 {
506 p_cb->scan_activity &= ~BTM_LE_SELECT_CONN_ACTIVE;
507 p_cb->p_select_cback = NULL;
508
509 #if (defined BLE_PRIVACY_SPT && BLE_PRIVACY_SPT == TRUE)
510 if (btm_cb.cmn_ble_vsc_cb.rpa_offloading == TRUE)
511 btm_ble_vendor_disable_irk_list();
512 #endif
513 p_cb->wl_state |= BTM_BLE_WL_SCAN;
514
515 /* stop scanning */
516 if (!BTM_BLE_IS_SCAN_ACTIVE(p_cb->scan_activity))
517 btm_ble_stop_scan(); /* duplicate filtering enabled */
518 btm_update_scanner_filter_policy(SP_ADV_ALL);
519 }
520 return TRUE;
521 }
522 /*******************************************************************************
523 **
524 ** Function btm_ble_initiate_select_conn
525 **
526 ** Description This function is to start/stop selective connection procedure.
527 **
528 ** Parameters start: TRUE to start; FALSE to stop.
529 ** p_select_cback: callback function to return application
530 ** selection.
531 **
532 ** Returns BOOLEAN: selective connectino procedure is started.
533 **
534 *******************************************************************************/
btm_ble_initiate_select_conn(BD_ADDR bda)535 void btm_ble_initiate_select_conn(BD_ADDR bda)
536 {
537 BTM_TRACE_EVENT ("btm_ble_initiate_select_conn");
538
539 /* use direct connection procedure to initiate connection */
540 if (!L2CA_ConnectFixedChnl(L2CAP_ATT_CID, bda))
541 {
542 BTM_TRACE_ERROR("btm_ble_initiate_select_conn failed");
543 }
544 }
545 /*******************************************************************************
546 **
547 ** Function btm_ble_suspend_bg_conn
548 **
549 ** Description This function is to suspend an active background connection
550 ** procedure.
551 **
552 ** Parameters none.
553 **
554 ** Returns none.
555 **
556 *******************************************************************************/
btm_ble_suspend_bg_conn(void)557 void btm_ble_suspend_bg_conn(void)
558 {
559 tBTM_BLE_CB *p_cb = &btm_cb.ble_ctr_cb;
560 BTM_TRACE_EVENT ("btm_ble_suspend_bg_conn");
561
562 if (p_cb->bg_conn_type == BTM_BLE_CONN_AUTO)
563 {
564 btm_ble_start_auto_conn(FALSE);
565 }
566 else if (p_cb->bg_conn_type == BTM_BLE_CONN_SELECTIVE)
567 {
568 btm_ble_start_select_conn(FALSE, NULL);
569 }
570 }
571 /*******************************************************************************
572 **
573 ** Function btm_suspend_wl_activity
574 **
575 ** Description This function is to suspend white list related activity
576 **
577 ** Returns none.
578 **
579 *******************************************************************************/
btm_suspend_wl_activity(tBTM_BLE_WL_STATE wl_state)580 static void btm_suspend_wl_activity(tBTM_BLE_WL_STATE wl_state)
581 {
582 if (wl_state & BTM_BLE_WL_INIT)
583 {
584 btm_ble_start_auto_conn(FALSE);
585 }
586 if (wl_state & BTM_BLE_WL_SCAN)
587 {
588 btm_ble_start_select_conn(FALSE, NULL);
589 }
590 if (wl_state & BTM_BLE_WL_ADV)
591 {
592 btm_ble_stop_adv();
593 }
594
595 }
596 /*******************************************************************************
597 **
598 ** Function btm_resume_wl_activity
599 **
600 ** Description This function is to resume white list related activity
601 **
602 ** Returns none.
603 **
604 *******************************************************************************/
btm_resume_wl_activity(tBTM_BLE_WL_STATE wl_state)605 static void btm_resume_wl_activity(tBTM_BLE_WL_STATE wl_state)
606 {
607 btm_ble_resume_bg_conn();
608
609 if (wl_state & BTM_BLE_WL_ADV)
610 {
611 btm_ble_start_adv();
612 }
613
614 }
615 /*******************************************************************************
616 **
617 ** Function btm_ble_resume_bg_conn
618 **
619 ** Description This function is to resume a background auto connection
620 ** procedure.
621 **
622 ** Parameters none.
623 **
624 ** Returns none.
625 **
626 *******************************************************************************/
btm_ble_resume_bg_conn(void)627 BOOLEAN btm_ble_resume_bg_conn(void)
628 {
629 tBTM_BLE_CB *p_cb = &btm_cb.ble_ctr_cb;
630 BOOLEAN ret = FALSE;
631
632 if (p_cb->bg_conn_type != BTM_BLE_CONN_NONE)
633 {
634 if (p_cb->bg_conn_type == BTM_BLE_CONN_AUTO)
635 ret = btm_ble_start_auto_conn(TRUE);
636
637 if (p_cb->bg_conn_type == BTM_BLE_CONN_SELECTIVE)
638 ret = btm_ble_start_select_conn(TRUE, btm_cb.ble_ctr_cb.p_select_cback);
639 }
640
641 return ret;
642 }
643 /*******************************************************************************
644 **
645 ** Function btm_ble_get_conn_st
646 **
647 ** Description This function get BLE connection state
648 **
649 ** Returns connection state
650 **
651 *******************************************************************************/
btm_ble_get_conn_st(void)652 tBTM_BLE_CONN_ST btm_ble_get_conn_st(void)
653 {
654 return btm_cb.ble_ctr_cb.conn_state;
655 }
656 /*******************************************************************************
657 **
658 ** Function btm_ble_set_conn_st
659 **
660 ** Description This function set BLE connection state
661 **
662 ** Returns None.
663 **
664 *******************************************************************************/
btm_ble_set_conn_st(tBTM_BLE_CONN_ST new_st)665 void btm_ble_set_conn_st(tBTM_BLE_CONN_ST new_st)
666 {
667 btm_cb.ble_ctr_cb.conn_state = new_st;
668 if (new_st == BLE_BG_CONN || new_st == BLE_DIR_CONN) {
669 btm_cb.ble_ctr_cb.wl_state |= BTM_BLE_WL_INIT;
670 btm_ble_set_topology_mask(BTM_BLE_STATE_INIT_BIT);
671 } else {
672 btm_cb.ble_ctr_cb.wl_state &= ~BTM_BLE_WL_INIT;
673 btm_ble_clear_topology_mask(BTM_BLE_STATE_INIT_BIT);
674 }
675 }
676
677 /*******************************************************************************
678 **
679 ** Function btm_ble_enqueue_direct_conn_req
680 **
681 ** Description This function enqueue the direct connection request
682 **
683 ** Returns None.
684 **
685 *******************************************************************************/
btm_ble_enqueue_direct_conn_req(void * p_param)686 void btm_ble_enqueue_direct_conn_req(void *p_param)
687 {
688 tBTM_BLE_CONN_REQ *p = (tBTM_BLE_CONN_REQ *)GKI_getbuf(sizeof(tBTM_BLE_CONN_REQ));
689
690 p->p_param = p_param;
691
692 GKI_enqueue (&btm_cb.ble_ctr_cb.conn_pending_q, p);
693 }
694 /*******************************************************************************
695 **
696 ** Function btm_send_pending_direct_conn
697 **
698 ** Description This function send the pending direct connection request in queue
699 **
700 ** Returns TRUE if started, FALSE otherwise
701 **
702 *******************************************************************************/
btm_send_pending_direct_conn(void)703 BOOLEAN btm_send_pending_direct_conn(void )
704 {
705 tBTM_BLE_CONN_REQ *p_req;
706 BOOLEAN rt = FALSE;
707
708 if ( btm_cb.ble_ctr_cb.conn_pending_q.count )
709 {
710 p_req = (tBTM_BLE_CONN_REQ*)GKI_dequeue (&btm_cb.ble_ctr_cb.conn_pending_q);
711
712 rt = l2cble_init_direct_conn((tL2C_LCB *)(p_req->p_param));
713
714 GKI_freebuf((void *)p_req);
715 }
716
717 return rt;
718 }
719
720 #endif
721
722
723