1 /****************************************************************************** 2 * 3 * Copyright (C) 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 #include <string.h> 19 #include <stdio.h> 20 #include <stddef.h> 21 #include "bt_target.h" 22 23 #include "btm_ble_api.h" 24 #include "bt_types.h" 25 #include "bt_utils.h" 26 #include "btu.h" 27 #include "btm_int.h" 28 #include "device/include/controller.h" 29 #include "hcimsgs.h" 30 31 #if (BLE_INCLUDED == TRUE) 32 33 tBTM_BLE_BATCH_SCAN_CB ble_batchscan_cb; 34 tBTM_BLE_ADV_TRACK_CB ble_advtrack_cb; 35 36 37 /* length of each batch scan command */ 38 #define BTM_BLE_BATCH_SCAN_STORAGE_CFG_LEN 4 39 #define BTM_BLE_BATCH_SCAN_PARAM_CONFIG_LEN 12 40 #define BTM_BLE_BATCH_SCAN_ENB_DISB_LEN 2 41 #define BTM_BLE_BATCH_SCAN_READ_RESULTS_LEN 2 42 43 #define BTM_BLE_BATCH_SCAN_CB_EVT_MASK 0xF0 44 #define BTM_BLE_BATCH_SCAN_SUBCODE_MASK 0x0F 45 46 /******************************************************************************* 47 ** Local functions 48 *******************************************************************************/ 49 void btm_ble_batchscan_vsc_cmpl_cback (tBTM_VSC_CMPL *p_params); 50 void btm_ble_batchscan_cleanup(void); 51 52 /******************************************************************************* 53 ** 54 ** Function btm_ble_batchscan_filter_track_adv_vse_cback 55 ** 56 ** Description VSE callback for batch scan, filter, and tracking events. 57 ** 58 ** Returns None 59 ** 60 *******************************************************************************/ 61 void btm_ble_batchscan_filter_track_adv_vse_cback(UINT8 len, UINT8 *p) 62 { 63 tBTM_BLE_TRACK_ADV_DATA adv_data; 64 65 UINT8 sub_event = 0; 66 tBTM_BLE_VSC_CB cmn_ble_vsc_cb; 67 STREAM_TO_UINT8(sub_event, p); 68 69 BTM_TRACE_EVENT("btm_ble_batchscan_filter_track_adv_vse_cback called with event:%x", sub_event); 70 if (HCI_VSE_SUBCODE_BLE_THRESHOLD_SUB_EVT == sub_event && 71 NULL != ble_batchscan_cb.p_thres_cback) 72 { 73 ble_batchscan_cb.p_thres_cback(ble_batchscan_cb.ref_value); 74 return; 75 } 76 77 if (HCI_VSE_SUBCODE_BLE_TRACKING_SUB_EVT == sub_event && NULL != ble_advtrack_cb.p_track_cback) 78 { 79 if (len < 10) 80 return; 81 82 memset(&adv_data, 0 , sizeof(tBTM_BLE_TRACK_ADV_DATA)); 83 BTM_BleGetVendorCapabilities(&cmn_ble_vsc_cb); 84 adv_data.client_if = (UINT8)ble_advtrack_cb.ref_value; 85 if (cmn_ble_vsc_cb.version_supported > BTM_VSC_CHIP_CAPABILITY_L_VERSION) 86 { 87 STREAM_TO_UINT8(adv_data.filt_index, p); 88 STREAM_TO_UINT8(adv_data.advertiser_state, p); 89 STREAM_TO_UINT8(adv_data.advertiser_info_present, p); 90 STREAM_TO_BDADDR(adv_data.bd_addr.address, p); 91 STREAM_TO_UINT8(adv_data.addr_type, p); 92 93 /* Extract the adv info details */ 94 if (ADV_INFO_PRESENT == adv_data.advertiser_info_present) 95 { 96 STREAM_TO_UINT8(adv_data.tx_power, p); 97 STREAM_TO_UINT8(adv_data.rssi_value, p); 98 STREAM_TO_UINT16(adv_data.time_stamp, p); 99 100 STREAM_TO_UINT8(adv_data.adv_pkt_len, p); 101 if (adv_data.adv_pkt_len > 0) 102 { 103 adv_data.p_adv_pkt_data = osi_malloc(adv_data.adv_pkt_len); 104 memcpy(adv_data.p_adv_pkt_data, p, adv_data.adv_pkt_len); 105 } 106 107 STREAM_TO_UINT8(adv_data.scan_rsp_len, p); 108 if (adv_data.scan_rsp_len > 0) 109 { 110 adv_data.p_scan_rsp_data = osi_malloc(adv_data.scan_rsp_len); 111 memcpy(adv_data.p_scan_rsp_data, p, adv_data.scan_rsp_len); 112 } 113 } 114 } 115 else 116 { 117 /* Based on L-release version */ 118 STREAM_TO_UINT8(adv_data.filt_index, p); 119 STREAM_TO_UINT8(adv_data.addr_type, p); 120 STREAM_TO_BDADDR(adv_data.bd_addr.address, p); 121 STREAM_TO_UINT8(adv_data.advertiser_state, p); 122 } 123 124 BTM_TRACE_EVENT("track_adv_vse_cback called: %d, %d, %d", adv_data.filt_index, 125 adv_data.addr_type, adv_data.advertiser_state); 126 ble_advtrack_cb.p_track_cback(&adv_data); 127 return; 128 } 129 } 130 131 /******************************************************************************* 132 ** 133 ** Function btm_ble_batchscan_enq_op_q 134 ** 135 ** Description enqueue a batchscan operation in q to check command complete 136 ** status 137 ** 138 ** Returns void 139 ** 140 *******************************************************************************/ 141 void btm_ble_batchscan_enq_op_q(UINT8 opcode, tBTM_BLE_BATCH_SCAN_STATE cur_state, 142 UINT8 cb_evt, tBTM_BLE_REF_VALUE ref_value) 143 { 144 ble_batchscan_cb.op_q.sub_code[ble_batchscan_cb.op_q.next_idx] = (opcode |(cb_evt << 4)); 145 ble_batchscan_cb.op_q.cur_state[ble_batchscan_cb.op_q.next_idx] = cur_state; 146 ble_batchscan_cb.op_q.ref_value[ble_batchscan_cb.op_q.next_idx] = ref_value; 147 BTM_TRACE_DEBUG("btm_ble_batchscan_enq_op_q: subcode:%d, Cur_state:%d, ref_value:%d", 148 ble_batchscan_cb.op_q.sub_code[ble_batchscan_cb.op_q.next_idx], 149 ble_batchscan_cb.op_q.cur_state[ble_batchscan_cb.op_q.next_idx], 150 ble_batchscan_cb.op_q.ref_value[ble_batchscan_cb.op_q.next_idx]); 151 ble_batchscan_cb.op_q.next_idx = (ble_batchscan_cb.op_q.next_idx + 1) 152 % BTM_BLE_BATCH_SCAN_MAX; 153 } 154 155 /******************************************************************************* 156 ** 157 ** Function btm_ble_batchscan_enq_rep_q 158 ** 159 ** Description enqueue a batchscan report operation in q to check command complete 160 ** status 161 ** 162 ** Returns void 163 ** 164 *******************************************************************************/ 165 tBTM_STATUS btm_ble_batchscan_enq_rep_q(UINT8 report_format, tBTM_BLE_REF_VALUE ref_value) 166 { 167 int i = 0; 168 for (i = 0; i < BTM_BLE_BATCH_REP_MAIN_Q_SIZE; i++) 169 { 170 if (report_format == ble_batchscan_cb.main_rep_q.rep_mode[i]) 171 return BTM_ILLEGAL_VALUE; 172 } 173 174 ble_batchscan_cb.main_rep_q.rep_mode[ble_batchscan_cb.main_rep_q.next_idx] = report_format; 175 ble_batchscan_cb.main_rep_q.ref_value[ble_batchscan_cb.main_rep_q.next_idx] = ref_value; 176 ble_batchscan_cb.main_rep_q.num_records[ble_batchscan_cb.main_rep_q.next_idx] = 0; 177 ble_batchscan_cb.main_rep_q.data_len[ble_batchscan_cb.main_rep_q.next_idx] = 0; 178 ble_batchscan_cb.main_rep_q.p_data[ble_batchscan_cb.main_rep_q.next_idx] = NULL; 179 BTM_TRACE_DEBUG("btm_ble_batchscan_enq_rep_q: index:%d, rep %d, ref %d", 180 ble_batchscan_cb.main_rep_q.next_idx, report_format, ref_value); 181 182 ble_batchscan_cb.main_rep_q.next_idx = (ble_batchscan_cb.main_rep_q.next_idx + 1) 183 % BTM_BLE_BATCH_REP_MAIN_Q_SIZE; 184 return BTM_SUCCESS; 185 } 186 187 /******************************************************************************* 188 ** 189 ** Function btm_ble_batchscan_enq_rep_data 190 ** 191 ** Description setup the data in the main report queue 192 ** 193 ** Returns void 194 ** 195 *******************************************************************************/ 196 void btm_ble_batchscan_enq_rep_data(UINT8 report_format, UINT8 num_records, UINT8 *p_data, 197 UINT8 data_len) 198 { 199 int index = 0; 200 201 for (index = 0; index < BTM_BLE_BATCH_REP_MAIN_Q_SIZE; index++) 202 { 203 if (report_format == ble_batchscan_cb.main_rep_q.rep_mode[index]) 204 break; 205 } 206 207 BTM_TRACE_DEBUG("btm_ble_batchscan_enq_rep_data: index:%d, rep %d, num %d len : %d", 208 index, report_format, num_records, data_len); 209 210 if (index < BTM_BLE_BATCH_REP_MAIN_Q_SIZE && data_len > 0 && num_records > 0) 211 { 212 int len = ble_batchscan_cb.main_rep_q.data_len[index]; 213 UINT8 *p_orig_data = ble_batchscan_cb.main_rep_q.p_data[index]; 214 UINT8 *p_app_data; 215 216 if (NULL != p_orig_data) 217 { 218 p_app_data = osi_malloc(len + data_len); 219 memcpy(p_app_data, p_orig_data, len); 220 memcpy(p_app_data+len, p_data, data_len); 221 osi_free(p_orig_data); 222 ble_batchscan_cb.main_rep_q.p_data[index] = p_app_data; 223 ble_batchscan_cb.main_rep_q.num_records[index] += num_records; 224 ble_batchscan_cb.main_rep_q.data_len[index] += data_len; 225 } 226 else 227 { 228 p_app_data = osi_malloc(data_len); 229 memcpy(p_app_data, p_data, data_len); 230 ble_batchscan_cb.main_rep_q.p_data[index] = p_app_data; 231 ble_batchscan_cb.main_rep_q.num_records[index] = num_records; 232 ble_batchscan_cb.main_rep_q.data_len[index] = data_len; 233 } 234 } 235 } 236 237 /******************************************************************************* 238 ** 239 ** Function btm_ble_batchscan_deq_rep_q 240 ** 241 ** Description dequeue a batchscan report in q when command complete 242 ** is received 243 ** 244 ** Returns void 245 ** 246 *******************************************************************************/ 247 void btm_ble_batchscan_deq_rep_data(UINT8 report_format, tBTM_BLE_REF_VALUE *p_ref_value, 248 UINT8 *p_num_records, UINT8 **p_data, UINT16 *p_data_len) 249 { 250 int index = 0; 251 252 for (index = 0; index < BTM_BLE_BATCH_REP_MAIN_Q_SIZE; index++) 253 { 254 if (report_format == ble_batchscan_cb.main_rep_q.rep_mode[index]) 255 break; 256 } 257 258 if (BTM_BLE_BATCH_REP_MAIN_Q_SIZE == index) 259 { 260 BTM_TRACE_ERROR("btm_ble_batchscan_deq_rep_data: rep_format:%d not found", report_format); 261 return; 262 } 263 264 *p_num_records = ble_batchscan_cb.main_rep_q.num_records[index]; 265 *p_ref_value = ble_batchscan_cb.main_rep_q.ref_value[index]; 266 *p_data = ble_batchscan_cb.main_rep_q.p_data[index]; 267 *p_data_len = ble_batchscan_cb.main_rep_q.data_len[index]; 268 269 ble_batchscan_cb.main_rep_q.p_data[index] = NULL; 270 ble_batchscan_cb.main_rep_q.data_len[index] = 0; 271 ble_batchscan_cb.main_rep_q.rep_mode[index] = 0; 272 ble_batchscan_cb.main_rep_q.ref_value[index] = 0; 273 ble_batchscan_cb.main_rep_q.num_records[index] = 0; 274 275 BTM_TRACE_DEBUG("btm_ble_batchscan_deq_rep_data: index:%d, rep %d, num %d, data_len %d", 276 index, report_format, *p_num_records, *p_data_len); 277 278 ble_batchscan_cb.main_rep_q.pending_idx = (ble_batchscan_cb.main_rep_q.pending_idx + 1) 279 % BTM_BLE_BATCH_SCAN_MAX; 280 } 281 282 /******************************************************************************* 283 ** 284 ** Function btm_ble_batchscan_deq_op_q 285 ** 286 ** Description dequeue a batch scan operation from q when command complete 287 ** is received 288 ** 289 ** Returns void 290 ** 291 *******************************************************************************/ 292 void btm_ble_batchscan_deq_op_q(UINT8 *p_opcode,tBTM_BLE_BATCH_SCAN_STATE *cur_state, 293 UINT8 *p_cb_evt, tBTM_BLE_REF_VALUE *p_ref) 294 { 295 *p_cb_evt = (ble_batchscan_cb.op_q.sub_code[ble_batchscan_cb.op_q.pending_idx] >> 4); 296 *p_opcode = (ble_batchscan_cb.op_q.sub_code[ble_batchscan_cb.op_q.pending_idx] 297 & BTM_BLE_BATCH_SCAN_SUBCODE_MASK); 298 *p_ref = ble_batchscan_cb.op_q.ref_value[ble_batchscan_cb.op_q.pending_idx]; 299 *cur_state = (ble_batchscan_cb.op_q.cur_state[ble_batchscan_cb.op_q.pending_idx]); 300 ble_batchscan_cb.op_q.pending_idx = (ble_batchscan_cb.op_q.pending_idx + 1) 301 % BTM_BLE_BATCH_SCAN_MAX; 302 } 303 304 /******************************************************************************* 305 ** 306 ** Function btm_ble_read_batchscan_reports 307 ** 308 ** Description This function reads the reports from controller 309 ** 310 ** Parameters scan_mode - The mode for which the reports are to be read out from the controller 311 ** ref_value - Reference value 312 ** 313 ** Returns status 314 ** 315 *******************************************************************************/ 316 tBTM_STATUS btm_ble_read_batchscan_reports(tBTM_BLE_BATCH_SCAN_MODE scan_mode, 317 tBTM_BLE_REF_VALUE ref_value) 318 { 319 tBTM_STATUS status = BTM_NO_RESOURCES; 320 UINT8 param[BTM_BLE_BATCH_SCAN_READ_RESULTS_LEN], *pp; 321 pp = param; 322 323 memset(param, 0, BTM_BLE_BATCH_SCAN_READ_RESULTS_LEN); 324 325 UINT8_TO_STREAM (pp, BTM_BLE_BATCH_SCAN_READ_RESULTS); 326 UINT8_TO_STREAM (pp, scan_mode); 327 328 if ((status = BTM_VendorSpecificCommand (HCI_BLE_BATCH_SCAN_OCF, 329 BTM_BLE_BATCH_SCAN_READ_RESULTS_LEN, param, btm_ble_batchscan_vsc_cmpl_cback)) 330 != BTM_CMD_STARTED) 331 { 332 BTM_TRACE_ERROR("btm_ble_read_batchscan_reports %d", status); 333 return BTM_ILLEGAL_VALUE; 334 } 335 336 if (BTM_CMD_STARTED == status) 337 { 338 /* The user needs to be provided scan read reports event */ 339 btm_ble_batchscan_enq_op_q(BTM_BLE_BATCH_SCAN_READ_RESULTS, ble_batchscan_cb.cur_state, 340 BTM_BLE_BATCH_SCAN_READ_REPTS_EVT, ref_value); 341 } 342 343 return status; 344 } 345 346 /******************************************************************************* 347 ** 348 ** Function btm_ble_batchscan_vsc_cmpl_cback 349 ** 350 ** Description Batch scan VSC complete callback 351 ** 352 ** Parameters p_params - VSC completed callback parameters 353 ** 354 ** Returns void 355 ** 356 *******************************************************************************/ 357 void btm_ble_batchscan_vsc_cmpl_cback (tBTM_VSC_CMPL *p_params) 358 { 359 UINT8 *p = p_params->p_param_buf; 360 UINT16 len = p_params->param_len; 361 tBTM_BLE_REF_VALUE ref_value = 0; 362 363 UINT8 status = 0, subcode = 0, opcode = 0; 364 UINT8 report_format = 0, num_records = 0, cb_evt = 0; 365 UINT16 data_len = 0; 366 tBTM_BLE_BATCH_SCAN_STATE cur_state = 0; 367 tBTM_STATUS btm_status = 0; 368 UINT8 *p_data = NULL; 369 370 if (len < 2) 371 { 372 BTM_TRACE_ERROR("wrong length for btm_ble_batch_scan_vsc_cmpl_cback"); 373 btm_ble_batchscan_deq_op_q(&opcode, &cur_state, &cb_evt, &ref_value); 374 return; 375 } 376 377 STREAM_TO_UINT8(status, p); 378 STREAM_TO_UINT8(subcode, p); 379 380 btm_ble_batchscan_deq_op_q(&opcode, &cur_state, &cb_evt, &ref_value); 381 382 BTM_TRACE_DEBUG("btm_ble_batchscan op_code = %02x state = %02x cb_evt = %02x,ref_value=%d", 383 opcode, cur_state, cb_evt, ref_value); 384 385 if (opcode != subcode) 386 { 387 BTM_TRACE_ERROR("Got unexpected VSC cmpl, expected: %d got: %d",subcode,opcode); 388 return; 389 } 390 391 switch (subcode) 392 { 393 case BTM_BLE_BATCH_SCAN_ENB_DISAB_CUST_FEATURE: 394 { 395 if (BTM_SUCCESS == status && BTM_BLE_SCAN_ENABLE_CALLED == cur_state) 396 ble_batchscan_cb.cur_state = BTM_BLE_SCAN_ENABLED_STATE; 397 else 398 if (BTM_BLE_SCAN_ENABLE_CALLED == cur_state) 399 { 400 BTM_TRACE_ERROR("SCAN_ENB_DISAB_CUST_FEATURE - Invalid state after enb"); 401 ble_batchscan_cb.cur_state = BTM_BLE_SCAN_INVALID_STATE; 402 } 403 404 BTM_TRACE_DEBUG("BTM_BLE_BATCH_SCAN_ENB_DISAB_CUST_FEAT status = %d, state: %d,evt=%d", 405 status, ble_batchscan_cb.cur_state, cb_evt); 406 407 if (cb_evt != 0 && NULL != ble_batchscan_cb.p_setup_cback) 408 ble_batchscan_cb.p_setup_cback(cb_evt, ref_value, status); 409 break; 410 } 411 412 case BTM_BLE_BATCH_SCAN_SET_STORAGE_PARAM: 413 { 414 BTM_TRACE_DEBUG("BTM_BLE_BATCH_SCAN_SET_STORAGE_PARAM status = %d, evt=%d", 415 status, cb_evt); 416 if (cb_evt != 0 && NULL != ble_batchscan_cb.p_setup_cback) 417 ble_batchscan_cb.p_setup_cback(cb_evt, ref_value, status); 418 break; 419 } 420 421 case BTM_BLE_BATCH_SCAN_SET_PARAMS: 422 { 423 BTM_TRACE_DEBUG("BTM_BLE_BATCH_SCAN_SET_PARAMS status = %d,evt=%d", status, cb_evt); 424 425 if (BTM_BLE_SCAN_DISABLE_CALLED == cur_state) 426 { 427 if (BTM_SUCCESS == status) 428 { 429 ble_batchscan_cb.cur_state = BTM_BLE_SCAN_DISABLED_STATE; 430 } 431 else 432 { 433 BTM_TRACE_ERROR("BTM_BLE_BATCH_SCAN_SET_PARAMS - Invalid state after disabled"); 434 ble_batchscan_cb.cur_state = BTM_BLE_SCAN_INVALID_STATE; 435 } 436 } 437 438 if (cb_evt != 0 && NULL != ble_batchscan_cb.p_setup_cback) 439 ble_batchscan_cb.p_setup_cback(cb_evt, ref_value, status); 440 break; 441 } 442 443 case BTM_BLE_BATCH_SCAN_READ_RESULTS: 444 { 445 if (cb_evt != 0 && NULL != ble_batchscan_cb.p_scan_rep_cback) 446 { 447 STREAM_TO_UINT8(report_format,p); 448 STREAM_TO_UINT8(num_records, p); 449 p = (uint8_t *)(p_params->p_param_buf + 4); 450 BTM_TRACE_DEBUG("BTM_BLE_BATCH_SCAN_READ_RESULTS status=%d,len=%d,rec=%d", 451 status, len-4, num_records); 452 453 if (0 == num_records) 454 { 455 btm_ble_batchscan_deq_rep_data(report_format, &ref_value, &num_records, 456 &p_data, &data_len); 457 if (NULL != ble_batchscan_cb.p_scan_rep_cback) 458 ble_batchscan_cb.p_scan_rep_cback(ref_value,report_format, num_records, 459 data_len, p_data, status); 460 } 461 else 462 { 463 if ((len-4) > 0) 464 { 465 btm_ble_batchscan_enq_rep_data(report_format, num_records, p, len-4); 466 /* More records could be in the buffer and needs to be pulled out */ 467 btm_status = btm_ble_read_batchscan_reports(report_format, ref_value); 468 if (BTM_CMD_STARTED != btm_status) 469 { 470 btm_ble_batchscan_deq_rep_data(report_format, &ref_value, &num_records, 471 &p_data, &data_len); 472 /* Send whatever is available, in case of a command failure */ 473 if (NULL != ble_batchscan_cb.p_scan_rep_cback && NULL != p_data) 474 ble_batchscan_cb.p_scan_rep_cback(ref_value,report_format, 475 num_records, data_len, p_data, status); 476 } 477 } 478 } 479 } 480 break; 481 } 482 483 default: 484 break; 485 } 486 487 return; 488 } 489 490 /******************************************************************************* 491 ** 492 ** Function btm_ble_set_storage_config 493 ** 494 ** Description This function writes the storage configuration in controller 495 ** 496 ** Parameters batch_scan_full_max -Max storage space (in %) allocated to full scanning 497 ** batch_scan_trunc_max -Max storage space (in %) allocated to truncated scanning 498 ** batch_scan_notify_threshold - Setup notification level based on total space 499 ** 500 ** Returns status 501 ** 502 *******************************************************************************/ 503 tBTM_STATUS btm_ble_set_storage_config(UINT8 batch_scan_full_max, UINT8 batch_scan_trunc_max, 504 UINT8 batch_scan_notify_threshold) 505 { 506 tBTM_STATUS status = BTM_NO_RESOURCES; 507 UINT8 param[BTM_BLE_BATCH_SCAN_STORAGE_CFG_LEN], *pp; 508 509 pp = param; 510 memset(param, 0, BTM_BLE_BATCH_SCAN_STORAGE_CFG_LEN); 511 512 UINT8_TO_STREAM (pp, BTM_BLE_BATCH_SCAN_SET_STORAGE_PARAM); 513 UINT8_TO_STREAM (pp, batch_scan_full_max); 514 UINT8_TO_STREAM (pp, batch_scan_trunc_max); 515 UINT8_TO_STREAM (pp, batch_scan_notify_threshold); 516 517 if ((status = BTM_VendorSpecificCommand (HCI_BLE_BATCH_SCAN_OCF, 518 BTM_BLE_BATCH_SCAN_STORAGE_CFG_LEN, param, 519 btm_ble_batchscan_vsc_cmpl_cback))!= BTM_CMD_STARTED) 520 { 521 BTM_TRACE_ERROR("btm_ble_set_storage_config %d", status); 522 return BTM_ILLEGAL_VALUE; 523 } 524 525 return status; 526 } 527 528 /******************************************************************************* 529 ** 530 ** Function btm_ble_set_batchscan_param 531 ** 532 ** Description This function writes the batch scan params in controller 533 ** 534 ** Parameters scan_mode -Batch scan mode 535 ** scan_interval - Scan interval 536 ** scan_window - Scan window 537 ** discard_rule -Discard rules 538 ** addr_type - Address type 539 ** 540 ** Returns status 541 ** 542 *******************************************************************************/ 543 tBTM_STATUS btm_ble_set_batchscan_param(tBTM_BLE_BATCH_SCAN_MODE scan_mode, 544 UINT32 scan_interval, UINT32 scan_window, tBLE_ADDR_TYPE addr_type, 545 tBTM_BLE_DISCARD_RULE discard_rule) 546 { 547 tBTM_STATUS status = BTM_NO_RESOURCES; 548 UINT8 scan_param[BTM_BLE_BATCH_SCAN_PARAM_CONFIG_LEN], *pp_scan; 549 550 pp_scan = scan_param; 551 memset(scan_param, 0, BTM_BLE_BATCH_SCAN_PARAM_CONFIG_LEN); 552 553 // Override param and decide addr_type based on own addr type 554 // TODO: Remove upper layer parameter? 555 addr_type = btm_cb.ble_ctr_cb.addr_mgnt_cb.own_addr_type; 556 557 UINT8_TO_STREAM (pp_scan, BTM_BLE_BATCH_SCAN_SET_PARAMS); 558 UINT8_TO_STREAM (pp_scan, scan_mode); 559 UINT32_TO_STREAM (pp_scan, scan_window); 560 UINT32_TO_STREAM (pp_scan, scan_interval); 561 UINT8_TO_STREAM (pp_scan, addr_type); 562 UINT8_TO_STREAM (pp_scan, discard_rule); 563 564 if ((status = BTM_VendorSpecificCommand (HCI_BLE_BATCH_SCAN_OCF, 565 BTM_BLE_BATCH_SCAN_PARAM_CONFIG_LEN, 566 scan_param, btm_ble_batchscan_vsc_cmpl_cback))!= BTM_CMD_STARTED) 567 { 568 BTM_TRACE_ERROR("btm_ble_set_batchscan_param %d", status); 569 return BTM_ILLEGAL_VALUE; 570 } 571 572 return status; 573 } 574 575 /******************************************************************************* 576 ** 577 ** Function btm_ble_enable_disable_batchscan 578 ** 579 ** Description This function enables the customer specific feature in controller 580 ** 581 ** Parameters enable_disable: true - enable, false - disable 582 ** 583 ** Returns status 584 ** 585 *******************************************************************************/ 586 tBTM_STATUS btm_ble_enable_disable_batchscan(BOOLEAN should_enable) 587 { 588 tBTM_STATUS status = BTM_NO_RESOURCES; 589 UINT8 shld_enable = 0x01; 590 UINT8 enable_param[BTM_BLE_BATCH_SCAN_ENB_DISB_LEN], *pp_enable; 591 592 if (!should_enable) 593 shld_enable = 0x00; 594 595 if (should_enable) 596 { 597 pp_enable = enable_param; 598 memset(enable_param, 0, BTM_BLE_BATCH_SCAN_ENB_DISB_LEN); 599 600 UINT8_TO_STREAM (pp_enable, BTM_BLE_BATCH_SCAN_ENB_DISAB_CUST_FEATURE); 601 UINT8_TO_STREAM (pp_enable, shld_enable); 602 603 if ((status = BTM_VendorSpecificCommand(HCI_BLE_BATCH_SCAN_OCF, 604 BTM_BLE_BATCH_SCAN_ENB_DISB_LEN, enable_param, 605 btm_ble_batchscan_vsc_cmpl_cback)) != BTM_CMD_STARTED) 606 { 607 status = BTM_MODE_UNSUPPORTED; 608 BTM_TRACE_ERROR("btm_ble_enable_disable_batchscan %d", status); 609 return BTM_ILLEGAL_VALUE; 610 } 611 } 612 else 613 if ((status = btm_ble_set_batchscan_param(BTM_BLE_BATCH_SCAN_MODE_DISABLE, 614 ble_batchscan_cb.scan_interval, ble_batchscan_cb.scan_window, 615 ble_batchscan_cb.addr_type, ble_batchscan_cb.discard_rule)) != BTM_CMD_STARTED) 616 { 617 status = BTM_MODE_UNSUPPORTED; 618 BTM_TRACE_ERROR("btm_ble_enable_disable_batchscan %d", status); 619 return BTM_ILLEGAL_VALUE; 620 } 621 622 if (should_enable) 623 ble_batchscan_cb.cur_state = BTM_BLE_SCAN_ENABLE_CALLED; 624 else 625 ble_batchscan_cb.cur_state = BTM_BLE_SCAN_DISABLE_CALLED; 626 return status; 627 } 628 629 /******************************************************************************* 630 ** 631 ** Function BTM_BleSetStorageConfig 632 ** 633 ** Description This function is called to write storage config params. 634 ** 635 ** Parameters: batch_scan_full_max - Max storage space (in %) allocated to full style 636 ** batch_scan_trunc_max - Max storage space (in %) allocated to trunc style 637 ** batch_scan_notify_threshold - Setup notification level based on total space 638 ** p_setup_cback - Setup callback pointer 639 ** p_thres_cback - Threshold callback pointer 640 ** p_rep_cback - Reports callback pointer 641 ** ref_value - Reference value 642 ** 643 ** Returns tBTM_STATUS 644 ** 645 *******************************************************************************/ 646 tBTM_STATUS BTM_BleSetStorageConfig(UINT8 batch_scan_full_max, UINT8 batch_scan_trunc_max, 647 UINT8 batch_scan_notify_threshold, 648 tBTM_BLE_SCAN_SETUP_CBACK *p_setup_cback, 649 tBTM_BLE_SCAN_THRESHOLD_CBACK *p_thres_cback, 650 tBTM_BLE_SCAN_REP_CBACK* p_rep_cback, 651 tBTM_BLE_REF_VALUE ref_value) 652 { 653 tBTM_STATUS status = BTM_NO_RESOURCES; 654 tBTM_BLE_VSC_CB cmn_ble_vsc_cb; 655 656 BTM_TRACE_EVENT (" BTM_BleSetStorageConfig: %d, %d, %d, %d, %d", 657 ble_batchscan_cb.cur_state, ref_value, batch_scan_full_max, batch_scan_trunc_max, 658 batch_scan_notify_threshold); 659 660 if (!controller_get_interface()->supports_ble()) 661 return BTM_ILLEGAL_VALUE; 662 663 BTM_BleGetVendorCapabilities(&cmn_ble_vsc_cb); 664 665 if (0 == cmn_ble_vsc_cb.tot_scan_results_strg) 666 { 667 BTM_TRACE_ERROR("Controller does not support batch scan"); 668 return BTM_ERR_PROCESSING; 669 } 670 671 ble_batchscan_cb.p_setup_cback = p_setup_cback; 672 ble_batchscan_cb.p_thres_cback = p_thres_cback; 673 ble_batchscan_cb.p_scan_rep_cback = p_rep_cback; 674 ble_batchscan_cb.ref_value = ref_value; 675 676 if (batch_scan_full_max > BTM_BLE_ADV_SCAN_FULL_MAX || 677 batch_scan_trunc_max > BTM_BLE_ADV_SCAN_TRUNC_MAX || 678 batch_scan_notify_threshold > BTM_BLE_ADV_SCAN_THR_MAX) 679 { 680 BTM_TRACE_ERROR("Illegal set storage config params"); 681 return BTM_ILLEGAL_VALUE; 682 } 683 684 if (BTM_BLE_SCAN_INVALID_STATE == ble_batchscan_cb.cur_state || 685 BTM_BLE_SCAN_DISABLED_STATE == ble_batchscan_cb.cur_state || 686 BTM_BLE_SCAN_DISABLE_CALLED == ble_batchscan_cb.cur_state) 687 { 688 status = btm_ble_enable_disable_batchscan(TRUE); 689 if (BTM_CMD_STARTED != status) 690 return status; 691 692 ble_batchscan_cb.cur_state = BTM_BLE_SCAN_ENABLE_CALLED; 693 btm_ble_batchscan_enq_op_q(BTM_BLE_BATCH_SCAN_ENB_DISAB_CUST_FEATURE, 694 BTM_BLE_SCAN_ENABLE_CALLED, 0, ref_value); 695 } 696 697 status = btm_ble_set_storage_config(batch_scan_full_max, batch_scan_trunc_max, 698 batch_scan_notify_threshold); 699 if (BTM_CMD_STARTED != status) 700 return status; 701 /* The user needs to be provided scan config storage event */ 702 btm_ble_batchscan_enq_op_q(BTM_BLE_BATCH_SCAN_SET_STORAGE_PARAM, ble_batchscan_cb.cur_state, 703 BTM_BLE_BATCH_SCAN_CFG_STRG_EVT, ref_value); 704 705 return status; 706 } 707 708 709 /******************************************************************************* 710 ** 711 ** Function BTM_BleEnableBatchScan 712 ** 713 ** Description This function is called to configure and enable batch scanning 714 ** 715 ** Parameters: scan_mode -Batch scan mode 716 ** scan_interval - Scan interval value 717 ** scan_window - Scan window value 718 ** discard_rule - Data discard rule 719 ** ref_value - Reference value 720 ** 721 ** Returns tBTM_STATUS 722 ** 723 *******************************************************************************/ 724 tBTM_STATUS BTM_BleEnableBatchScan(tBTM_BLE_BATCH_SCAN_MODE scan_mode, 725 UINT32 scan_interval, UINT32 scan_window, tBLE_ADDR_TYPE addr_type, 726 tBTM_BLE_DISCARD_RULE discard_rule, tBTM_BLE_REF_VALUE ref_value) 727 { 728 tBTM_STATUS status = BTM_NO_RESOURCES; 729 tBTM_BLE_VSC_CB cmn_ble_vsc_cb; 730 BTM_TRACE_EVENT (" BTM_BleEnableBatchScan: %d, %d, %d, %d, %d, %d", 731 scan_mode, scan_interval, scan_window, addr_type, discard_rule, ref_value); 732 733 if (!controller_get_interface()->supports_ble()) 734 return BTM_ILLEGAL_VALUE; 735 736 BTM_BleGetVendorCapabilities(&cmn_ble_vsc_cb); 737 738 if (0 == cmn_ble_vsc_cb.tot_scan_results_strg) 739 { 740 BTM_TRACE_ERROR("Controller does not support batch scan"); 741 return BTM_ERR_PROCESSING; 742 } 743 744 BTM_TRACE_DEBUG("BTM_BleEnableBatchScan: %d, %x, %x, %d, %d", scan_mode, scan_interval, 745 scan_window, discard_rule, ble_batchscan_cb.cur_state); 746 747 /* Only 16 bits will be used for scan interval and scan window as per agreement with Google */ 748 /* So the standard LE range would suffice for scan interval and scan window */ 749 if ((BTM_BLE_ISVALID_PARAM(scan_interval, BTM_BLE_SCAN_INT_MIN, BTM_BLE_SCAN_INT_MAX) || 750 BTM_BLE_ISVALID_PARAM(scan_window, BTM_BLE_SCAN_WIN_MIN, BTM_BLE_SCAN_WIN_MAX)) 751 && (BTM_BLE_BATCH_SCAN_MODE_PASS == scan_mode || BTM_BLE_BATCH_SCAN_MODE_ACTI == scan_mode 752 || BTM_BLE_BATCH_SCAN_MODE_PASS_ACTI == scan_mode) 753 && (BTM_BLE_DISCARD_OLD_ITEMS == discard_rule || 754 BTM_BLE_DISCARD_LOWER_RSSI_ITEMS == discard_rule)) 755 { 756 if (BTM_BLE_SCAN_INVALID_STATE == ble_batchscan_cb.cur_state || 757 BTM_BLE_SCAN_DISABLED_STATE == ble_batchscan_cb.cur_state || 758 BTM_BLE_SCAN_DISABLE_CALLED == ble_batchscan_cb.cur_state) 759 { 760 status = btm_ble_enable_disable_batchscan(TRUE); 761 if (BTM_CMD_STARTED != status) 762 return status; 763 btm_ble_batchscan_enq_op_q(BTM_BLE_BATCH_SCAN_ENB_DISAB_CUST_FEATURE, 764 BTM_BLE_SCAN_ENABLE_CALLED, 0, ref_value); 765 } 766 767 ble_batchscan_cb.scan_mode = scan_mode; 768 ble_batchscan_cb.scan_interval = scan_interval; 769 ble_batchscan_cb.scan_window = scan_window; 770 ble_batchscan_cb.addr_type = addr_type; 771 ble_batchscan_cb.discard_rule = discard_rule; 772 /* This command starts batch scanning, if enabled */ 773 status = btm_ble_set_batchscan_param(scan_mode, scan_interval, scan_window, addr_type, 774 discard_rule); 775 if (BTM_CMD_STARTED != status) 776 return status; 777 778 /* The user needs to be provided scan enable event */ 779 btm_ble_batchscan_enq_op_q(BTM_BLE_BATCH_SCAN_SET_PARAMS, ble_batchscan_cb.cur_state, 780 BTM_BLE_BATCH_SCAN_ENABLE_EVT, ref_value); 781 } 782 else 783 { 784 BTM_TRACE_ERROR("Illegal enable scan params"); 785 return BTM_ILLEGAL_VALUE; 786 } 787 return status; 788 } 789 790 /******************************************************************************* 791 ** 792 ** Function BTM_BleDisableBatchScan 793 ** 794 ** Description This function is called to disable batch scanning 795 ** 796 ** Parameters: ref_value - Reference value 797 ** 798 ** Returns tBTM_STATUS 799 ** 800 *******************************************************************************/ 801 tBTM_STATUS BTM_BleDisableBatchScan(tBTM_BLE_REF_VALUE ref_value) 802 { 803 tBTM_STATUS status = BTM_NO_RESOURCES; 804 tBTM_BLE_VSC_CB cmn_ble_vsc_cb; 805 BTM_TRACE_EVENT (" BTM_BleDisableBatchScan"); 806 807 if (!controller_get_interface()->supports_ble()) 808 return BTM_ILLEGAL_VALUE; 809 810 BTM_BleGetVendorCapabilities(&cmn_ble_vsc_cb); 811 812 if (0 == cmn_ble_vsc_cb.tot_scan_results_strg) 813 { 814 BTM_TRACE_ERROR("Controller does not support batch scan"); 815 return BTM_ERR_PROCESSING; 816 } 817 818 status = btm_ble_enable_disable_batchscan(FALSE); 819 if (BTM_CMD_STARTED == status) 820 { 821 /* The user needs to be provided scan disable event */ 822 btm_ble_batchscan_enq_op_q(BTM_BLE_BATCH_SCAN_SET_PARAMS, 823 BTM_BLE_SCAN_DISABLE_CALLED, BTM_BLE_BATCH_SCAN_DISABLE_EVT, 824 ref_value); 825 } 826 827 return status; 828 } 829 830 /******************************************************************************* 831 ** 832 ** Function BTM_BleReadScanReports 833 ** 834 ** Description This function is called to start reading batch scan reports 835 ** 836 ** Parameters: scan_mode - Batch scan mode 837 ** ref_value - Reference value 838 ** 839 ** Returns tBTM_STATUS 840 ** 841 *******************************************************************************/ 842 tBTM_STATUS BTM_BleReadScanReports(tBTM_BLE_BATCH_SCAN_MODE scan_mode, 843 tBTM_BLE_REF_VALUE ref_value) 844 { 845 tBTM_STATUS status = BTM_NO_RESOURCES; 846 tBTM_BLE_VSC_CB cmn_ble_vsc_cb; 847 UINT8 read_scan_mode = 0; 848 UINT8 *p_data = NULL, num_records = 0; 849 UINT16 data_len = 0; 850 851 BTM_TRACE_EVENT (" BTM_BleReadScanReports; %d, %d", scan_mode, ref_value); 852 853 if (!controller_get_interface()->supports_ble()) 854 return BTM_ILLEGAL_VALUE; 855 856 BTM_BleGetVendorCapabilities(&cmn_ble_vsc_cb); 857 858 if (0 == cmn_ble_vsc_cb.tot_scan_results_strg) 859 { 860 BTM_TRACE_ERROR("Controller does not support batch scan"); 861 return BTM_ERR_PROCESSING; 862 } 863 864 /* Check if the requested scan mode has already been setup by the user */ 865 read_scan_mode = ble_batchscan_cb.scan_mode & BTM_BLE_BATCH_SCAN_MODE_ACTI; 866 if (0 == read_scan_mode) 867 read_scan_mode = ble_batchscan_cb.scan_mode & BTM_BLE_BATCH_SCAN_MODE_PASS; 868 869 /* Check only for modes, as scan reports can be called after disabling batch scan */ 870 if (read_scan_mode > 0 && (BTM_BLE_BATCH_SCAN_MODE_PASS == scan_mode || 871 BTM_BLE_BATCH_SCAN_MODE_ACTI == scan_mode)) 872 { 873 status = btm_ble_batchscan_enq_rep_q(scan_mode, ref_value); 874 if (BTM_SUCCESS == status) 875 { 876 status = btm_ble_read_batchscan_reports(scan_mode, ref_value); 877 if (BTM_CMD_STARTED != status) 878 { 879 btm_ble_batchscan_deq_rep_data(scan_mode, &ref_value, 880 &num_records, &p_data, &data_len); 881 } 882 } 883 } 884 else 885 { 886 BTM_TRACE_ERROR("Illegal read scan params: %d, %d, %d", read_scan_mode, scan_mode, 887 ble_batchscan_cb.cur_state); 888 return BTM_ILLEGAL_VALUE; 889 } 890 return status; 891 } 892 893 894 /******************************************************************************* 895 ** 896 ** Function BTM_BleTrackAdvertiser 897 ** 898 ** Description This function is called to setup the callback for tracking advertisers 899 ** 900 ** Parameters: p_track_cback - Tracking callback pointer 901 ** ref_value - Reference value 902 ** 903 ** Returns tBTM_STATUS 904 ** 905 *******************************************************************************/ 906 tBTM_STATUS BTM_BleTrackAdvertiser(tBTM_BLE_TRACK_ADV_CBACK *p_track_cback, 907 tBTM_BLE_REF_VALUE ref_value) 908 { 909 tBTM_BLE_VSC_CB cmn_ble_vsc_cb; 910 BTM_TRACE_EVENT (" BTM_BleTrackAdvertiser"); 911 if (!controller_get_interface()->supports_ble()) 912 return BTM_ILLEGAL_VALUE; 913 914 BTM_BleGetVendorCapabilities(&cmn_ble_vsc_cb); 915 916 if (0 == cmn_ble_vsc_cb.tot_scan_results_strg) 917 { 918 BTM_TRACE_ERROR("Controller does not support scan storage"); 919 return BTM_ERR_PROCESSING; 920 } 921 922 ble_advtrack_cb.p_track_cback = p_track_cback; 923 ble_advtrack_cb.ref_value = ref_value; 924 return BTM_CMD_STARTED; 925 } 926 927 /******************************************************************************* 928 ** 929 ** Function btm_ble_batchscan_init 930 ** 931 ** Description This function initialize the batch scan control block. 932 ** 933 ** Parameters None 934 ** 935 ** Returns status 936 ** 937 *******************************************************************************/ 938 void btm_ble_batchscan_init(void) 939 { 940 BTM_TRACE_EVENT (" btm_ble_batchscan_init"); 941 memset(&ble_batchscan_cb, 0, sizeof(tBTM_BLE_BATCH_SCAN_CB)); 942 memset(&ble_advtrack_cb, 0, sizeof(tBTM_BLE_ADV_TRACK_CB)); 943 BTM_RegisterForVSEvents(btm_ble_batchscan_filter_track_adv_vse_cback, TRUE); 944 } 945 946 /******************************************************************************* 947 ** 948 ** Function btm_ble_batchscan_cleanup 949 ** 950 ** Description This function cleans the batch scan control block. 951 ** 952 ** Parameters None 953 ** 954 ** Returns void 955 ** 956 *******************************************************************************/ 957 void btm_ble_batchscan_cleanup(void) 958 { 959 int index = 0; 960 BTM_TRACE_EVENT (" btm_ble_batchscan_cleanup"); 961 962 for (index = 0; index < BTM_BLE_BATCH_REP_MAIN_Q_SIZE; index++) 963 osi_free_and_reset((void **)&ble_batchscan_cb.main_rep_q.p_data[index]); 964 965 memset(&ble_batchscan_cb, 0, sizeof(tBTM_BLE_BATCH_SCAN_CB)); 966 memset(&ble_advtrack_cb, 0, sizeof(tBTM_BLE_ADV_TRACK_CB)); 967 } 968 969 #endif 970
