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 40extern void btm_process_cancel_complete(UINT8 status, UINT8 mode); 41extern 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 61static 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/********************************************************************************/ 66static void btu_hcif_inquiry_comp_evt (UINT8 *p); 67static void btu_hcif_inquiry_result_evt (UINT8 *p); 68static void btu_hcif_inquiry_rssi_result_evt (UINT8 *p); 69#if (BTM_EIR_CLIENT_INCLUDED == TRUE) 70static void btu_hcif_extended_inquiry_result_evt (UINT8 *p); 71#endif 72 73static void btu_hcif_connection_comp_evt (UINT8 *p); 74static void btu_hcif_connection_request_evt (UINT8 *p); 75static void btu_hcif_disconnection_comp_evt (UINT8 *p); 76static void btu_hcif_authentication_comp_evt (UINT8 *p); 77static void btu_hcif_rmt_name_request_comp_evt (UINT8 *p, UINT16 evt_len); 78static void btu_hcif_encryption_change_evt (UINT8 *p); 79static void btu_hcif_change_conn_link_key_evt (UINT8 *p); 80static void btu_hcif_master_link_key_comp_evt (UINT8 *p); 81static void btu_hcif_read_rmt_features_comp_evt (UINT8 *p); 82static void btu_hcif_read_rmt_ext_features_comp_evt (UINT8 *p); 83static void btu_hcif_read_rmt_version_comp_evt (UINT8 *p); 84static void btu_hcif_qos_setup_comp_evt (UINT8 *p); 85static void btu_hcif_command_complete_evt (UINT8 controller_id, UINT8 *p, UINT16 evt_len); 86static void btu_hcif_command_status_evt (UINT8 controller_id, UINT8 *p); 87static void btu_hcif_hardware_error_evt (UINT8 *p); 88static void btu_hcif_flush_occured_evt (void); 89static void btu_hcif_role_change_evt (UINT8 *p); 90static void btu_hcif_num_compl_data_pkts_evt (UINT8 *p); 91static void btu_hcif_mode_change_evt (UINT8 *p); 92static void btu_hcif_return_link_keys_evt (UINT8 *p); 93static void btu_hcif_pin_code_request_evt (UINT8 *p); 94static void btu_hcif_link_key_request_evt (UINT8 *p); 95static void btu_hcif_link_key_notification_evt (UINT8 *p); 96static void btu_hcif_loopback_command_evt (void); 97static void btu_hcif_data_buf_overflow_evt (void); 98static void btu_hcif_max_slots_changed_evt (void); 99static void btu_hcif_read_clock_off_comp_evt (UINT8 *p); 100static void btu_hcif_conn_pkt_type_change_evt (void); 101static void btu_hcif_qos_violation_evt (UINT8 *p); 102static void btu_hcif_page_scan_mode_change_evt (void); 103static void btu_hcif_page_scan_rep_mode_chng_evt (void); 104static void btu_hcif_esco_connection_comp_evt(UINT8 *p); 105static void btu_hcif_esco_connection_chg_evt(UINT8 *p); 106 107/* Simple Pairing Events */ 108static void btu_hcif_host_support_evt (UINT8 *p); 109static void btu_hcif_io_cap_request_evt (UINT8 *p); 110static void btu_hcif_io_cap_response_evt (UINT8 *p); 111static void btu_hcif_user_conf_request_evt (UINT8 *p); 112static void btu_hcif_user_passkey_request_evt (UINT8 *p); 113static void btu_hcif_user_passkey_notif_evt (UINT8 *p); 114static void btu_hcif_keypress_notif_evt (UINT8 *p); 115static void btu_hcif_link_super_tout_evt (UINT8 *p); 116 117 #if BTM_OOB_INCLUDED == TRUE 118static void btu_hcif_rem_oob_request_evt (UINT8 *p); 119 #endif 120 121static void btu_hcif_simple_pair_complete_evt (UINT8 *p); 122 #if L2CAP_NON_FLUSHABLE_PB_INCLUDED == TRUE 123static void btu_hcif_enhanced_flush_complete_evt (void); 124 #endif 125 126 #if (BTM_SSR_INCLUDED == TRUE) 127static 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) 131extern void hidd_pm_proc_mode_change( UINT8 hci_status, UINT8 mode, UINT16 interval ); 132 #endif 133 134 135 #if BLE_INCLUDED == TRUE 136static void btu_ble_ll_conn_complete_evt (UINT8 *p, UINT16 evt_len); 137static void btu_ble_process_adv_pkt (UINT8 *p); 138static void btu_ble_read_remote_feat_evt (UINT8 *p); 139static void btu_ble_ll_conn_param_upd_evt (UINT8 *p, UINT16 evt_len); 140static void btu_ble_proc_ltk_req (UINT8 *p); 141static void btu_hcif_encryption_key_refresh_cmpl_evt (UINT8 *p); 142#if (BLE_LLT_INCLUDED == TRUE) 143static 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*******************************************************************************/ 157static 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*******************************************************************************/ 228void 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*******************************************************************************/ 453void 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*******************************************************************************/ 542void 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*******************************************************************************/ 569static 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*******************************************************************************/ 589static 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*******************************************************************************/ 604static 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) 620static 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*******************************************************************************/ 636static 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*******************************************************************************/ 682static 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*******************************************************************************/ 716static 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*******************************************************************************/ 749static 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*******************************************************************************/ 770static 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*******************************************************************************/ 795static 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*******************************************************************************/ 819static 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*******************************************************************************/ 840static 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*******************************************************************************/ 863static 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*******************************************************************************/ 877static 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*******************************************************************************/ 903static 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*******************************************************************************/ 918static 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*******************************************************************************/ 946static 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*******************************************************************************/ 980static 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*******************************************************************************/ 1012static 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*******************************************************************************/ 1178static 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*******************************************************************************/ 1275static 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*******************************************************************************/ 1447static 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*******************************************************************************/ 1543void 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*******************************************************************************/ 1698static 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*******************************************************************************/ 1720static 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*******************************************************************************/ 1734static 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*******************************************************************************/ 1758static 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*******************************************************************************/ 1776static 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) 1812static 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 1831static 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*******************************************************************************/ 1861static 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*******************************************************************************/ 1884static 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*******************************************************************************/ 1902static 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*******************************************************************************/ 1925static 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*******************************************************************************/ 1939static 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*******************************************************************************/ 1953static 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*******************************************************************************/ 1967static 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*******************************************************************************/ 1998static 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*******************************************************************************/ 2012static 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*******************************************************************************/ 2034static 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*******************************************************************************/ 2048static 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*******************************************************************************/ 2065static 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*******************************************************************************/ 2079static 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*******************************************************************************/ 2094static 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*******************************************************************************/ 2109static 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*******************************************************************************/ 2124static 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*******************************************************************************/ 2138static 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*******************************************************************************/ 2152static 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*******************************************************************************/ 2166static 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 2185static 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*******************************************************************************/ 2200static 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*******************************************************************************/ 2214void 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 2239static 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) 2253static 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 2267static 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 2274static void btu_ble_ll_conn_complete_evt ( UINT8 *p, UINT16 evt_len) 2275{ 2276 btm_ble_conn_complete(p, evt_len); 2277} 2278 2279static 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 2292static void btu_ble_read_remote_feat_evt (UINT8 *p) 2293{ 2294 btm_ble_read_remote_features_complete(p); 2295} 2296 2297static 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) 2314static 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