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 that interface with the HCI transport. On 22 * the receive side, it routes events to the appropriate handler, e.g. 23 * L2CAP, ScoMgr. On the transmit side, it manages the command 24 * transmission. 25 * 26 ******************************************************************************/ 27 28 #include <stdlib.h> 29 #include <string.h> 30 #include <stdio.h> 31 32 #include "gki.h" 33 #include "bt_types.h" 34 #include "hcimsgs.h" 35 #include "btu.h" 36 #include "l2c_int.h" 37 #include "btm_api.h" 38 #include "btm_int.h" 39 40 extern void btm_process_cancel_complete(UINT8 status, UINT8 mode); 41 extern void btm_ble_test_command_complete(UINT8 *p); 42 43 // btla-specific ++ 44 #define LOG_TAG "BTLD" 45 #if (defined(ANDROID_APP_INCLUDED) && (ANDROID_APP_INCLUDED == TRUE) && (!defined(LINUX_NATIVE)) ) 46 #include <cutils/log.h> 47 #else 48 #define LOGV(format, ...) fprintf (stdout, LOG_TAG format"\n", ## __VA_ARGS__) 49 #define LOGE(format, ...) fprintf (stderr, LOG_TAG format"\n", ## __VA_ARGS__) 50 #define LOGI(format, ...) fprintf (stdout, LOG_TAG format"\n", ## __VA_ARGS__) 51 #endif 52 53 // btla-specific ++ 54 /* BTE application task */ 55 #if APPL_INCLUDED == TRUE 56 #include "bte_appl.h" 57 #endif 58 // btla-specific -- 59 60 //Counter to track number of HCI command timeout 61 static int num_hci_cmds_timed_out; 62 63 /********************************************************************************/ 64 /* L O C A L F U N C T I O N P R O T O T Y P E S */ 65 /********************************************************************************/ 66 static void btu_hcif_inquiry_comp_evt (UINT8 *p); 67 static void btu_hcif_inquiry_result_evt (UINT8 *p); 68 static void btu_hcif_inquiry_rssi_result_evt (UINT8 *p); 69 #if (BTM_EIR_CLIENT_INCLUDED == TRUE) 70 static void btu_hcif_extended_inquiry_result_evt (UINT8 *p); 71 #endif 72 73 static void btu_hcif_connection_comp_evt (UINT8 *p); 74 static void btu_hcif_connection_request_evt (UINT8 *p); 75 static void btu_hcif_disconnection_comp_evt (UINT8 *p); 76 static void btu_hcif_authentication_comp_evt (UINT8 *p); 77 static void btu_hcif_rmt_name_request_comp_evt (UINT8 *p, UINT16 evt_len); 78 static void btu_hcif_encryption_change_evt (UINT8 *p); 79 static void btu_hcif_change_conn_link_key_evt (UINT8 *p); 80 static void btu_hcif_master_link_key_comp_evt (UINT8 *p); 81 static void btu_hcif_read_rmt_features_comp_evt (UINT8 *p); 82 static void btu_hcif_read_rmt_ext_features_comp_evt (UINT8 *p); 83 static void btu_hcif_read_rmt_version_comp_evt (UINT8 *p); 84 static void btu_hcif_qos_setup_comp_evt (UINT8 *p); 85 static void btu_hcif_command_complete_evt (UINT8 controller_id, UINT8 *p, UINT16 evt_len); 86 static void btu_hcif_command_status_evt (UINT8 controller_id, UINT8 *p); 87 static void btu_hcif_hardware_error_evt (UINT8 *p); 88 static void btu_hcif_flush_occured_evt (void); 89 static void btu_hcif_role_change_evt (UINT8 *p); 90 static void btu_hcif_num_compl_data_pkts_evt (UINT8 *p); 91 static void btu_hcif_mode_change_evt (UINT8 *p); 92 static void btu_hcif_return_link_keys_evt (UINT8 *p); 93 static void btu_hcif_pin_code_request_evt (UINT8 *p); 94 static void btu_hcif_link_key_request_evt (UINT8 *p); 95 static void btu_hcif_link_key_notification_evt (UINT8 *p); 96 static void btu_hcif_loopback_command_evt (void); 97 static void btu_hcif_data_buf_overflow_evt (void); 98 static void btu_hcif_max_slots_changed_evt (void); 99 static void btu_hcif_read_clock_off_comp_evt (UINT8 *p); 100 static void btu_hcif_conn_pkt_type_change_evt (void); 101 static void btu_hcif_qos_violation_evt (UINT8 *p); 102 static void btu_hcif_page_scan_mode_change_evt (void); 103 static void btu_hcif_page_scan_rep_mode_chng_evt (void); 104 static void btu_hcif_esco_connection_comp_evt(UINT8 *p); 105 static void btu_hcif_esco_connection_chg_evt(UINT8 *p); 106 107 /* Simple Pairing Events */ 108 static void btu_hcif_host_support_evt (UINT8 *p); 109 static void btu_hcif_io_cap_request_evt (UINT8 *p); 110 static void btu_hcif_io_cap_response_evt (UINT8 *p); 111 static void btu_hcif_user_conf_request_evt (UINT8 *p); 112 static void btu_hcif_user_passkey_request_evt (UINT8 *p); 113 static void btu_hcif_user_passkey_notif_evt (UINT8 *p); 114 static void btu_hcif_keypress_notif_evt (UINT8 *p); 115 static void btu_hcif_link_super_tout_evt (UINT8 *p); 116 117 #if BTM_OOB_INCLUDED == TRUE 118 static void btu_hcif_rem_oob_request_evt (UINT8 *p); 119 #endif 120 121 static void btu_hcif_simple_pair_complete_evt (UINT8 *p); 122 #if L2CAP_NON_FLUSHABLE_PB_INCLUDED == TRUE 123 static void btu_hcif_enhanced_flush_complete_evt (void); 124 #endif 125 126 #if (BTM_SSR_INCLUDED == TRUE) 127 static void btu_hcif_ssr_evt (UINT8 *p, UINT16 evt_len); 128 #endif /* BTM_SSR_INCLUDED == TRUE */ 129 130 #if (HID_DEV_INCLUDED == TRUE) && (HID_DEV_PM_INCLUDED == TRUE) 131 extern void hidd_pm_proc_mode_change( UINT8 hci_status, UINT8 mode, UINT16 interval ); 132 #endif 133 134 135 #if BLE_INCLUDED == TRUE 136 static void btu_ble_ll_conn_complete_evt (UINT8 *p, UINT16 evt_len); 137 static void btu_ble_process_adv_pkt (UINT8 *p); 138 static void btu_ble_read_remote_feat_evt (UINT8 *p); 139 static void btu_ble_ll_conn_param_upd_evt (UINT8 *p, UINT16 evt_len); 140 static void btu_ble_proc_ltk_req (UINT8 *p); 141 static void btu_hcif_encryption_key_refresh_cmpl_evt (UINT8 *p); 142 #if (BLE_LLT_INCLUDED == TRUE) 143 static void btu_ble_rc_param_req_evt(UINT8 *p); 144 #endif 145 #endif 146 /******************************************************************************* 147 ** 148 ** Function btu_hcif_store_cmd 149 ** 150 ** Description This function stores a copy of an outgoing command and 151 ** and sets a timer waiting for a event in response to the 152 ** command. 153 ** 154 ** Returns void 155 ** 156 *******************************************************************************/ 157 static void btu_hcif_store_cmd (UINT8 controller_id, BT_HDR *p_buf) 158 { 159 tHCI_CMD_CB *p_hci_cmd_cb; 160 UINT16 opcode; 161 BT_HDR *p_cmd; 162 UINT8 *p; 163 164 /* Validate controller ID */ 165 if (controller_id >= BTU_MAX_LOCAL_CTRLS) 166 return; 167 168 p_hci_cmd_cb = &(btu_cb.hci_cmd_cb[controller_id]); 169 p = (UINT8 *)(p_buf + 1) + p_buf->offset; 170 171 /* get command opcode */ 172 STREAM_TO_UINT16 (opcode, p); 173 174 /* don't do anything for certain commands */ 175 if ((opcode == HCI_RESET) || (opcode == HCI_HOST_NUM_PACKETS_DONE)) 176 { 177 return; 178 } 179 180 /* allocate buffer (HCI_GET_CMD_BUF will either get a buffer from HCI_CMD_POOL or from 'best-fit' pool) */ 181 if ((p_cmd = HCI_GET_CMD_BUF(p_buf->len + p_buf->offset - HCIC_PREAMBLE_SIZE)) == NULL) 182 { 183 return; 184 } 185 186 /* copy buffer */ 187 memcpy (p_cmd, p_buf, sizeof(BT_HDR)); 188 189 /* If vendor specific save the callback function */ 190 if ((opcode & HCI_GRP_VENDOR_SPECIFIC) == HCI_GRP_VENDOR_SPECIFIC 191 #if BLE_INCLUDED == TRUE 192 || (opcode == HCI_BLE_RAND ) 193 || (opcode == HCI_BLE_ENCRYPT) 194 #endif 195 ) 196 { 197 memcpy ((UINT8 *)(p_cmd + 1), (UINT8 *)(p_buf + 1), sizeof(void *)); 198 } 199 200 memcpy ((UINT8 *)(p_cmd + 1) + p_cmd->offset, 201 (UINT8 *)(p_buf + 1) + p_buf->offset, p_buf->len); 202 203 /* queue copy of cmd */ 204 GKI_enqueue(&(p_hci_cmd_cb->cmd_cmpl_q), p_cmd); 205 206 /* start timer */ 207 if (BTU_CMD_CMPL_TIMEOUT > 0) 208 { 209 #if (defined(BTU_CMD_CMPL_TOUT_DOUBLE_CHECK) && BTU_CMD_CMPL_TOUT_DOUBLE_CHECK == TRUE) 210 p_hci_cmd_cb->checked_hcisu = FALSE; 211 #endif 212 btu_start_timer (&(p_hci_cmd_cb->cmd_cmpl_timer), 213 (UINT16)(BTU_TTYPE_BTU_CMD_CMPL + controller_id), 214 BTU_CMD_CMPL_TIMEOUT); 215 } 216 } 217 218 /******************************************************************************* 219 ** 220 ** Function btu_hcif_process_event 221 ** 222 ** Description This function is called when an event is received from 223 ** the Host Controller. 224 ** 225 ** Returns void 226 ** 227 *******************************************************************************/ 228 void btu_hcif_process_event (UINT8 controller_id, BT_HDR *p_msg) 229 { 230 UINT8 *p = (UINT8 *)(p_msg + 1) + p_msg->offset; 231 UINT8 hci_evt_code, hci_evt_len; 232 #if BLE_INCLUDED == TRUE 233 UINT8 ble_sub_code; 234 #endif 235 STREAM_TO_UINT8 (hci_evt_code, p); 236 STREAM_TO_UINT8 (hci_evt_len, p); 237 238 switch (hci_evt_code) 239 { 240 case HCI_INQUIRY_COMP_EVT: 241 btu_hcif_inquiry_comp_evt (p); 242 break; 243 case HCI_INQUIRY_RESULT_EVT: 244 btu_hcif_inquiry_result_evt (p); 245 break; 246 case HCI_INQUIRY_RSSI_RESULT_EVT: 247 btu_hcif_inquiry_rssi_result_evt (p); 248 break; 249 #if (BTM_EIR_CLIENT_INCLUDED == TRUE) 250 case HCI_EXTENDED_INQUIRY_RESULT_EVT: 251 btu_hcif_extended_inquiry_result_evt (p); 252 break; 253 #endif 254 case HCI_CONNECTION_COMP_EVT: 255 btu_hcif_connection_comp_evt (p); 256 break; 257 case HCI_CONNECTION_REQUEST_EVT: 258 btu_hcif_connection_request_evt (p); 259 break; 260 case HCI_DISCONNECTION_COMP_EVT: 261 btu_hcif_disconnection_comp_evt (p); 262 break; 263 case HCI_AUTHENTICATION_COMP_EVT: 264 btu_hcif_authentication_comp_evt (p); 265 break; 266 case HCI_RMT_NAME_REQUEST_COMP_EVT: 267 btu_hcif_rmt_name_request_comp_evt (p, hci_evt_len); 268 break; 269 case HCI_ENCRYPTION_CHANGE_EVT: 270 btu_hcif_encryption_change_evt (p); 271 break; 272 #if BLE_INCLUDED == TRUE 273 case HCI_ENCRYPTION_KEY_REFRESH_COMP_EVT: 274 btu_hcif_encryption_key_refresh_cmpl_evt(p); 275 break; 276 #endif 277 case HCI_CHANGE_CONN_LINK_KEY_EVT: 278 btu_hcif_change_conn_link_key_evt (p); 279 break; 280 case HCI_MASTER_LINK_KEY_COMP_EVT: 281 btu_hcif_master_link_key_comp_evt (p); 282 break; 283 case HCI_READ_RMT_FEATURES_COMP_EVT: 284 btu_hcif_read_rmt_features_comp_evt (p); 285 break; 286 case HCI_READ_RMT_EXT_FEATURES_COMP_EVT: 287 btu_hcif_read_rmt_ext_features_comp_evt (p); 288 break; 289 case HCI_READ_RMT_VERSION_COMP_EVT: 290 btu_hcif_read_rmt_version_comp_evt (p); 291 break; 292 case HCI_QOS_SETUP_COMP_EVT: 293 btu_hcif_qos_setup_comp_evt (p); 294 break; 295 case HCI_COMMAND_COMPLETE_EVT: 296 btu_hcif_command_complete_evt (controller_id, p, hci_evt_len); 297 break; 298 case HCI_COMMAND_STATUS_EVT: 299 btu_hcif_command_status_evt (controller_id, p); 300 break; 301 case HCI_HARDWARE_ERROR_EVT: 302 btu_hcif_hardware_error_evt (p); 303 break; 304 case HCI_FLUSH_OCCURED_EVT: 305 btu_hcif_flush_occured_evt (); 306 break; 307 case HCI_ROLE_CHANGE_EVT: 308 btu_hcif_role_change_evt (p); 309 break; 310 case HCI_NUM_COMPL_DATA_PKTS_EVT: 311 btu_hcif_num_compl_data_pkts_evt (p); 312 break; 313 case HCI_MODE_CHANGE_EVT: 314 btu_hcif_mode_change_evt (p); 315 break; 316 case HCI_RETURN_LINK_KEYS_EVT: 317 btu_hcif_return_link_keys_evt (p); 318 break; 319 case HCI_PIN_CODE_REQUEST_EVT: 320 btu_hcif_pin_code_request_evt (p); 321 break; 322 case HCI_LINK_KEY_REQUEST_EVT: 323 btu_hcif_link_key_request_evt (p); 324 break; 325 case HCI_LINK_KEY_NOTIFICATION_EVT: 326 btu_hcif_link_key_notification_evt (p); 327 break; 328 case HCI_LOOPBACK_COMMAND_EVT: 329 btu_hcif_loopback_command_evt (); 330 break; 331 case HCI_DATA_BUF_OVERFLOW_EVT: 332 btu_hcif_data_buf_overflow_evt (); 333 break; 334 case HCI_MAX_SLOTS_CHANGED_EVT: 335 btu_hcif_max_slots_changed_evt (); 336 break; 337 case HCI_READ_CLOCK_OFF_COMP_EVT: 338 btu_hcif_read_clock_off_comp_evt (p); 339 break; 340 case HCI_CONN_PKT_TYPE_CHANGE_EVT: 341 btu_hcif_conn_pkt_type_change_evt (); 342 break; 343 case HCI_QOS_VIOLATION_EVT: 344 btu_hcif_qos_violation_evt (p); 345 break; 346 case HCI_PAGE_SCAN_MODE_CHANGE_EVT: 347 btu_hcif_page_scan_mode_change_evt (); 348 break; 349 case HCI_PAGE_SCAN_REP_MODE_CHNG_EVT: 350 btu_hcif_page_scan_rep_mode_chng_evt (); 351 break; 352 case HCI_ESCO_CONNECTION_COMP_EVT: 353 btu_hcif_esco_connection_comp_evt (p); 354 break; 355 case HCI_ESCO_CONNECTION_CHANGED_EVT: 356 btu_hcif_esco_connection_chg_evt (p); 357 break; 358 #if (BTM_SSR_INCLUDED == TRUE) 359 case HCI_SNIFF_SUB_RATE_EVT: 360 btu_hcif_ssr_evt (p, hci_evt_len); 361 break; 362 #endif /* BTM_SSR_INCLUDED == TRUE */ 363 case HCI_RMT_HOST_SUP_FEAT_NOTIFY_EVT: 364 btu_hcif_host_support_evt (p); 365 break; 366 case HCI_IO_CAPABILITY_REQUEST_EVT: 367 btu_hcif_io_cap_request_evt (p); 368 break; 369 case HCI_IO_CAPABILITY_RESPONSE_EVT: 370 btu_hcif_io_cap_response_evt (p); 371 break; 372 case HCI_USER_CONFIRMATION_REQUEST_EVT: 373 btu_hcif_user_conf_request_evt (p); 374 break; 375 case HCI_USER_PASSKEY_REQUEST_EVT: 376 btu_hcif_user_passkey_request_evt (p); 377 break; 378 #if BTM_OOB_INCLUDED == TRUE 379 case HCI_REMOTE_OOB_DATA_REQUEST_EVT: 380 btu_hcif_rem_oob_request_evt (p); 381 break; 382 #endif 383 case HCI_SIMPLE_PAIRING_COMPLETE_EVT: 384 btu_hcif_simple_pair_complete_evt (p); 385 break; 386 case HCI_USER_PASSKEY_NOTIFY_EVT: 387 btu_hcif_user_passkey_notif_evt (p); 388 break; 389 case HCI_KEYPRESS_NOTIFY_EVT: 390 btu_hcif_keypress_notif_evt (p); 391 break; 392 case HCI_LINK_SUPER_TOUT_CHANGED_EVT: 393 btu_hcif_link_super_tout_evt (p); 394 break; 395 #if L2CAP_NON_FLUSHABLE_PB_INCLUDED == TRUE 396 case HCI_ENHANCED_FLUSH_COMPLETE_EVT: 397 btu_hcif_enhanced_flush_complete_evt (); 398 break; 399 #endif 400 401 #if (BLE_INCLUDED == TRUE) 402 case HCI_BLE_EVENT: 403 STREAM_TO_UINT8 (ble_sub_code, p); 404 405 HCI_TRACE_EVENT("BLE HCI(id=%d) event = 0x%02x)", hci_evt_code, ble_sub_code); 406 407 switch (ble_sub_code) 408 { 409 case HCI_BLE_ADV_PKT_RPT_EVT: /* result of inquiry */ 410 btu_ble_process_adv_pkt(p); 411 break; 412 case HCI_BLE_CONN_COMPLETE_EVT: 413 btu_ble_ll_conn_complete_evt(p, hci_evt_len); 414 break; 415 case HCI_BLE_LL_CONN_PARAM_UPD_EVT: 416 btu_ble_ll_conn_param_upd_evt(p, hci_evt_len); 417 break; 418 case HCI_BLE_READ_REMOTE_FEAT_CMPL_EVT: 419 btu_ble_read_remote_feat_evt(p); 420 break; 421 case HCI_BLE_LTK_REQ_EVT: /* received only at slave device */ 422 btu_ble_proc_ltk_req(p); 423 break; 424 #if (BLE_LLT_INCLUDED == TRUE) 425 case HCI_BLE_RC_PARAM_REQ_EVT: 426 btu_ble_rc_param_req_evt(p); 427 break; 428 #endif 429 430 } 431 break; 432 #endif /* BLE_INCLUDED */ 433 case HCI_VENDOR_SPECIFIC_EVT: 434 btm_vendor_specific_evt (p, hci_evt_len); 435 break; 436 } 437 // reset the num_hci_cmds_timed_out upon receving any event from controller. 438 num_hci_cmds_timed_out = 0; 439 } 440 441 442 /******************************************************************************* 443 ** 444 ** Function btu_hcif_send_cmd 445 ** 446 ** Description This function is called to check if it can send commands 447 ** to the Host Controller. It may be passed the address of 448 ** a packet to send. 449 ** 450 ** Returns void 451 ** 452 *******************************************************************************/ 453 void btu_hcif_send_cmd (UINT8 controller_id, BT_HDR *p_buf) 454 { 455 tHCI_CMD_CB * p_hci_cmd_cb = &(btu_cb.hci_cmd_cb[controller_id]); 456 457 #if ((L2CAP_HOST_FLOW_CTRL == TRUE)||defined(HCI_TESTER)) 458 UINT8 *pp; 459 UINT16 code; 460 #endif 461 462 /* If there are already commands in the queue, then enqueue this command */ 463 if ((p_buf) && (p_hci_cmd_cb->cmd_xmit_q.count)) 464 { 465 GKI_enqueue (&(p_hci_cmd_cb->cmd_xmit_q), p_buf); 466 p_buf = NULL; 467 } 468 469 /* Allow for startup case, where no acks may be received */ 470 if ( ((controller_id == LOCAL_BR_EDR_CONTROLLER_ID) 471 && (p_hci_cmd_cb->cmd_window == 0) 472 && (btm_cb.devcb.state == BTM_DEV_STATE_WAIT_RESET_CMPLT)) ) 473 { 474 p_hci_cmd_cb->cmd_window = p_hci_cmd_cb->cmd_xmit_q.count + 1; 475 } 476 477 /* See if we can send anything */ 478 while (p_hci_cmd_cb->cmd_window != 0) 479 { 480 if (!p_buf) 481 p_buf = (BT_HDR *)GKI_dequeue (&(p_hci_cmd_cb->cmd_xmit_q)); 482 483 if (p_buf) 484 { 485 btu_hcif_store_cmd(controller_id, p_buf); 486 487 #if ((L2CAP_HOST_FLOW_CTRL == TRUE)||defined(HCI_TESTER)) 488 pp = (UINT8 *)(p_buf + 1) + p_buf->offset; 489 490 STREAM_TO_UINT16 (code, pp); 491 492 /* 493 * We do not need to decrease window for host flow control, 494 * host flow control does not receive an event back from controller 495 */ 496 if (code != HCI_HOST_NUM_PACKETS_DONE) 497 #endif 498 p_hci_cmd_cb->cmd_window--; 499 500 if (controller_id == LOCAL_BR_EDR_CONTROLLER_ID) 501 { 502 HCI_CMD_TO_LOWER(p_buf); 503 } 504 else 505 { 506 /* Unknown controller */ 507 HCI_TRACE_WARNING("BTU HCI(ctrl id=%d) controller ID not recognized", controller_id); 508 GKI_freebuf(p_buf);; 509 } 510 511 p_buf = NULL; 512 } 513 else 514 break; 515 } 516 517 if (p_buf) 518 GKI_enqueue (&(p_hci_cmd_cb->cmd_xmit_q), p_buf); 519 520 #if (defined(HCILP_INCLUDED) && HCILP_INCLUDED == TRUE) 521 if (controller_id == LOCAL_BR_EDR_CONTROLLER_ID) 522 { 523 /* check if controller can go to sleep */ 524 btu_check_bt_sleep (); 525 } 526 #endif 527 528 } 529 530 531 /******************************************************************************* 532 ** 533 ** Function btu_hcif_send_host_rdy_for_data 534 ** 535 ** Description This function is called to check if it can send commands 536 ** to the Host Controller. It may be passed the address of 537 ** a packet to send. 538 ** 539 ** Returns void 540 ** 541 *******************************************************************************/ 542 void btu_hcif_send_host_rdy_for_data(void) 543 { 544 UINT16 num_pkts[MAX_L2CAP_LINKS + 4]; /* 3 SCO connections */ 545 UINT16 handles[MAX_L2CAP_LINKS + 4]; 546 UINT8 num_ents; 547 548 /* Get the L2CAP numbers */ 549 num_ents = l2c_link_pkts_rcvd (num_pkts, handles); 550 551 /* Get the SCO numbers */ 552 /* No SCO for now ?? */ 553 554 if (num_ents) 555 { 556 btsnd_hcic_host_num_xmitted_pkts (num_ents, handles, num_pkts); 557 } 558 } 559 560 /******************************************************************************* 561 ** 562 ** Function btu_hcif_inquiry_comp_evt 563 ** 564 ** Description Process event HCI_INQUIRY_COMP_EVT 565 ** 566 ** Returns void 567 ** 568 *******************************************************************************/ 569 static void btu_hcif_inquiry_comp_evt (UINT8 *p) 570 { 571 UINT8 status; 572 573 STREAM_TO_UINT8 (status, p); 574 575 /* Tell inquiry processing that we are done */ 576 btm_process_inq_complete(status, BTM_BR_INQUIRY_MASK); 577 } 578 579 580 /******************************************************************************* 581 ** 582 ** Function btu_hcif_inquiry_result_evt 583 ** 584 ** Description Process event HCI_INQUIRY_RESULT_EVT 585 ** 586 ** Returns void 587 ** 588 *******************************************************************************/ 589 static void btu_hcif_inquiry_result_evt (UINT8 *p) 590 { 591 /* Store results in the cache */ 592 btm_process_inq_results (p, BTM_INQ_RESULT_STANDARD); 593 } 594 595 /******************************************************************************* 596 ** 597 ** Function btu_hcif_inquiry_rssi_result_evt 598 ** 599 ** Description Process event HCI_INQUIRY_RSSI_RESULT_EVT 600 ** 601 ** Returns void 602 ** 603 *******************************************************************************/ 604 static void btu_hcif_inquiry_rssi_result_evt (UINT8 *p) 605 { 606 /* Store results in the cache */ 607 btm_process_inq_results (p, BTM_INQ_RESULT_WITH_RSSI); 608 } 609 610 /******************************************************************************* 611 ** 612 ** Function btu_hcif_extended_inquiry_result_evt 613 ** 614 ** Description Process event HCI_EXTENDED_INQUIRY_RESULT_EVT 615 ** 616 ** Returns void 617 ** 618 *******************************************************************************/ 619 #if (BTM_EIR_CLIENT_INCLUDED == TRUE) 620 static void btu_hcif_extended_inquiry_result_evt (UINT8 *p) 621 { 622 /* Store results in the cache */ 623 btm_process_inq_results (p, BTM_INQ_RESULT_EXTENDED); 624 } 625 #endif 626 627 /******************************************************************************* 628 ** 629 ** Function btu_hcif_connection_comp_evt 630 ** 631 ** Description Process event HCI_CONNECTION_COMP_EVT 632 ** 633 ** Returns void 634 ** 635 *******************************************************************************/ 636 static void btu_hcif_connection_comp_evt (UINT8 *p) 637 { 638 UINT8 status; 639 UINT16 handle; 640 BD_ADDR bda; 641 UINT8 link_type; 642 UINT8 enc_mode; 643 #if BTM_SCO_INCLUDED == TRUE 644 tBTM_ESCO_DATA esco_data; 645 #endif 646 647 STREAM_TO_UINT8 (status, p); 648 STREAM_TO_UINT16 (handle, p); 649 STREAM_TO_BDADDR (bda, p); 650 STREAM_TO_UINT8 (link_type, p); 651 STREAM_TO_UINT8 (enc_mode, p); 652 653 handle = HCID_GET_HANDLE (handle); 654 655 if (link_type == HCI_LINK_TYPE_ACL) 656 { 657 btm_sec_connected (bda, handle, status, enc_mode); 658 659 l2c_link_hci_conn_comp (status, handle, bda); 660 } 661 #if BTM_SCO_INCLUDED == TRUE 662 else 663 { 664 memset(&esco_data, 0, sizeof(tBTM_ESCO_DATA)); 665 /* esco_data.link_type = HCI_LINK_TYPE_SCO; already zero */ 666 memcpy (esco_data.bd_addr, bda, BD_ADDR_LEN); 667 btm_sco_connected (status, bda, handle, &esco_data); 668 } 669 #endif /* BTM_SCO_INCLUDED */ 670 } 671 672 673 /******************************************************************************* 674 ** 675 ** Function btu_hcif_connection_request_evt 676 ** 677 ** Description Process event HCI_CONNECTION_REQUEST_EVT 678 ** 679 ** Returns void 680 ** 681 *******************************************************************************/ 682 static void btu_hcif_connection_request_evt (UINT8 *p) 683 { 684 BD_ADDR bda; 685 DEV_CLASS dc; 686 UINT8 link_type; 687 688 STREAM_TO_BDADDR (bda, p); 689 STREAM_TO_DEVCLASS (dc, p); 690 STREAM_TO_UINT8 (link_type, p); 691 692 /* Pass request to security manager to check connect filters before */ 693 /* passing request to l2cap */ 694 if (link_type == HCI_LINK_TYPE_ACL) 695 { 696 btm_sec_conn_req (bda, dc); 697 } 698 #if BTM_SCO_INCLUDED == TRUE 699 else 700 { 701 btm_sco_conn_req (bda, dc, link_type); 702 } 703 #endif /* BTM_SCO_INCLUDED */ 704 } 705 706 707 /******************************************************************************* 708 ** 709 ** Function btu_hcif_disconnection_comp_evt 710 ** 711 ** Description Process event HCI_DISCONNECTION_COMP_EVT 712 ** 713 ** Returns void 714 ** 715 *******************************************************************************/ 716 static void btu_hcif_disconnection_comp_evt (UINT8 *p) 717 { 718 UINT8 status; 719 UINT16 handle; 720 UINT8 reason; 721 722 STREAM_TO_UINT8 (status, p); 723 STREAM_TO_UINT16 (handle, p); 724 STREAM_TO_UINT8 (reason, p); 725 726 handle = HCID_GET_HANDLE (handle); 727 728 #if BTM_SCO_INCLUDED == TRUE 729 /* If L2CAP doesn't know about it, send it to SCO */ 730 if (!l2c_link_hci_disc_comp (handle, reason)) 731 btm_sco_removed (handle, reason); 732 #else 733 l2c_link_hci_disc_comp (handle, reason); 734 #endif /* BTM_SCO_INCLUDED */ 735 736 /* Notify security manager */ 737 btm_sec_disconnected (handle, reason); 738 } 739 740 /******************************************************************************* 741 ** 742 ** Function btu_hcif_authentication_comp_evt 743 ** 744 ** Description Process event HCI_AUTHENTICATION_COMP_EVT 745 ** 746 ** Returns void 747 ** 748 *******************************************************************************/ 749 static void btu_hcif_authentication_comp_evt (UINT8 *p) 750 { 751 UINT8 status; 752 UINT16 handle; 753 754 STREAM_TO_UINT8 (status, p); 755 STREAM_TO_UINT16 (handle, p); 756 757 btm_sec_auth_complete (handle, status); 758 } 759 760 761 /******************************************************************************* 762 ** 763 ** Function btu_hcif_rmt_name_request_comp_evt 764 ** 765 ** Description Process event HCI_RMT_NAME_REQUEST_COMP_EVT 766 ** 767 ** Returns void 768 ** 769 *******************************************************************************/ 770 static void btu_hcif_rmt_name_request_comp_evt (UINT8 *p, UINT16 evt_len) 771 { 772 UINT8 status; 773 BD_ADDR bd_addr; 774 775 STREAM_TO_UINT8 (status, p); 776 STREAM_TO_BDADDR (bd_addr, p); 777 778 evt_len -= (1 + BD_ADDR_LEN); 779 780 btm_process_remote_name (bd_addr, p, evt_len, status); 781 782 btm_sec_rmt_name_request_complete (bd_addr, p, status); 783 } 784 785 786 /******************************************************************************* 787 ** 788 ** Function btu_hcif_encryption_change_evt 789 ** 790 ** Description Process event HCI_ENCRYPTION_CHANGE_EVT 791 ** 792 ** Returns void 793 ** 794 *******************************************************************************/ 795 static void btu_hcif_encryption_change_evt (UINT8 *p) 796 { 797 UINT8 status; 798 UINT16 handle; 799 UINT8 encr_enable; 800 801 STREAM_TO_UINT8 (status, p); 802 STREAM_TO_UINT16 (handle, p); 803 STREAM_TO_UINT8 (encr_enable, p); 804 805 btm_acl_encrypt_change (handle, status, encr_enable); 806 btm_sec_encrypt_change (handle, status, encr_enable); 807 } 808 809 810 /******************************************************************************* 811 ** 812 ** Function btu_hcif_change_conn_link_key_evt 813 ** 814 ** Description Process event HCI_CHANGE_CONN_LINK_KEY_EVT 815 ** 816 ** Returns void 817 ** 818 *******************************************************************************/ 819 static void btu_hcif_change_conn_link_key_evt (UINT8 *p) 820 { 821 UINT8 status; 822 UINT16 handle; 823 824 STREAM_TO_UINT8 (status, p); 825 STREAM_TO_UINT16 (handle, p); 826 827 btm_acl_link_key_change (handle, status); 828 } 829 830 831 /******************************************************************************* 832 ** 833 ** Function btu_hcif_master_link_key_comp_evt 834 ** 835 ** Description Process event HCI_MASTER_LINK_KEY_COMP_EVT 836 ** 837 ** Returns void 838 ** 839 *******************************************************************************/ 840 static void btu_hcif_master_link_key_comp_evt (UINT8 *p) 841 { 842 UINT8 status; 843 UINT16 handle; 844 UINT8 key_flg; 845 846 STREAM_TO_UINT8 (status, p); 847 STREAM_TO_UINT16 (handle, p); 848 STREAM_TO_UINT8 (key_flg, p); 849 850 btm_sec_mkey_comp_event (handle, status, key_flg); 851 } 852 853 854 /******************************************************************************* 855 ** 856 ** Function btu_hcif_read_rmt_features_comp_evt 857 ** 858 ** Description Process event HCI_READ_RMT_FEATURES_COMP_EVT 859 ** 860 ** Returns void 861 ** 862 *******************************************************************************/ 863 static void btu_hcif_read_rmt_features_comp_evt (UINT8 *p) 864 { 865 btm_read_remote_features_complete(p); 866 } 867 868 /******************************************************************************* 869 ** 870 ** Function btu_hcif_read_rmt_ext_features_comp_evt 871 ** 872 ** Description Process event HCI_READ_RMT_EXT_FEATURES_COMP_EVT 873 ** 874 ** Returns void 875 ** 876 *******************************************************************************/ 877 static void btu_hcif_read_rmt_ext_features_comp_evt (UINT8 *p) 878 { 879 UINT8 *p_cur = p; 880 UINT8 status; 881 UINT16 handle; 882 883 STREAM_TO_UINT8 (status, p_cur); 884 885 if (status == HCI_SUCCESS) 886 btm_read_remote_ext_features_complete(p); 887 else 888 { 889 STREAM_TO_UINT16 (handle, p_cur); 890 btm_read_remote_ext_features_failed(status, handle); 891 } 892 } 893 894 /******************************************************************************* 895 ** 896 ** Function btu_hcif_read_rmt_version_comp_evt 897 ** 898 ** Description Process event HCI_READ_RMT_VERSION_COMP_EVT 899 ** 900 ** Returns void 901 ** 902 *******************************************************************************/ 903 static void btu_hcif_read_rmt_version_comp_evt (UINT8 *p) 904 { 905 btm_read_remote_version_complete (p); 906 } 907 908 909 /******************************************************************************* 910 ** 911 ** Function btu_hcif_qos_setup_comp_evt 912 ** 913 ** Description Process event HCI_QOS_SETUP_COMP_EVT 914 ** 915 ** Returns void 916 ** 917 *******************************************************************************/ 918 static void btu_hcif_qos_setup_comp_evt (UINT8 *p) 919 { 920 UINT8 status; 921 UINT16 handle; 922 FLOW_SPEC flow; 923 924 STREAM_TO_UINT8 (status, p); 925 STREAM_TO_UINT16 (handle, p); 926 STREAM_TO_UINT8 (flow.qos_flags, p); 927 STREAM_TO_UINT8 (flow.service_type, p); 928 STREAM_TO_UINT32 (flow.token_rate, p); 929 STREAM_TO_UINT32 (flow.peak_bandwidth, p); 930 STREAM_TO_UINT32 (flow.latency, p); 931 STREAM_TO_UINT32 (flow.delay_variation, p); 932 933 btm_qos_setup_complete(status, handle, &flow); 934 } 935 936 937 /******************************************************************************* 938 ** 939 ** Function btu_hcif_esco_connection_comp_evt 940 ** 941 ** Description Process event HCI_ESCO_CONNECTION_COMP_EVT 942 ** 943 ** Returns void 944 ** 945 *******************************************************************************/ 946 static void btu_hcif_esco_connection_comp_evt (UINT8 *p) 947 { 948 #if BTM_SCO_INCLUDED == TRUE 949 tBTM_ESCO_DATA data; 950 UINT16 handle; 951 BD_ADDR bda; 952 UINT8 status; 953 954 STREAM_TO_UINT8 (status, p); 955 STREAM_TO_UINT16 (handle, p); 956 STREAM_TO_BDADDR (bda, p); 957 958 STREAM_TO_UINT8 (data.link_type, p); 959 STREAM_TO_UINT8 (data.tx_interval, p); 960 STREAM_TO_UINT8 (data.retrans_window, p); 961 STREAM_TO_UINT16 (data.rx_pkt_len, p); 962 STREAM_TO_UINT16 (data.tx_pkt_len, p); 963 STREAM_TO_UINT8 (data.air_mode, p); 964 965 memcpy (data.bd_addr, bda, BD_ADDR_LEN); 966 btm_sco_connected (status, bda, handle, &data); 967 #endif 968 } 969 970 971 /******************************************************************************* 972 ** 973 ** Function btu_hcif_esco_connection_chg_evt 974 ** 975 ** Description Process event HCI_ESCO_CONNECTION_CHANGED_EVT 976 ** 977 ** Returns void 978 ** 979 *******************************************************************************/ 980 static void btu_hcif_esco_connection_chg_evt (UINT8 *p) 981 { 982 #if BTM_SCO_INCLUDED == TRUE 983 UINT16 handle; 984 UINT16 tx_pkt_len; 985 UINT16 rx_pkt_len; 986 UINT8 status; 987 UINT8 tx_interval; 988 UINT8 retrans_window; 989 990 STREAM_TO_UINT8 (status, p); 991 STREAM_TO_UINT16 (handle, p); 992 993 STREAM_TO_UINT8 (tx_interval, p); 994 STREAM_TO_UINT8 (retrans_window, p); 995 STREAM_TO_UINT16 (rx_pkt_len, p); 996 STREAM_TO_UINT16 (tx_pkt_len, p); 997 998 btm_esco_proc_conn_chg (status, handle, tx_interval, retrans_window, 999 rx_pkt_len, tx_pkt_len); 1000 #endif 1001 } 1002 1003 /******************************************************************************* 1004 ** 1005 ** Function btu_hcif_hdl_command_complete 1006 ** 1007 ** Description Handle command complete event 1008 ** 1009 ** Returns void 1010 ** 1011 *******************************************************************************/ 1012 static void btu_hcif_hdl_command_complete (UINT16 opcode, UINT8 *p, UINT16 evt_len, 1013 void *p_cplt_cback) 1014 { 1015 switch (opcode) 1016 { 1017 case HCI_RESET: 1018 btm_reset_complete (); /* BR/EDR */ 1019 break; 1020 1021 case HCI_INQUIRY_CANCEL: 1022 /* Tell inquiry processing that we are done */ 1023 btm_process_cancel_complete(HCI_SUCCESS, BTM_BR_INQUIRY_MASK); 1024 break; 1025 case HCI_SET_EVENT_FILTER: 1026 btm_event_filter_complete (p); 1027 break; 1028 1029 case HCI_READ_STORED_LINK_KEY: 1030 btm_read_stored_link_key_complete (p); 1031 break; 1032 1033 case HCI_WRITE_STORED_LINK_KEY: 1034 btm_write_stored_link_key_complete (p); 1035 break; 1036 1037 case HCI_DELETE_STORED_LINK_KEY: 1038 btm_delete_stored_link_key_complete (p); 1039 break; 1040 1041 case HCI_READ_LOCAL_VERSION_INFO: 1042 btm_read_local_version_complete (p, evt_len); 1043 break; 1044 1045 case HCI_READ_POLICY_SETTINGS: 1046 btm_read_link_policy_complete (p); 1047 break; 1048 1049 case HCI_READ_BUFFER_SIZE: 1050 btm_read_hci_buf_size_complete (p, evt_len); 1051 break; 1052 1053 case HCI_READ_LOCAL_SUPPORTED_CMDS: 1054 btm_read_local_supported_cmds_complete (p); 1055 break; 1056 1057 case HCI_READ_LOCAL_FEATURES: 1058 btm_read_local_features_complete (p, evt_len); 1059 break; 1060 1061 case HCI_READ_LOCAL_EXT_FEATURES: 1062 btm_read_local_ext_features_complete (p, evt_len); 1063 break; 1064 1065 case HCI_READ_LOCAL_NAME: 1066 btm_read_local_name_complete (p, evt_len); 1067 break; 1068 1069 case HCI_READ_BD_ADDR: 1070 btm_read_local_addr_complete (p, evt_len); 1071 break; 1072 1073 case HCI_GET_LINK_QUALITY: 1074 btm_read_link_quality_complete (p); 1075 break; 1076 1077 case HCI_READ_RSSI: 1078 btm_read_rssi_complete (p); 1079 break; 1080 1081 case HCI_READ_TRANSMIT_POWER_LEVEL: 1082 btm_read_tx_power_complete(p, FALSE); 1083 break; 1084 1085 case HCI_CREATE_CONNECTION_CANCEL: 1086 btm_create_conn_cancel_complete(p); 1087 break; 1088 1089 case HCI_READ_LOCAL_OOB_DATA: 1090 #if BTM_OOB_INCLUDED == TRUE 1091 btm_read_local_oob_complete(p); 1092 #endif 1093 break; 1094 1095 1096 case HCI_READ_INQ_TX_POWER_LEVEL: 1097 btm_read_linq_tx_power_complete (p); 1098 break; 1099 1100 case HCI_WRITE_SIMPLE_PAIRING_MODE: 1101 btm_write_simple_paring_mode_complete (p); 1102 break; 1103 1104 case HCI_WRITE_LE_HOST_SUPPORTED: 1105 btm_write_le_host_supported_complete (p); 1106 break; 1107 1108 #if (BLE_INCLUDED == TRUE) 1109 /* BLE Commands sComplete*/ 1110 case HCI_BLE_READ_WHITE_LIST_SIZE : 1111 btm_read_white_list_size_complete(p, evt_len); 1112 break; 1113 1114 case HCI_BLE_ADD_WHITE_LIST: 1115 btm_ble_add_2_white_list_complete(*p); 1116 break; 1117 1118 case HCI_BLE_CLEAR_WHITE_LIST: 1119 btm_ble_clear_white_list_complete(p, evt_len); 1120 break; 1121 1122 case HCI_BLE_REMOVE_WHITE_LIST: 1123 btm_ble_remove_from_white_list_complete(p, evt_len); 1124 break; 1125 1126 case HCI_BLE_RAND: 1127 case HCI_BLE_ENCRYPT: 1128 btm_ble_rand_enc_complete (p, opcode, (tBTM_RAND_ENC_CB *)p_cplt_cback); 1129 break; 1130 1131 case HCI_BLE_READ_BUFFER_SIZE: 1132 btm_read_ble_buf_size_complete(p, evt_len); 1133 break; 1134 1135 case HCI_BLE_READ_LOCAL_SPT_FEAT: 1136 btm_read_ble_local_supported_features_complete(p, evt_len); 1137 break; 1138 1139 case HCI_BLE_READ_ADV_CHNL_TX_POWER: 1140 btm_read_tx_power_complete(p, TRUE); 1141 break; 1142 1143 case HCI_BLE_WRITE_ADV_ENABLE: 1144 btm_ble_write_adv_enable_complete(p); 1145 break; 1146 1147 case HCI_BLE_READ_SUPPORTED_STATES: 1148 btm_read_ble_local_supported_states_complete(p, evt_len); 1149 break; 1150 1151 case HCI_BLE_CREATE_LL_CONN: 1152 btm_ble_create_ll_conn_complete(*p); 1153 break; 1154 1155 case HCI_BLE_TRANSMITTER_TEST: 1156 case HCI_BLE_RECEIVER_TEST: 1157 case HCI_BLE_TEST_END: 1158 btm_ble_test_command_complete(p); 1159 break; 1160 #endif /* (BLE_INCLUDED == TRUE) */ 1161 1162 default: 1163 if ((opcode & HCI_GRP_VENDOR_SPECIFIC) == HCI_GRP_VENDOR_SPECIFIC) 1164 btm_vsc_complete (p, opcode, evt_len, (tBTM_CMPL_CB *)p_cplt_cback); 1165 break; 1166 } 1167 } 1168 1169 /******************************************************************************* 1170 ** 1171 ** Function btu_hcif_command_complete_evt 1172 ** 1173 ** Description Process event HCI_COMMAND_COMPLETE_EVT 1174 ** 1175 ** Returns void 1176 ** 1177 *******************************************************************************/ 1178 static void btu_hcif_command_complete_evt (UINT8 controller_id, UINT8 *p, UINT16 evt_len) 1179 { 1180 tHCI_CMD_CB *p_hci_cmd_cb = &(btu_cb.hci_cmd_cb[controller_id]); 1181 UINT16 cc_opcode; 1182 BT_HDR *p_cmd; 1183 void *p_cplt_cback = NULL; 1184 1185 STREAM_TO_UINT8 (p_hci_cmd_cb->cmd_window, p); 1186 1187 #if (defined(HCI_MAX_SIMUL_CMDS) && (HCI_MAX_SIMUL_CMDS > 0)) 1188 if (p_hci_cmd_cb->cmd_window > HCI_MAX_SIMUL_CMDS) 1189 p_hci_cmd_cb->cmd_window = HCI_MAX_SIMUL_CMDS; 1190 #endif 1191 1192 STREAM_TO_UINT16 (cc_opcode, p); 1193 1194 evt_len -= 3; 1195 1196 /* only do this for certain commands */ 1197 if ((cc_opcode != HCI_RESET) && (cc_opcode != HCI_HOST_NUM_PACKETS_DONE) && 1198 (cc_opcode != HCI_COMMAND_NONE)) 1199 { 1200 /* dequeue and free stored command */ 1201 1202 /* always use cmd code check, when one cmd timeout waiting for cmd_cmpl, 1203 it'll cause the rest of the command goes in wrong order */ 1204 p_cmd = (BT_HDR *) GKI_getfirst (&p_hci_cmd_cb->cmd_cmpl_q); 1205 1206 while (p_cmd) 1207 { 1208 UINT16 opcode_dequeued; 1209 UINT8 *p_dequeued; 1210 1211 /* Make sure dequeued command is for the command_cplt received */ 1212 p_dequeued = (UINT8 *)(p_cmd + 1) + p_cmd->offset; 1213 STREAM_TO_UINT16 (opcode_dequeued, p_dequeued); 1214 1215 if (opcode_dequeued != cc_opcode) 1216 { 1217 /* opcode does not match, check next command in the queue */ 1218 p_cmd = (BT_HDR *) GKI_getnext(p_cmd); 1219 continue; 1220 } 1221 GKI_remove_from_queue(&p_hci_cmd_cb->cmd_cmpl_q, p_cmd); 1222 1223 /* If command was a VSC, then extract command_complete callback */ 1224 if ((cc_opcode & HCI_GRP_VENDOR_SPECIFIC) == HCI_GRP_VENDOR_SPECIFIC 1225 #if BLE_INCLUDED == TRUE 1226 || (cc_opcode == HCI_BLE_RAND ) 1227 || (cc_opcode == HCI_BLE_ENCRYPT) 1228 #endif 1229 ) 1230 { 1231 p_cplt_cback = *((void **)(p_cmd + 1)); 1232 } 1233 1234 GKI_freebuf (p_cmd); 1235 1236 break; 1237 } 1238 1239 /* if more commands in queue restart timer */ 1240 if (BTU_CMD_CMPL_TIMEOUT > 0) 1241 { 1242 if (!GKI_queue_is_empty (&(p_hci_cmd_cb->cmd_cmpl_q))) 1243 { 1244 #if (defined(BTU_CMD_CMPL_TOUT_DOUBLE_CHECK) && BTU_CMD_CMPL_TOUT_DOUBLE_CHECK == TRUE) 1245 p_hci_cmd_cb->checked_hcisu = FALSE; 1246 #endif 1247 btu_start_timer (&(p_hci_cmd_cb->cmd_cmpl_timer), 1248 (UINT16)(BTU_TTYPE_BTU_CMD_CMPL + controller_id), 1249 BTU_CMD_CMPL_TIMEOUT); 1250 } 1251 else 1252 { 1253 btu_stop_timer (&(p_hci_cmd_cb->cmd_cmpl_timer)); 1254 } 1255 } 1256 } 1257 1258 /* handle event */ 1259 btu_hcif_hdl_command_complete (cc_opcode, p, evt_len, p_cplt_cback); 1260 1261 /* see if we can send more commands */ 1262 btu_hcif_send_cmd (controller_id, NULL); 1263 } 1264 1265 1266 /******************************************************************************* 1267 ** 1268 ** Function btu_hcif_hdl_command_status 1269 ** 1270 ** Description Handle a command status event 1271 ** 1272 ** Returns void 1273 ** 1274 *******************************************************************************/ 1275 static void btu_hcif_hdl_command_status (UINT16 opcode, UINT8 status, UINT8 *p_cmd, 1276 void *p_vsc_status_cback) 1277 { 1278 BD_ADDR bd_addr; 1279 UINT16 handle; 1280 #if BTM_SCO_INCLUDED == TRUE 1281 tBTM_ESCO_DATA esco_data; 1282 #endif 1283 1284 #if BTM_PWR_MGR_INCLUDED == TRUE 1285 switch (opcode) 1286 { 1287 case HCI_EXIT_SNIFF_MODE: 1288 case HCI_EXIT_PARK_MODE: 1289 #if BTM_SCO_WAKE_PARKED_LINK == TRUE 1290 if (status != HCI_SUCCESS) 1291 { 1292 /* Allow SCO initiation to continue if waiting for change mode event */ 1293 if (p_cmd != NULL) 1294 { 1295 p_cmd++; /* bypass length field */ 1296 STREAM_TO_UINT16 (handle, p_cmd); 1297 btm_sco_chk_pend_unpark (status, handle); 1298 } 1299 } 1300 #endif 1301 /* Case Falls Through */ 1302 1303 case HCI_HOLD_MODE: 1304 case HCI_SNIFF_MODE: 1305 case HCI_PARK_MODE: 1306 btm_pm_proc_cmd_status(status); 1307 break; 1308 1309 default: 1310 #endif /* BTM_PWR_MGR_INCLUDED */ 1311 /* If command failed to start, we may need to tell BTM */ 1312 if (status != HCI_SUCCESS) 1313 { 1314 switch (opcode) 1315 { 1316 case HCI_INQUIRY: 1317 /* Tell inquiry processing that we are done */ 1318 btm_process_inq_complete(status, BTM_BR_INQUIRY_MASK); 1319 break; 1320 1321 case HCI_RMT_NAME_REQUEST: 1322 /* Tell inquiry processing that we are done */ 1323 btm_process_remote_name (NULL, NULL, 0, status); 1324 1325 btm_sec_rmt_name_request_complete (NULL, NULL, status); 1326 break; 1327 1328 case HCI_CHANGE_CONN_LINK_KEY: 1329 /* Let host know we're done with error */ 1330 /* read handle out of stored command */ 1331 if (p_cmd != NULL) 1332 { 1333 p_cmd++; 1334 STREAM_TO_UINT16 (handle, p_cmd); 1335 1336 btm_acl_link_key_change (handle, status); 1337 } 1338 break; 1339 1340 case HCI_QOS_SETUP_COMP_EVT: 1341 /* Tell qos setup that we are done */ 1342 btm_qos_setup_complete(status,0,NULL); 1343 break; 1344 1345 case HCI_SWITCH_ROLE: 1346 /* Tell BTM that the command failed */ 1347 /* read bd addr out of stored command */ 1348 if (p_cmd != NULL) 1349 { 1350 p_cmd++; 1351 STREAM_TO_BDADDR (bd_addr, p_cmd); 1352 btm_acl_role_changed(status, bd_addr, BTM_ROLE_UNDEFINED); 1353 } 1354 else 1355 btm_acl_role_changed(status, NULL, BTM_ROLE_UNDEFINED); 1356 l2c_link_role_changed (NULL, BTM_ROLE_UNDEFINED, HCI_ERR_COMMAND_DISALLOWED); 1357 break; 1358 1359 case HCI_CREATE_CONNECTION: 1360 /* read bd addr out of stored command */ 1361 if (p_cmd != NULL) 1362 { 1363 p_cmd++; 1364 STREAM_TO_BDADDR (bd_addr, p_cmd); 1365 btm_sec_connected (bd_addr, HCI_INVALID_HANDLE, status, 0); 1366 l2c_link_hci_conn_comp (status, HCI_INVALID_HANDLE, bd_addr); 1367 } 1368 break; 1369 1370 case HCI_READ_RMT_EXT_FEATURES: 1371 if (p_cmd != NULL) 1372 { 1373 p_cmd++; /* skip command length */ 1374 STREAM_TO_UINT16 (handle, p_cmd); 1375 } 1376 else 1377 handle = HCI_INVALID_HANDLE; 1378 1379 btm_read_remote_ext_features_failed(status, handle); 1380 break; 1381 1382 case HCI_AUTHENTICATION_REQUESTED: 1383 /* Device refused to start authentication. That should be treated as authentication failure. */ 1384 btm_sec_auth_complete (BTM_INVALID_HCI_HANDLE, status); 1385 break; 1386 1387 case HCI_SET_CONN_ENCRYPTION: 1388 /* Device refused to start encryption. That should be treated as encryption failure. */ 1389 btm_sec_encrypt_change (BTM_INVALID_HCI_HANDLE, status, FALSE); 1390 break; 1391 1392 #if BLE_INCLUDED == TRUE 1393 case HCI_BLE_CREATE_LL_CONN: 1394 btm_ble_create_ll_conn_complete(status); 1395 break; 1396 #endif 1397 1398 #if BTM_SCO_INCLUDED == TRUE 1399 case HCI_SETUP_ESCO_CONNECTION: 1400 /* read handle out of stored command */ 1401 if (p_cmd != NULL) 1402 { 1403 p_cmd++; 1404 STREAM_TO_UINT16 (handle, p_cmd); 1405 1406 /* Determine if initial connection failed or is a change of setup */ 1407 if (btm_is_sco_active(handle)) 1408 btm_esco_proc_conn_chg (status, handle, 0, 0, 0, 0); 1409 else 1410 btm_sco_connected (status, NULL, handle, &esco_data); 1411 } 1412 break; 1413 #endif 1414 1415 /* This is commented out until an upper layer cares about returning event 1416 #if L2CAP_NON_FLUSHABLE_PB_INCLUDED == TRUE 1417 case HCI_ENHANCED_FLUSH: 1418 break; 1419 #endif 1420 */ 1421 default: 1422 if ((opcode & HCI_GRP_VENDOR_SPECIFIC) == HCI_GRP_VENDOR_SPECIFIC) 1423 btm_vsc_complete (&status, opcode, 1, (tBTM_CMPL_CB *)p_vsc_status_cback); 1424 break; 1425 } 1426 1427 } 1428 else 1429 { 1430 if ((opcode & HCI_GRP_VENDOR_SPECIFIC) == HCI_GRP_VENDOR_SPECIFIC) 1431 btm_vsc_complete (&status, opcode, 1, (tBTM_CMPL_CB *)p_vsc_status_cback); 1432 } 1433 #if BTM_PWR_MGR_INCLUDED == TRUE 1434 } 1435 #endif 1436 } 1437 1438 /******************************************************************************* 1439 ** 1440 ** Function btu_hcif_command_status_evt 1441 ** 1442 ** Description Process event HCI_COMMAND_STATUS_EVT 1443 ** 1444 ** Returns void 1445 ** 1446 *******************************************************************************/ 1447 static void btu_hcif_command_status_evt (UINT8 controller_id, UINT8 *p) 1448 { 1449 tHCI_CMD_CB * p_hci_cmd_cb = &(btu_cb.hci_cmd_cb[controller_id]); 1450 UINT8 status; 1451 UINT16 opcode; 1452 UINT16 cmd_opcode; 1453 BT_HDR *p_cmd = NULL; 1454 UINT8 *p_data = NULL; 1455 void *p_vsc_status_cback = NULL; 1456 1457 STREAM_TO_UINT8 (status, p); 1458 STREAM_TO_UINT8 (p_hci_cmd_cb->cmd_window, p); 1459 1460 #if (defined(HCI_MAX_SIMUL_CMDS) && (HCI_MAX_SIMUL_CMDS > 0)) 1461 if (p_hci_cmd_cb->cmd_window > HCI_MAX_SIMUL_CMDS) 1462 p_hci_cmd_cb->cmd_window = HCI_MAX_SIMUL_CMDS; 1463 #endif 1464 1465 STREAM_TO_UINT16 (opcode, p); 1466 1467 /* only do this for certain commands */ 1468 if ((opcode != HCI_RESET) && (opcode != HCI_HOST_NUM_PACKETS_DONE) && 1469 (opcode != HCI_COMMAND_NONE)) 1470 { 1471 /*look for corresponding command in cmd_queue*/ 1472 p_cmd = (BT_HDR *) GKI_getfirst(&(p_hci_cmd_cb->cmd_cmpl_q)); 1473 while (p_cmd) 1474 { 1475 p_data = (UINT8 *)(p_cmd + 1) + p_cmd->offset; 1476 STREAM_TO_UINT16 (cmd_opcode, p_data); 1477 1478 /* Make sure this command is for the command_status received */ 1479 if (cmd_opcode != opcode) 1480 { 1481 /* opcode does not match, check next command in the queue */ 1482 p_cmd = (BT_HDR *) GKI_getnext(p_cmd); 1483 continue; 1484 } 1485 else 1486 { 1487 GKI_remove_from_queue(&p_hci_cmd_cb->cmd_cmpl_q, p_cmd); 1488 1489 /* If command was a VSC, then extract command_status callback */ 1490 if ((cmd_opcode & HCI_GRP_VENDOR_SPECIFIC) == HCI_GRP_VENDOR_SPECIFIC) 1491 { 1492 p_vsc_status_cback = *((void **)(p_cmd + 1)); 1493 } 1494 break; 1495 } 1496 } 1497 1498 /* if more commands in queue restart timer */ 1499 if (BTU_CMD_CMPL_TIMEOUT > 0) 1500 { 1501 if (!GKI_queue_is_empty (&(p_hci_cmd_cb->cmd_cmpl_q))) 1502 { 1503 #if (defined(BTU_CMD_CMPL_TOUT_DOUBLE_CHECK) && BTU_CMD_CMPL_TOUT_DOUBLE_CHECK == TRUE) 1504 p_hci_cmd_cb->checked_hcisu = FALSE; 1505 #endif 1506 btu_start_timer (&(p_hci_cmd_cb->cmd_cmpl_timer), 1507 (UINT16)(BTU_TTYPE_BTU_CMD_CMPL + controller_id), 1508 BTU_CMD_CMPL_TIMEOUT); 1509 } 1510 else 1511 { 1512 btu_stop_timer (&(p_hci_cmd_cb->cmd_cmpl_timer)); 1513 } 1514 } 1515 } 1516 1517 /* handle command */ 1518 btu_hcif_hdl_command_status (opcode, status, p_data, p_vsc_status_cback); 1519 1520 /* free stored command */ 1521 if (p_cmd != NULL) 1522 { 1523 GKI_freebuf (p_cmd); 1524 } 1525 else 1526 { 1527 HCI_TRACE_WARNING("No command in queue matching opcode %d", opcode); 1528 } 1529 1530 /* See if we can forward any more commands */ 1531 btu_hcif_send_cmd (controller_id, NULL); 1532 } 1533 1534 /******************************************************************************* 1535 ** 1536 ** Function btu_hcif_cmd_timeout 1537 ** 1538 ** Description Handle a command timeout 1539 ** 1540 ** Returns void 1541 ** 1542 *******************************************************************************/ 1543 void btu_hcif_cmd_timeout (UINT8 controller_id) 1544 { 1545 tHCI_CMD_CB * p_hci_cmd_cb = &(btu_cb.hci_cmd_cb[controller_id]); 1546 BT_HDR *p_cmd; 1547 UINT8 *p; 1548 void *p_cplt_cback = NULL; 1549 UINT16 opcode; 1550 UINT16 event; 1551 1552 #if (defined(BTU_CMD_CMPL_TOUT_DOUBLE_CHECK) && BTU_CMD_CMPL_TOUT_DOUBLE_CHECK == TRUE) 1553 if (!(p_hci_cmd_cb->checked_hcisu)) 1554 { 1555 HCI_TRACE_WARNING("BTU HCI(id=%d) command timeout - double check HCISU", controller_id); 1556 1557 /* trigger HCISU to read any pending data in transport buffer */ 1558 GKI_send_event(HCISU_TASK, HCISU_EVT_MASK); 1559 1560 btu_start_timer (&(p_hci_cmd_cb->cmd_cmpl_timer), 1561 (UINT16)(BTU_TTYPE_BTU_CMD_CMPL + controller_id), 1562 2); /* start short timer, if timer is set to 1 then it could expire before HCISU checks. */ 1563 1564 p_hci_cmd_cb->checked_hcisu = TRUE; 1565 1566 return; 1567 } 1568 #endif 1569 1570 /* set the controller cmd window to 1, as if we received a response, so 1571 ** the flow of commands from the stack doesn't hang */ 1572 p_hci_cmd_cb->cmd_window = 1; 1573 1574 /* get queued command */ 1575 if ((p_cmd = (BT_HDR *) GKI_dequeue (&(p_hci_cmd_cb->cmd_cmpl_q))) == NULL) 1576 { 1577 HCI_TRACE_WARNING("Cmd timeout; no cmd in queue"); 1578 return; 1579 } 1580 1581 /* if more commands in queue restart timer */ 1582 if (BTU_CMD_CMPL_TIMEOUT > 0) 1583 { 1584 if (!GKI_queue_is_empty (&(p_hci_cmd_cb->cmd_cmpl_q))) 1585 { 1586 #if (defined(BTU_CMD_CMPL_TOUT_DOUBLE_CHECK) && BTU_CMD_CMPL_TOUT_DOUBLE_CHECK == TRUE) 1587 p_hci_cmd_cb->checked_hcisu = FALSE; 1588 #endif 1589 btu_start_timer (&(p_hci_cmd_cb->cmd_cmpl_timer), 1590 (UINT16)(BTU_TTYPE_BTU_CMD_CMPL + controller_id), 1591 BTU_CMD_CMPL_TIMEOUT); 1592 } 1593 } 1594 1595 p = (UINT8 *)(p_cmd + 1) + p_cmd->offset; 1596 #if (NFC_INCLUDED == TRUE) 1597 if (controller_id == NFC_CONTROLLER_ID) 1598 { 1599 //TODO call nfc_ncif_cmd_timeout 1600 HCI_TRACE_WARNING("BTU NCI command timeout - header 0x%02x%02x", p[0], p[1]); 1601 return; 1602 } 1603 #endif 1604 1605 /* get opcode from stored command */ 1606 STREAM_TO_UINT16 (opcode, p); 1607 1608 // btla-specific ++ 1609 #if (defined(ANDROID_APP_INCLUDED) && (ANDROID_APP_INCLUDED == TRUE)) 1610 ALOGE("######################################################################"); 1611 ALOGE("#"); 1612 ALOGE("# WARNING : BTU HCI(id=%d) command timeout. opcode=0x%x", controller_id, opcode); 1613 ALOGE("#"); 1614 ALOGE("######################################################################"); 1615 #else 1616 HCI_TRACE_WARNING("BTU HCI(id=%d) command timeout. opcode=0x%x", controller_id, opcode); 1617 #endif 1618 // btla-specific ++ 1619 1620 /* send stack a fake command complete or command status, but first determine 1621 ** which to send 1622 */ 1623 switch (opcode) 1624 { 1625 case HCI_HOLD_MODE: 1626 case HCI_SNIFF_MODE: 1627 case HCI_EXIT_SNIFF_MODE: 1628 case HCI_PARK_MODE: 1629 case HCI_EXIT_PARK_MODE: 1630 case HCI_INQUIRY: 1631 case HCI_RMT_NAME_REQUEST: 1632 case HCI_QOS_SETUP_COMP_EVT: 1633 case HCI_CREATE_CONNECTION: 1634 case HCI_CHANGE_CONN_LINK_KEY: 1635 case HCI_SWITCH_ROLE: 1636 case HCI_READ_RMT_EXT_FEATURES: 1637 case HCI_AUTHENTICATION_REQUESTED: 1638 case HCI_SET_CONN_ENCRYPTION: 1639 #if BTM_SCO_INCLUDED == TRUE 1640 case HCI_SETUP_ESCO_CONNECTION: 1641 #endif 1642 /* fake a command status */ 1643 btu_hcif_hdl_command_status (opcode, HCI_ERR_UNSPECIFIED, p, NULL); 1644 break; 1645 1646 default: 1647 /* If vendor specific restore the callback function */ 1648 if ((opcode & HCI_GRP_VENDOR_SPECIFIC) == HCI_GRP_VENDOR_SPECIFIC 1649 #if BLE_INCLUDED == TRUE 1650 || (opcode == HCI_BLE_RAND ) || 1651 (opcode == HCI_BLE_ENCRYPT) 1652 #endif 1653 ) 1654 { 1655 p_cplt_cback = *((void **)(p_cmd + 1)); 1656 } 1657 1658 /* fake a command complete; first create a fake event */ 1659 event = HCI_ERR_UNSPECIFIED; 1660 btu_hcif_hdl_command_complete (opcode, (UINT8 *)&event, 1, p_cplt_cback); 1661 break; 1662 } 1663 1664 /* free stored command */ 1665 GKI_freebuf(p_cmd); 1666 1667 num_hci_cmds_timed_out++; 1668 /* When we receive consecutive HCI cmd timeouts for >=BTM_MAX_HCI_CMD_TOUT_BEFORE_RESTART 1669 times, Bluetooth process will be killed and restarted */ 1670 if (num_hci_cmds_timed_out >= BTM_MAX_HCI_CMD_TOUT_BEFORE_RESTART) 1671 { 1672 HCI_TRACE_ERROR("Num consecutive HCI Cmd tout =%d Restarting BT process",num_hci_cmds_timed_out); 1673 1674 usleep(10000); /* 10 milliseconds */ 1675 /* Killing the process to force a restart as part of fault tolerance */ 1676 kill(getpid(), SIGKILL); 1677 } 1678 else 1679 { 1680 HCI_TRACE_WARNING("HCI Cmd timeout counter %d", num_hci_cmds_timed_out); 1681 1682 /* If anyone wants device status notifications, give him one */ 1683 btm_report_device_status (BTM_DEV_STATUS_CMD_TOUT); 1684 } 1685 /* See if we can forward any more commands */ 1686 btu_hcif_send_cmd (controller_id, NULL); 1687 } 1688 1689 /******************************************************************************* 1690 ** 1691 ** Function btu_hcif_hardware_error_evt 1692 ** 1693 ** Description Process event HCI_HARDWARE_ERROR_EVT 1694 ** 1695 ** Returns void 1696 ** 1697 *******************************************************************************/ 1698 static void btu_hcif_hardware_error_evt (UINT8 *p) 1699 { 1700 HCI_TRACE_ERROR("Ctlr H/w error event - code:0x%x", *p); 1701 1702 /* If anyone wants device status notifications, give him one. */ 1703 btm_report_device_status (BTM_DEV_STATUS_DOWN); 1704 1705 /* Reset the controller */ 1706 if (BTM_IsDeviceUp()) 1707 BTM_DeviceReset (NULL); 1708 } 1709 1710 1711 /******************************************************************************* 1712 ** 1713 ** Function btu_hcif_flush_occured_evt 1714 ** 1715 ** Description Process event HCI_FLUSH_OCCURED_EVT 1716 ** 1717 ** Returns void 1718 ** 1719 *******************************************************************************/ 1720 static void btu_hcif_flush_occured_evt (void) 1721 { 1722 } 1723 1724 1725 /******************************************************************************* 1726 ** 1727 ** Function btu_hcif_role_change_evt 1728 ** 1729 ** Description Process event HCI_ROLE_CHANGE_EVT 1730 ** 1731 ** Returns void 1732 ** 1733 *******************************************************************************/ 1734 static void btu_hcif_role_change_evt (UINT8 *p) 1735 { 1736 UINT8 status; 1737 BD_ADDR bda; 1738 UINT8 role; 1739 1740 STREAM_TO_UINT8 (status, p); 1741 STREAM_TO_BDADDR (bda, p); 1742 STREAM_TO_UINT8 (role, p); 1743 1744 l2c_link_role_changed (bda, role, status); 1745 btm_acl_role_changed(status, bda, role); 1746 } 1747 1748 1749 /******************************************************************************* 1750 ** 1751 ** Function btu_hcif_num_compl_data_pkts_evt 1752 ** 1753 ** Description Process event HCI_NUM_COMPL_DATA_PKTS_EVT 1754 ** 1755 ** Returns void 1756 ** 1757 *******************************************************************************/ 1758 static void btu_hcif_num_compl_data_pkts_evt (UINT8 *p) 1759 { 1760 /* Process for L2CAP and SCO */ 1761 l2c_link_process_num_completed_pkts (p); 1762 1763 /* Send on to SCO */ 1764 /*?? No SCO for now */ 1765 } 1766 1767 /******************************************************************************* 1768 ** 1769 ** Function btu_hcif_mode_change_evt 1770 ** 1771 ** Description Process event HCI_MODE_CHANGE_EVT 1772 ** 1773 ** Returns void 1774 ** 1775 *******************************************************************************/ 1776 static void btu_hcif_mode_change_evt (UINT8 *p) 1777 { 1778 UINT8 status; 1779 UINT16 handle; 1780 UINT8 current_mode; 1781 UINT16 interval; 1782 1783 STREAM_TO_UINT8 (status, p); 1784 1785 STREAM_TO_UINT16 (handle, p); 1786 STREAM_TO_UINT8 (current_mode, p); 1787 STREAM_TO_UINT16 (interval, p); 1788 #if BTM_PWR_MGR_INCLUDED == TRUE 1789 #if BTM_SCO_WAKE_PARKED_LINK == TRUE 1790 btm_sco_chk_pend_unpark (status, handle); 1791 #endif 1792 btm_pm_proc_mode_change (status, handle, current_mode, interval); 1793 #else 1794 btm_process_mode_change (status, handle, current_mode, interval); 1795 #endif /* BTM_PWR_MGR_INCLUDED == TRUE */ 1796 1797 #if (HID_DEV_INCLUDED == TRUE) && (HID_DEV_PM_INCLUDED == TRUE) 1798 hidd_pm_proc_mode_change( status, current_mode, interval ) ; 1799 #endif 1800 } 1801 1802 /******************************************************************************* 1803 ** 1804 ** Function btu_hcif_ssr_evt 1805 ** 1806 ** Description Process event HCI_SNIFF_SUB_RATE_EVT 1807 ** 1808 ** Returns void 1809 ** 1810 *******************************************************************************/ 1811 #if (BTM_SSR_INCLUDED == TRUE) 1812 static void btu_hcif_ssr_evt (UINT8 *p, UINT16 evt_len) 1813 { 1814 #if (BTM_PWR_MGR_INCLUDED == TRUE) 1815 btm_pm_proc_ssr_evt(p, evt_len); 1816 #endif 1817 } 1818 #endif 1819 1820 1821 /******************************************************************************* 1822 ** 1823 ** Function btu_hcif_return_link_keys_evt 1824 ** 1825 ** Description Process event HCI_RETURN_LINK_KEYS_EVT 1826 ** 1827 ** Returns void 1828 ** 1829 *******************************************************************************/ 1830 1831 static void btu_hcif_return_link_keys_evt (UINT8 *p) 1832 { 1833 UINT8 num_keys; 1834 tBTM_RETURN_LINK_KEYS_EVT *result; 1835 1836 /* get the number of link keys */ 1837 num_keys = *p; 1838 1839 /* If there are no link keys don't call the call back */ 1840 if (!num_keys) 1841 return; 1842 1843 /* Take one extra byte at the beginning to specify event */ 1844 result = (tBTM_RETURN_LINK_KEYS_EVT *)(--p); 1845 result->event = BTM_CB_EVT_RETURN_LINK_KEYS; 1846 1847 /* Call the BTM function to pass the link keys to application */ 1848 btm_return_link_keys_evt (result); 1849 } 1850 1851 1852 /******************************************************************************* 1853 ** 1854 ** Function btu_hcif_pin_code_request_evt 1855 ** 1856 ** Description Process event HCI_PIN_CODE_REQUEST_EVT 1857 ** 1858 ** Returns void 1859 ** 1860 *******************************************************************************/ 1861 static void btu_hcif_pin_code_request_evt (UINT8 *p) 1862 { 1863 BD_ADDR bda; 1864 1865 STREAM_TO_BDADDR (bda, p); 1866 1867 /* Tell L2CAP that there was a PIN code request, */ 1868 /* it may need to stretch timeouts */ 1869 l2c_pin_code_request (bda); 1870 1871 btm_sec_pin_code_request (bda); 1872 } 1873 1874 1875 /******************************************************************************* 1876 ** 1877 ** Function btu_hcif_link_key_request_evt 1878 ** 1879 ** Description Process event HCI_LINK_KEY_REQUEST_EVT 1880 ** 1881 ** Returns void 1882 ** 1883 *******************************************************************************/ 1884 static void btu_hcif_link_key_request_evt (UINT8 *p) 1885 { 1886 BD_ADDR bda; 1887 1888 STREAM_TO_BDADDR (bda, p); 1889 btm_sec_link_key_request (bda); 1890 } 1891 1892 1893 /******************************************************************************* 1894 ** 1895 ** Function btu_hcif_link_key_notification_evt 1896 ** 1897 ** Description Process event HCI_LINK_KEY_NOTIFICATION_EVT 1898 ** 1899 ** Returns void 1900 ** 1901 *******************************************************************************/ 1902 static void btu_hcif_link_key_notification_evt (UINT8 *p) 1903 { 1904 BD_ADDR bda; 1905 LINK_KEY key; 1906 UINT8 key_type; 1907 1908 STREAM_TO_BDADDR (bda, p); 1909 STREAM_TO_ARRAY16 (key, p); 1910 STREAM_TO_UINT8 (key_type, p); 1911 1912 btm_sec_link_key_notification (bda, key, key_type); 1913 } 1914 1915 1916 /******************************************************************************* 1917 ** 1918 ** Function btu_hcif_loopback_command_evt 1919 ** 1920 ** Description Process event HCI_LOOPBACK_COMMAND_EVT 1921 ** 1922 ** Returns void 1923 ** 1924 *******************************************************************************/ 1925 static void btu_hcif_loopback_command_evt (void) 1926 { 1927 } 1928 1929 1930 /******************************************************************************* 1931 ** 1932 ** Function btu_hcif_data_buf_overflow_evt 1933 ** 1934 ** Description Process event HCI_DATA_BUF_OVERFLOW_EVT 1935 ** 1936 ** Returns void 1937 ** 1938 *******************************************************************************/ 1939 static void btu_hcif_data_buf_overflow_evt (void) 1940 { 1941 } 1942 1943 1944 /******************************************************************************* 1945 ** 1946 ** Function btu_hcif_max_slots_changed_evt 1947 ** 1948 ** Description Process event HCI_MAX_SLOTS_CHANGED_EVT 1949 ** 1950 ** Returns void 1951 ** 1952 *******************************************************************************/ 1953 static void btu_hcif_max_slots_changed_evt (void) 1954 { 1955 } 1956 1957 1958 /******************************************************************************* 1959 ** 1960 ** Function btu_hcif_read_clock_off_comp_evt 1961 ** 1962 ** Description Process event HCI_READ_CLOCK_OFF_COMP_EVT 1963 ** 1964 ** Returns void 1965 ** 1966 *******************************************************************************/ 1967 static void btu_hcif_read_clock_off_comp_evt (UINT8 *p) 1968 { 1969 UINT8 status; 1970 UINT16 handle; 1971 UINT16 clock_offset; 1972 1973 STREAM_TO_UINT8 (status, p); 1974 1975 /* If failed to get clock offset just drop the result */ 1976 if (status != HCI_SUCCESS) 1977 return; 1978 1979 STREAM_TO_UINT16 (handle, p); 1980 STREAM_TO_UINT16 (clock_offset, p); 1981 1982 handle = HCID_GET_HANDLE (handle); 1983 1984 btm_process_clk_off_comp_evt (handle, clock_offset); 1985 btm_sec_update_clock_offset (handle, clock_offset); 1986 } 1987 1988 1989 /******************************************************************************* 1990 ** 1991 ** Function btu_hcif_conn_pkt_type_change_evt 1992 ** 1993 ** Description Process event HCI_CONN_PKT_TYPE_CHANGE_EVT 1994 ** 1995 ** Returns void 1996 ** 1997 *******************************************************************************/ 1998 static void btu_hcif_conn_pkt_type_change_evt (void) 1999 { 2000 } 2001 2002 2003 /******************************************************************************* 2004 ** 2005 ** Function btu_hcif_qos_violation_evt 2006 ** 2007 ** Description Process event HCI_QOS_VIOLATION_EVT 2008 ** 2009 ** Returns void 2010 ** 2011 *******************************************************************************/ 2012 static void btu_hcif_qos_violation_evt (UINT8 *p) 2013 { 2014 UINT16 handle; 2015 2016 STREAM_TO_UINT16 (handle, p); 2017 2018 handle = HCID_GET_HANDLE (handle); 2019 2020 2021 l2c_link_hci_qos_violation (handle); 2022 } 2023 2024 2025 /******************************************************************************* 2026 ** 2027 ** Function btu_hcif_page_scan_mode_change_evt 2028 ** 2029 ** Description Process event HCI_PAGE_SCAN_MODE_CHANGE_EVT 2030 ** 2031 ** Returns void 2032 ** 2033 *******************************************************************************/ 2034 static void btu_hcif_page_scan_mode_change_evt (void) 2035 { 2036 } 2037 2038 2039 /******************************************************************************* 2040 ** 2041 ** Function btu_hcif_page_scan_rep_mode_chng_evt 2042 ** 2043 ** Description Process event HCI_PAGE_SCAN_REP_MODE_CHNG_EVT 2044 ** 2045 ** Returns void 2046 ** 2047 *******************************************************************************/ 2048 static void btu_hcif_page_scan_rep_mode_chng_evt (void) 2049 { 2050 } 2051 2052 /********************************************** 2053 ** Simple Pairing Events 2054 ***********************************************/ 2055 2056 /******************************************************************************* 2057 ** 2058 ** Function btu_hcif_host_support_evt 2059 ** 2060 ** Description Process event HCI_RMT_HOST_SUP_FEAT_NOTIFY_EVT 2061 ** 2062 ** Returns void 2063 ** 2064 *******************************************************************************/ 2065 static void btu_hcif_host_support_evt (UINT8 *p) 2066 { 2067 btm_sec_rmt_host_support_feat_evt(p); 2068 } 2069 2070 /******************************************************************************* 2071 ** 2072 ** Function btu_hcif_io_cap_request_evt 2073 ** 2074 ** Description Process event HCI_IO_CAPABILITY_REQUEST_EVT 2075 ** 2076 ** Returns void 2077 ** 2078 *******************************************************************************/ 2079 static void btu_hcif_io_cap_request_evt (UINT8 *p) 2080 { 2081 btm_io_capabilities_req(p); 2082 } 2083 2084 2085 /******************************************************************************* 2086 ** 2087 ** Function btu_hcif_io_cap_response_evt 2088 ** 2089 ** Description Process event HCI_IO_CAPABILITY_RESPONSE_EVT 2090 ** 2091 ** Returns void 2092 ** 2093 *******************************************************************************/ 2094 static void btu_hcif_io_cap_response_evt (UINT8 *p) 2095 { 2096 btm_io_capabilities_rsp(p); 2097 } 2098 2099 2100 /******************************************************************************* 2101 ** 2102 ** Function btu_hcif_user_conf_request_evt 2103 ** 2104 ** Description Process event HCI_USER_CONFIRMATION_REQUEST_EVT 2105 ** 2106 ** Returns void 2107 ** 2108 *******************************************************************************/ 2109 static void btu_hcif_user_conf_request_evt (UINT8 *p) 2110 { 2111 btm_proc_sp_req_evt(BTM_SP_CFM_REQ_EVT, p); 2112 } 2113 2114 2115 /******************************************************************************* 2116 ** 2117 ** Function btu_hcif_user_passkey_request_evt 2118 ** 2119 ** Description Process event HCI_USER_PASSKEY_REQUEST_EVT 2120 ** 2121 ** Returns void 2122 ** 2123 *******************************************************************************/ 2124 static void btu_hcif_user_passkey_request_evt (UINT8 *p) 2125 { 2126 btm_proc_sp_req_evt(BTM_SP_KEY_REQ_EVT, p); 2127 } 2128 2129 /******************************************************************************* 2130 ** 2131 ** Function btu_hcif_user_passkey_notif_evt 2132 ** 2133 ** Description Process event HCI_USER_PASSKEY_NOTIFY_EVT 2134 ** 2135 ** Returns void 2136 ** 2137 *******************************************************************************/ 2138 static void btu_hcif_user_passkey_notif_evt (UINT8 *p) 2139 { 2140 btm_proc_sp_req_evt(BTM_SP_KEY_NOTIF_EVT, p); 2141 } 2142 2143 /******************************************************************************* 2144 ** 2145 ** Function btu_hcif_keypress_notif_evt 2146 ** 2147 ** Description Process event HCI_KEYPRESS_NOTIFY_EVT 2148 ** 2149 ** Returns void 2150 ** 2151 *******************************************************************************/ 2152 static void btu_hcif_keypress_notif_evt (UINT8 *p) 2153 { 2154 btm_keypress_notif_evt(p); 2155 } 2156 2157 /******************************************************************************* 2158 ** 2159 ** Function btu_hcif_link_super_tout_evt 2160 ** 2161 ** Description Process event HCI_LINK_SUPER_TOUT_CHANGED_EVT 2162 ** 2163 ** Returns void 2164 ** 2165 *******************************************************************************/ 2166 static void btu_hcif_link_super_tout_evt (UINT8 *p) 2167 { 2168 UINT16 handle, timeout; 2169 STREAM_TO_UINT16 (handle, p); 2170 STREAM_TO_UINT16 (timeout, p); 2171 2172 btm_proc_lsto_evt(handle, timeout); 2173 } 2174 2175 /******************************************************************************* 2176 ** 2177 ** Function btu_hcif_rem_oob_request_evt 2178 ** 2179 ** Description Process event HCI_REMOTE_OOB_DATA_REQUEST_EVT 2180 ** 2181 ** Returns void 2182 ** 2183 *******************************************************************************/ 2184 #if BTM_OOB_INCLUDED == TRUE 2185 static void btu_hcif_rem_oob_request_evt (UINT8 *p) 2186 { 2187 btm_rem_oob_req(p); 2188 } 2189 #endif 2190 2191 /******************************************************************************* 2192 ** 2193 ** Function btu_hcif_simple_pair_complete_evt 2194 ** 2195 ** Description Process event HCI_SIMPLE_PAIRING_COMPLETE_EVT 2196 ** 2197 ** Returns void 2198 ** 2199 *******************************************************************************/ 2200 static void btu_hcif_simple_pair_complete_evt (UINT8 *p) 2201 { 2202 btm_simple_pair_complete(p); 2203 } 2204 /******************************************************************************* 2205 ** 2206 ** Function btu_hcif_flush_cmd_queue 2207 ** 2208 ** Description Flush the HCI command complete queue and transmit queue when 2209 ** needed. 2210 ** 2211 ** Returns void 2212 ** 2213 *******************************************************************************/ 2214 void btu_hcif_flush_cmd_queue(void) 2215 { 2216 BT_HDR *p_cmd; 2217 2218 btu_cb.hci_cmd_cb[0].cmd_window = 0; 2219 while ((p_cmd = (BT_HDR *) GKI_dequeue (&btu_cb.hci_cmd_cb[0].cmd_cmpl_q)) != NULL) 2220 { 2221 GKI_freebuf (p_cmd); 2222 } 2223 while ((p_cmd = (BT_HDR *) GKI_dequeue (&btu_cb.hci_cmd_cb[0].cmd_xmit_q)) != NULL) 2224 { 2225 GKI_freebuf (p_cmd); 2226 } 2227 } 2228 2229 /******************************************************************************* 2230 ** 2231 ** Function btu_hcif_enhanced_flush_complete_evt 2232 ** 2233 ** Description Process event HCI_ENHANCED_FLUSH_COMPLETE_EVT 2234 ** 2235 ** Returns void 2236 ** 2237 *******************************************************************************/ 2238 #if L2CAP_NON_FLUSHABLE_PB_INCLUDED == TRUE 2239 static void btu_hcif_enhanced_flush_complete_evt (void) 2240 { 2241 /* This is empty until an upper layer cares about returning event */ 2242 } 2243 #endif 2244 /********************************************** 2245 ** End of Simple Pairing Events 2246 ***********************************************/ 2247 2248 2249 /********************************************** 2250 ** BLE Events 2251 ***********************************************/ 2252 #if (defined BLE_INCLUDED) && (BLE_INCLUDED == TRUE) 2253 static void btu_hcif_encryption_key_refresh_cmpl_evt (UINT8 *p) 2254 { 2255 UINT8 status; 2256 UINT8 enc_enable = 0; 2257 UINT16 handle; 2258 2259 STREAM_TO_UINT8 (status, p); 2260 STREAM_TO_UINT16 (handle, p); 2261 2262 if (status == HCI_SUCCESS) enc_enable = 1; 2263 2264 btm_sec_encrypt_change (handle, status, enc_enable); 2265 } 2266 2267 static void btu_ble_process_adv_pkt (UINT8 *p) 2268 { 2269 HCI_TRACE_EVENT("btu_ble_process_adv_pkt"); 2270 2271 btm_ble_process_adv_pkt(p); 2272 } 2273 2274 static void btu_ble_ll_conn_complete_evt ( UINT8 *p, UINT16 evt_len) 2275 { 2276 btm_ble_conn_complete(p, evt_len); 2277 } 2278 2279 static void btu_ble_ll_conn_param_upd_evt (UINT8 *p, UINT16 evt_len) 2280 { 2281 /* LE connection update has completed successfully as a master. */ 2282 /* We can enable the update request if the result is a success. */ 2283 /* extract the HCI handle first */ 2284 UINT8 status; 2285 UINT16 handle; 2286 2287 STREAM_TO_UINT8 (status, p); 2288 STREAM_TO_UINT16 (handle, p); 2289 l2cble_process_conn_update_evt(handle, status); 2290 } 2291 2292 static void btu_ble_read_remote_feat_evt (UINT8 *p) 2293 { 2294 btm_ble_read_remote_features_complete(p); 2295 } 2296 2297 static void btu_ble_proc_ltk_req (UINT8 *p) 2298 { 2299 UINT16 ediv, handle; 2300 UINT8 *pp; 2301 2302 STREAM_TO_UINT16(handle, p); 2303 pp = p + 8; 2304 STREAM_TO_UINT16(ediv, pp); 2305 #if BLE_INCLUDED == TRUE && SMP_INCLUDED == TRUE 2306 btm_ble_ltk_request(handle, p, ediv); 2307 #endif 2308 /* This is empty until an upper layer cares about returning event */ 2309 } 2310 /********************************************** 2311 ** End of BLE Events Handler 2312 ***********************************************/ 2313 #if (defined BLE_LLT_INCLUDED) && (BLE_LLT_INCLUDED == TRUE) 2314 static void btu_ble_rc_param_req_evt(UINT8 *p) 2315 { 2316 UINT16 handle; 2317 UINT16 int_min, int_max, latency, timeout; 2318 2319 STREAM_TO_UINT16(handle, p); 2320 STREAM_TO_UINT16(int_min, p); 2321 STREAM_TO_UINT16(int_max, p); 2322 STREAM_TO_UINT16(latency, p); 2323 STREAM_TO_UINT16(timeout, p); 2324 2325 l2cble_process_rc_param_request_evt(handle, int_min, int_max, latency, timeout); 2326 } 2327 #endif /* BLE_LLT_INCLUDED */ 2328 2329 #endif /* BLE_INCLUDED */ 2330 2331
