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