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