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