1 /******************************************************************************
2 *
3 * Copyright 2005-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 the HID host action functions.
22 *
23 ******************************************************************************/
24
25 #include "bt_target.h"
26
27 #if (BTA_HH_INCLUDED == TRUE)
28
29 #include <log/log.h>
30 #include <string.h>
31
32 #include "bta_hh_co.h"
33 #include "bta_hh_int.h"
34 #include "bta_sys.h"
35 #include "btm_api.h"
36 #include "l2c_api.h"
37 #include "osi/include/osi.h"
38 #include "utl.h"
39
40 /*****************************************************************************
41 * Constants
42 ****************************************************************************/
43
44 /*****************************************************************************
45 * Local Function prototypes
46 ****************************************************************************/
47 static void bta_hh_cback(uint8_t dev_handle, const RawAddress& addr,
48 uint8_t event, uint32_t data, BT_HDR* pdata);
49 static tBTA_HH_STATUS bta_hh_get_trans_status(uint32_t result);
50
51 #if (BTA_HH_DEBUG == TRUE)
52 static const char* bta_hh_get_w4_event(uint16_t event);
53 static const char* bta_hh_hid_event_name(uint16_t event);
54 #endif
55
56 /*****************************************************************************
57 * Action Functions
58 ****************************************************************************/
59 /*******************************************************************************
60 *
61 * Function bta_hh_api_enable
62 *
63 * Description Perform necessary operations to enable HID host.
64 *
65 *
66 * Returns void
67 *
68 ******************************************************************************/
bta_hh_api_enable(tBTA_HH_DATA * p_data)69 void bta_hh_api_enable(tBTA_HH_DATA* p_data) {
70 tBTA_HH_STATUS status = BTA_HH_ERR;
71 uint8_t xx;
72
73 /* initialize BTE HID */
74 HID_HostInit();
75
76 memset(&bta_hh_cb, 0, sizeof(tBTA_HH_CB));
77
78 HID_HostSetSecurityLevel("", p_data->api_enable.sec_mask);
79
80 /* Register with L2CAP */
81 if (HID_HostRegister(bta_hh_cback) == HID_SUCCESS) {
82 /* store parameters */
83 bta_hh_cb.p_cback = p_data->api_enable.p_cback;
84
85 status = BTA_HH_OK;
86 /* initialize device CB */
87 for (xx = 0; xx < BTA_HH_MAX_DEVICE; xx++) {
88 bta_hh_cb.kdev[xx].state = BTA_HH_IDLE_ST;
89 bta_hh_cb.kdev[xx].hid_handle = BTA_HH_INVALID_HANDLE;
90 bta_hh_cb.kdev[xx].index = xx;
91 }
92
93 /* initialize control block map */
94 for (xx = 0; xx < BTA_HH_MAX_KNOWN; xx++)
95 bta_hh_cb.cb_index[xx] = BTA_HH_IDX_INVALID;
96 }
97
98 #if (BTA_HH_LE_INCLUDED == TRUE)
99 if (status == BTA_HH_OK) {
100 bta_hh_le_enable();
101 } else
102 #endif
103 {
104 /* signal BTA call back event */
105 tBTA_HH bta_hh;
106 bta_hh.status = status;
107 (*bta_hh_cb.p_cback)(BTA_HH_ENABLE_EVT, &bta_hh);
108 }
109 }
110 /*******************************************************************************
111 *
112 * Function bta_hh_api_disable
113 *
114 * Description Perform necessary operations to disable HID host.
115 *
116 *
117 * Returns void
118 *
119 ******************************************************************************/
bta_hh_api_disable(void)120 void bta_hh_api_disable(void) {
121 uint8_t xx;
122
123 /* service is not enabled */
124 if (bta_hh_cb.p_cback == NULL) return;
125
126 /* no live connection, signal DISC_CMPL_EVT directly */
127 if (!bta_hh_cb.cnt_num) {
128 bta_hh_disc_cmpl();
129 } else /* otherwise, disconnect all live connections */
130 {
131 bta_hh_cb.w4_disable = true;
132
133 for (xx = 0; xx < BTA_HH_MAX_DEVICE; xx++) {
134 /* send API_CLOSE event to every connected device */
135 if (bta_hh_cb.kdev[xx].state == BTA_HH_CONN_ST) {
136 /* disconnect all connected devices */
137 bta_hh_sm_execute(&bta_hh_cb.kdev[xx], BTA_HH_API_CLOSE_EVT, NULL);
138 }
139 }
140 }
141
142 return;
143 }
144
145 /*******************************************************************************
146 *
147 * Function bta_hh_disc_cmpl
148 *
149 * Description All connections have been closed, disable service.
150 *
151 *
152 * Returns void
153 *
154 ******************************************************************************/
bta_hh_disc_cmpl(void)155 void bta_hh_disc_cmpl(void) {
156 #if (BTA_HH_LE_INCLUDED == TRUE)
157 HID_HostDeregister();
158 bta_hh_le_deregister();
159 #else
160 tBTA_HH_STATUS status = BTA_HH_OK;
161
162 /* Deregister with lower layer */
163 if (HID_HostDeregister() != HID_SUCCESS) status = BTA_HH_ERR;
164
165 bta_hh_cleanup_disable(status);
166 #endif
167 }
168
169 /*******************************************************************************
170 *
171 * Function bta_hh_sdp_cback
172 *
173 * Description SDP callback function.
174 *
175 * Returns void
176 *
177 ******************************************************************************/
bta_hh_sdp_cback(uint16_t result,uint16_t attr_mask,tHID_DEV_SDP_INFO * sdp_rec)178 static void bta_hh_sdp_cback(uint16_t result, uint16_t attr_mask,
179 tHID_DEV_SDP_INFO* sdp_rec) {
180 tBTA_HH_DEV_CB* p_cb = bta_hh_cb.p_cur;
181 uint8_t hdl = 0;
182 tBTA_HH_STATUS status = BTA_HH_ERR_SDP;
183
184 /* make sure sdp succeeded and hh has not been disabled */
185 if ((result == SDP_SUCCESS) && (p_cb != NULL)) {
186 /* security is required for the connection, add attr_mask bit*/
187 if (p_cb->sec_mask) attr_mask |= HID_SEC_REQUIRED;
188
189 #if (BTA_HH_DEBUG == TRUE)
190 APPL_TRACE_EVENT("%s: p_cb: %d result 0x%02x, attr_mask 0x%02x, handle %x",
191 __func__, p_cb, result, attr_mask, p_cb->hid_handle);
192 #endif
193
194 /* check to see type of device is supported , and should not been added
195 * before */
196 if (bta_hh_tod_spt(p_cb, sdp_rec->sub_class)) {
197 /* if not added before */
198 if (p_cb->hid_handle == BTA_HH_INVALID_HANDLE) {
199 /* add device/update attr_mask information */
200 if (HID_HostAddDev(p_cb->addr, attr_mask, &hdl) == HID_SUCCESS) {
201 status = BTA_HH_OK;
202 /* update cb_index[] map */
203 bta_hh_cb.cb_index[hdl] = p_cb->index;
204 } else {
205 p_cb->app_id = 0;
206 }
207 } else {
208 hdl = p_cb->hid_handle;
209 }
210 /* else : incoming connection after SDP should update the SDP information
211 * as well */
212
213 if (p_cb->app_id != 0) {
214 /* update cb information with attr_mask, dscp_info etc. */
215 bta_hh_add_device_to_list(p_cb, hdl, attr_mask, &sdp_rec->dscp_info,
216 sdp_rec->sub_class, sdp_rec->ssr_max_latency,
217 sdp_rec->ssr_min_tout, p_cb->app_id);
218
219 p_cb->dscp_info.ctry_code = sdp_rec->ctry_code;
220
221 status = BTA_HH_OK;
222 }
223
224 } else /* type of device is not supported */
225 status = BTA_HH_ERR_TOD_UNSPT;
226 }
227
228 /* free disc_db when SDP is completed */
229 osi_free_and_reset((void**)&bta_hh_cb.p_disc_db);
230
231 /* send SDP_CMPL_EVT into state machine */
232 tBTA_HH_DATA bta_hh_data;
233 bta_hh_data.status = status;
234 bta_hh_sm_execute(p_cb, BTA_HH_SDP_CMPL_EVT, &bta_hh_data);
235
236 return;
237 }
238 /*******************************************************************************
239 *
240 * Function bta_hh_di_sdp_cback
241 *
242 * Description SDP DI callback function.
243 *
244 * Returns void
245 *
246 ******************************************************************************/
bta_hh_di_sdp_cback(uint16_t result)247 static void bta_hh_di_sdp_cback(uint16_t result) {
248 tBTA_HH_DEV_CB* p_cb = bta_hh_cb.p_cur;
249 tBTA_HH_STATUS status = BTA_HH_ERR_SDP;
250 tSDP_DI_GET_RECORD di_rec;
251 tHID_STATUS ret;
252 #if (BTA_HH_DEBUG == TRUE)
253 APPL_TRACE_EVENT("%s: p_cb: %d result 0x%02x", __func__, p_cb, result);
254 #endif
255
256 /* if DI record does not exist on remote device, vendor_id in
257 * tBTA_HH_DEV_DSCP_INFO will be set to 0xffff and we will allow the
258 * connection to go through. Spec mandates that DI record be set, but many
259 * HID devices do not set this. So for IOP purposes, we allow the connection
260 * to go through and update the DI record to invalid DI entry.
261 */
262 if (((result == SDP_SUCCESS) || (result == SDP_NO_RECS_MATCH)) &&
263 (p_cb != NULL)) {
264 if (result == SDP_SUCCESS &&
265 SDP_GetNumDiRecords(bta_hh_cb.p_disc_db) != 0) {
266 /* always update information with primary DI record */
267 if (SDP_GetDiRecord(1, &di_rec, bta_hh_cb.p_disc_db) == SDP_SUCCESS) {
268 bta_hh_update_di_info(p_cb, di_rec.rec.vendor, di_rec.rec.product,
269 di_rec.rec.version, 0);
270 }
271
272 } else /* no DI recrod available */
273 {
274 bta_hh_update_di_info(p_cb, BTA_HH_VENDOR_ID_INVALID, 0, 0, 0);
275 }
276
277 ret = HID_HostGetSDPRecord(p_cb->addr, bta_hh_cb.p_disc_db,
278 p_bta_hh_cfg->sdp_db_size, bta_hh_sdp_cback);
279 if (ret == HID_SUCCESS) {
280 status = BTA_HH_OK;
281 } else {
282 #if (BTA_HH_DEBUG == TRUE)
283 APPL_TRACE_DEBUG("%s: HID_HostGetSDPRecord failed: Status 0x%2x",
284 __func__, ret);
285 #endif
286 }
287 }
288
289 if (status != BTA_HH_OK) {
290 osi_free_and_reset((void**)&bta_hh_cb.p_disc_db);
291 /* send SDP_CMPL_EVT into state machine */
292 tBTA_HH_DATA bta_hh_data;
293 bta_hh_data.status = status;
294 bta_hh_sm_execute(p_cb, BTA_HH_SDP_CMPL_EVT, &bta_hh_data);
295 }
296 return;
297 }
298
299 /*******************************************************************************
300 *
301 * Function bta_hh_start_sdp
302 *
303 * Description Start SDP service search, and obtain necessary SDP records.
304 * Only one SDP service search request is allowed at the same
305 * time. For every BTA_HhOpen API call, do SDP first unless SDP
306 * has been done previously.
307 *
308 * Returns void
309 *
310 ******************************************************************************/
bta_hh_start_sdp(tBTA_HH_DEV_CB * p_cb,tBTA_HH_DATA * p_data)311 void bta_hh_start_sdp(tBTA_HH_DEV_CB* p_cb, tBTA_HH_DATA* p_data) {
312 tBTA_HH_STATUS status = BTA_HH_ERR_SDP;
313 uint8_t hdl;
314
315 p_cb->sec_mask = p_data->api_conn.sec_mask;
316 p_cb->mode = p_data->api_conn.mode;
317 bta_hh_cb.p_cur = p_cb;
318
319 #if (BTA_HH_LE_INCLUDED == TRUE)
320 if (bta_hh_is_le_device(p_cb, p_data->api_conn.bd_addr)) {
321 bta_hh_le_open_conn(p_cb, p_data->api_conn.bd_addr);
322 return;
323 }
324 #endif
325
326 /* if previously virtually cabled device, skip SDP */
327 if (p_cb->app_id) {
328 status = BTA_HH_OK;
329 #if (BTA_HH_DEBUG == TRUE)
330 APPL_TRACE_DEBUG("%s: skip SDP for known devices", __func__);
331 #endif
332 if (p_cb->hid_handle == BTA_HH_INVALID_HANDLE) {
333 if (HID_HostAddDev(p_cb->addr, p_cb->attr_mask, &hdl) == HID_SUCCESS) {
334 /* update device CB with newly register device handle */
335 bta_hh_add_device_to_list(p_cb, hdl, p_cb->attr_mask, NULL,
336 p_cb->sub_class,
337 p_cb->dscp_info.ssr_max_latency,
338 p_cb->dscp_info.ssr_min_tout, p_cb->app_id);
339 /* update cb_index[] map */
340 bta_hh_cb.cb_index[hdl] = p_cb->index;
341 } else
342 status = BTA_HH_ERR_NO_RES;
343 }
344 tBTA_HH_DATA bta_hh_data;
345 bta_hh_data.status = status;
346 bta_hh_sm_execute(p_cb, BTA_HH_SDP_CMPL_EVT, &bta_hh_data);
347
348 return;
349 }
350 /* GetSDPRecord. at one time only one SDP precedure can be active */
351 else if (!bta_hh_cb.p_disc_db) {
352 bta_hh_cb.p_disc_db =
353 (tSDP_DISCOVERY_DB*)osi_malloc(p_bta_hh_cfg->sdp_db_size);
354 bta_hh_cb.p_cur = p_cb;
355 /* do DI discovery first */
356 if (SDP_DiDiscover(p_data->api_conn.bd_addr, bta_hh_cb.p_disc_db,
357 p_bta_hh_cfg->sdp_db_size,
358 bta_hh_di_sdp_cback) != SDP_SUCCESS) {
359 #if (BTA_HH_DEBUG == TRUE)
360 APPL_TRACE_DEBUG("%s: SDP_DiDiscover failed: Status 0x%2X", __func__,
361 status);
362 #endif
363 status = BTA_HH_ERR_SDP;
364 osi_free_and_reset((void**)&bta_hh_cb.p_disc_db);
365 } else {
366 status = BTA_HH_OK;
367 }
368 } else if (bta_hh_cb.p_disc_db) {
369 /* It is possible that there is incoming/outgoing collision case. DUT
370 * initiated
371 * HID connection at same time remote has connected L2CAP for HID control,
372 * so SDP would be in progress, when this flow reaches here. Just do nothing
373 * when the code reaches here, and ongoing SDP completion or failure will
374 * handle this case.
375 */
376 APPL_TRACE_DEBUG("%s: ignoring as SDP already in progress", __func__);
377 return;
378 }
379
380 if (status != BTA_HH_OK) {
381 tBTA_HH_DATA bta_hh_data;
382 bta_hh_data.status = status;
383 bta_hh_sm_execute(p_cb, BTA_HH_SDP_CMPL_EVT, &bta_hh_data);
384 }
385
386 return;
387 }
388 /*******************************************************************************
389 *
390 * Function bta_hh_sdp_cmpl
391 *
392 * Description When SDP completes, initiate a connection or report an error
393 * depending on the SDP result.
394 *
395 *
396 * Returns void
397 *
398 ******************************************************************************/
bta_hh_sdp_cmpl(tBTA_HH_DEV_CB * p_cb,tBTA_HH_DATA * p_data)399 void bta_hh_sdp_cmpl(tBTA_HH_DEV_CB* p_cb, tBTA_HH_DATA* p_data) {
400 tBTA_HH_CONN conn_dat;
401 tBTA_HH_STATUS status = p_data->status;
402
403 #if (BTA_HH_DEBUG == TRUE)
404 APPL_TRACE_DEBUG("%s: status 0x%2X", __func__, p_data->status);
405 #endif
406
407 /* initialize call back data */
408 memset((void*)&conn_dat, 0, sizeof(tBTA_HH_CONN));
409 conn_dat.handle = p_cb->hid_handle;
410 conn_dat.bda = p_cb->addr;
411
412 /* if SDP compl success */
413 if (status == BTA_HH_OK) {
414 /* not incoming connection doing SDP, initiate a HID connection */
415 if (!p_cb->incoming_conn) {
416 tHID_STATUS ret;
417 /* set security level */
418 HID_HostSetSecurityLevel("", p_cb->sec_mask);
419
420 /* open HID connection */
421 ret = HID_HostOpenDev(p_cb->hid_handle);
422 APPL_TRACE_DEBUG("%s: HID_HostOpenDev returned=%d", __func__, ret);
423 if (ret == HID_SUCCESS || ret == HID_ERR_ALREADY_CONN) {
424 status = BTA_HH_OK;
425 } else if (ret == HID_ERR_CONN_IN_PROCESS) {
426 /* Connection already in progress, return from here, SDP
427 * will be performed after connection is completed.
428 */
429 APPL_TRACE_DEBUG("%s: connection already in progress", __func__);
430 return;
431 } else {
432 #if (BTA_HH_DEBUG == TRUE)
433 APPL_TRACE_DEBUG("%s: HID_HostOpenDev failed: Status 0x%2X", __func__,
434 ret);
435 #endif
436 /* open fail, remove device from management device list */
437 HID_HostRemoveDev(p_cb->hid_handle);
438 status = BTA_HH_ERR;
439 }
440 } else /* incoming connection SDP finish */
441 {
442 bta_hh_sm_execute(p_cb, BTA_HH_OPEN_CMPL_EVT, NULL);
443 }
444 }
445
446 if (status != BTA_HH_OK) {
447 /* Check if this was incoming connection request from an unknown device
448 * and connection failed due to missing HID Device SDP UUID
449 * In above condition, disconnect the link as well as remove the
450 * device from list of HID devices
451 */
452 if ((status == BTA_HH_ERR_SDP) && (p_cb->incoming_conn) &&
453 (p_cb->app_id == 0)) {
454 APPL_TRACE_DEBUG("%s: SDP failed for incoming conn :hndl %d", __func__,
455 p_cb->incoming_hid_handle);
456 HID_HostRemoveDev(p_cb->incoming_hid_handle);
457 }
458 conn_dat.status = status;
459 (*bta_hh_cb.p_cback)(BTA_HH_OPEN_EVT, (tBTA_HH*)&conn_dat);
460
461 /* move state machine W4_CONN ->IDLE */
462 bta_hh_sm_execute(p_cb, BTA_HH_API_CLOSE_EVT, NULL);
463
464 /* if this is an outgoing connection to an unknown device, clean up cb */
465 if (p_cb->app_id == 0 && !p_cb->incoming_conn) {
466 /* clean up device control block */
467 bta_hh_clean_up_kdev(p_cb);
468 }
469 #if (BTA_HH_DEBUG == TRUE)
470 bta_hh_trace_dev_db();
471 #endif
472 }
473 return;
474 }
475
476 /*******************************************************************************
477 *
478 * Function bta_hh_api_disc_act
479 *
480 * Description HID Host initiate a disconnection.
481 *
482 *
483 * Returns void
484 *
485 ******************************************************************************/
bta_hh_api_disc_act(tBTA_HH_DEV_CB * p_cb,tBTA_HH_DATA * p_data)486 void bta_hh_api_disc_act(tBTA_HH_DEV_CB* p_cb, tBTA_HH_DATA* p_data) {
487 tBTA_HH_CBDATA disc_dat;
488 tHID_STATUS status;
489
490 #if (BTA_HH_LE_INCLUDED == TRUE)
491 if (p_cb->is_le_device)
492 bta_hh_le_api_disc_act(p_cb);
493 else
494 #endif
495 {
496 /* found an active connection */
497 disc_dat.handle =
498 p_data ? (uint8_t)p_data->hdr.layer_specific : p_cb->hid_handle;
499 disc_dat.status = BTA_HH_ERR;
500
501 status = HID_HostCloseDev(disc_dat.handle);
502
503 if (status) {
504 tBTA_HH bta_hh;
505 bta_hh.dev_status = disc_dat;
506 (*bta_hh_cb.p_cback)(BTA_HH_CLOSE_EVT, &bta_hh);
507 }
508 }
509
510 return;
511 }
512 /*******************************************************************************
513 *
514 * Function bta_hh_open_cmpl_act
515 *
516 * Description HID host connection completed
517 *
518 *
519 * Returns void
520 *
521 ******************************************************************************/
bta_hh_open_cmpl_act(tBTA_HH_DEV_CB * p_cb,tBTA_HH_DATA * p_data)522 void bta_hh_open_cmpl_act(tBTA_HH_DEV_CB* p_cb, tBTA_HH_DATA* p_data) {
523 tBTA_HH_CONN conn;
524 uint8_t dev_handle =
525 p_data ? (uint8_t)p_data->hid_cback.hdr.layer_specific : p_cb->hid_handle;
526
527 memset((void*)&conn, 0, sizeof(tBTA_HH_CONN));
528 conn.handle = dev_handle;
529 conn.bda = p_cb->addr;
530
531 /* increase connection number */
532 bta_hh_cb.cnt_num++;
533
534 /* initialize device driver */
535 bta_hh_co_open(p_cb->hid_handle, p_cb->sub_class, p_cb->attr_mask,
536 p_cb->app_id);
537
538 #if (BTA_HH_LE_INCLUDED == TRUE)
539 conn.status = p_cb->status;
540 conn.le_hid = p_cb->is_le_device;
541 conn.scps_supported = p_cb->scps_supported;
542
543 if (!p_cb->is_le_device)
544 #endif
545 {
546 /* inform role manager */
547 bta_sys_conn_open(BTA_ID_HH, p_cb->app_id, p_cb->addr);
548 }
549 /* set protocol mode when not default report mode */
550 if (p_cb->mode != BTA_HH_PROTO_RPT_MODE
551 #if (BTA_HH_LE_INCLUDED == TRUE)
552 && !p_cb->is_le_device
553 #endif
554 ) {
555 if ((HID_HostWriteDev(dev_handle, HID_TRANS_SET_PROTOCOL,
556 HID_PAR_PROTOCOL_BOOT_MODE, 0, 0, NULL)) !=
557 HID_SUCCESS) {
558 /* HID connection is up, while SET_PROTO fail */
559 conn.status = BTA_HH_ERR_PROTO;
560 (*bta_hh_cb.p_cback)(BTA_HH_OPEN_EVT, (tBTA_HH*)&conn);
561 } else {
562 conn.status = BTA_HH_OK;
563 p_cb->w4_evt = BTA_HH_OPEN_EVT;
564 }
565 } else
566 (*bta_hh_cb.p_cback)(BTA_HH_OPEN_EVT, (tBTA_HH*)&conn);
567
568 p_cb->incoming_conn = false;
569 p_cb->incoming_hid_handle = BTA_HH_INVALID_HANDLE;
570 }
571 /*******************************************************************************
572 *
573 * Function bta_hh_open_act
574 *
575 * Description HID host receive HID_OPEN_EVT .
576 *
577 *
578 * Returns void
579 *
580 ******************************************************************************/
bta_hh_open_act(tBTA_HH_DEV_CB * p_cb,tBTA_HH_DATA * p_data)581 void bta_hh_open_act(tBTA_HH_DEV_CB* p_cb, tBTA_HH_DATA* p_data) {
582 tBTA_HH_API_CONN conn_data;
583
584 uint8_t dev_handle =
585 p_data ? (uint8_t)p_data->hid_cback.hdr.layer_specific : p_cb->hid_handle;
586
587 #if (BTA_HH_DEBUG == TRUE)
588 APPL_TRACE_EVENT("%s: Device[%d] connected", __func__, dev_handle);
589 #endif
590
591 /* SDP has been done */
592 if (p_cb->app_id != 0) {
593 bta_hh_sm_execute(p_cb, BTA_HH_OPEN_CMPL_EVT, p_data);
594 } else
595 /* app_id == 0 indicates an incoming conenction request arrives without SDP
596 * performed, do it first
597 */
598 {
599 p_cb->incoming_conn = true;
600 /* store the handle here in case sdp fails - need to disconnect */
601 p_cb->incoming_hid_handle = dev_handle;
602
603 memset(&conn_data, 0, sizeof(tBTA_HH_API_CONN));
604 conn_data.bd_addr = p_cb->addr;
605 bta_hh_start_sdp(p_cb, (tBTA_HH_DATA*)&conn_data);
606 }
607
608 return;
609 }
610
611 /*******************************************************************************
612 *
613 * Function bta_hh_data_act
614 *
615 * Description HID Host process a data report
616 *
617 *
618 * Returns void
619 *
620 ******************************************************************************/
bta_hh_data_act(tBTA_HH_DEV_CB * p_cb,tBTA_HH_DATA * p_data)621 void bta_hh_data_act(tBTA_HH_DEV_CB* p_cb, tBTA_HH_DATA* p_data) {
622 BT_HDR* pdata = p_data->hid_cback.p_data;
623 uint8_t* p_rpt = (uint8_t*)(pdata + 1) + pdata->offset;
624
625 bta_hh_co_data((uint8_t)p_data->hid_cback.hdr.layer_specific, p_rpt,
626 pdata->len, p_cb->mode, p_cb->sub_class,
627 p_cb->dscp_info.ctry_code, p_cb->addr, p_cb->app_id);
628
629 osi_free_and_reset((void**)&pdata);
630 }
631
632 /*******************************************************************************
633 *
634 * Function bta_hh_handsk_act
635 *
636 * Description HID Host process a handshake acknowledgement.
637 *
638 *
639 * Returns void
640 *
641 ******************************************************************************/
bta_hh_handsk_act(tBTA_HH_DEV_CB * p_cb,tBTA_HH_DATA * p_data)642 void bta_hh_handsk_act(tBTA_HH_DEV_CB* p_cb, tBTA_HH_DATA* p_data) {
643 #if (BTA_HH_DEBUG == TRUE)
644 APPL_TRACE_DEBUG("HANDSHAKE received for: event = %s data= %d",
645 bta_hh_get_w4_event(p_cb->w4_evt), p_data->hid_cback.data);
646 #endif
647
648 tBTA_HH bta_hh;
649 memset(&bta_hh, 0, sizeof(tBTA_HH));
650
651 switch (p_cb->w4_evt) {
652 /* GET_ transsaction, handshake indicate unsupported request */
653 case BTA_HH_GET_PROTO_EVT:
654 bta_hh.hs_data.rsp_data.proto_mode = BTA_HH_PROTO_UNKNOWN;
655 FALLTHROUGH_INTENDED; /* FALLTHROUGH */
656 case BTA_HH_GET_RPT_EVT:
657 case BTA_HH_GET_IDLE_EVT:
658 bta_hh.hs_data.handle = p_cb->hid_handle;
659 /* if handshake gives an OK code for these transaction, fill in UNSUPT */
660 bta_hh.hs_data.status = bta_hh_get_trans_status(p_data->hid_cback.data);
661 if (bta_hh.hs_data.status == BTA_HH_OK)
662 bta_hh.hs_data.status = BTA_HH_HS_TRANS_NOT_SPT;
663 if (p_cb->w4_evt == BTA_HH_GET_RPT_EVT)
664 bta_hh_co_get_rpt_rsp(bta_hh.dev_status.handle, bta_hh.hs_data.status,
665 NULL, 0);
666 (*bta_hh_cb.p_cback)(p_cb->w4_evt, &bta_hh);
667 p_cb->w4_evt = 0;
668 break;
669
670 /* acknoledgement from HID device for SET_ transaction */
671 case BTA_HH_SET_RPT_EVT:
672 case BTA_HH_SET_PROTO_EVT:
673 case BTA_HH_SET_IDLE_EVT:
674 bta_hh.dev_status.handle = p_cb->hid_handle;
675 bta_hh.dev_status.status =
676 bta_hh_get_trans_status(p_data->hid_cback.data);
677 if (p_cb->w4_evt == BTA_HH_SET_RPT_EVT)
678 bta_hh_co_set_rpt_rsp(bta_hh.dev_status.handle,
679 bta_hh.dev_status.status);
680 (*bta_hh_cb.p_cback)(p_cb->w4_evt, &bta_hh);
681 p_cb->w4_evt = 0;
682 break;
683
684 /* SET_PROTOCOL when open connection */
685 case BTA_HH_OPEN_EVT:
686 bta_hh.conn.status =
687 p_data->hid_cback.data ? BTA_HH_ERR_PROTO : BTA_HH_OK;
688 bta_hh.conn.handle = p_cb->hid_handle;
689 bta_hh.conn.bda = p_cb->addr;
690 (*bta_hh_cb.p_cback)(p_cb->w4_evt, &bta_hh);
691 #if (BTA_HH_DEBUG == TRUE)
692 bta_hh_trace_dev_db();
693 #endif
694 p_cb->w4_evt = 0;
695 break;
696
697 default:
698 /* unknow transaction handshake response */
699 APPL_TRACE_DEBUG("unknown transaction type");
700 break;
701 }
702
703 /* transaction achknoledgement received, inform PM for mode change */
704 bta_sys_idle(BTA_ID_HH, p_cb->app_id, p_cb->addr);
705 return;
706 }
707 /*******************************************************************************
708 *
709 * Function bta_hh_ctrl_dat_act
710 *
711 * Description HID Host process a data report from control channel.
712 *
713 *
714 * Returns void
715 *
716 ******************************************************************************/
bta_hh_ctrl_dat_act(tBTA_HH_DEV_CB * p_cb,tBTA_HH_DATA * p_data)717 void bta_hh_ctrl_dat_act(tBTA_HH_DEV_CB* p_cb, tBTA_HH_DATA* p_data) {
718 BT_HDR* pdata = p_data->hid_cback.p_data;
719 uint8_t* data = (uint8_t*)(pdata + 1) + pdata->offset;
720 tBTA_HH_HSDATA hs_data;
721
722 #if (BTA_HH_DEBUG == TRUE)
723 APPL_TRACE_DEBUG("Ctrl DATA received w4: event[%s]",
724 bta_hh_get_w4_event(p_cb->w4_evt));
725 #endif
726 if (pdata->len == 0) {
727 android_errorWriteLog(0x534e4554, "116108738");
728 p_cb->w4_evt = 0;
729 osi_free_and_reset((void**)&pdata);
730 return;
731 }
732 hs_data.status = BTA_HH_OK;
733 hs_data.handle = p_cb->hid_handle;
734
735 switch (p_cb->w4_evt) {
736 case BTA_HH_GET_IDLE_EVT:
737 hs_data.rsp_data.idle_rate = *data;
738 break;
739 case BTA_HH_GET_RPT_EVT:
740 hs_data.rsp_data.p_rpt_data = pdata;
741 bta_hh_co_get_rpt_rsp(hs_data.handle, hs_data.status, pdata->data,
742 pdata->len);
743 break;
744 case BTA_HH_GET_PROTO_EVT:
745 /* match up BTE/BTA report/boot mode def*/
746 hs_data.rsp_data.proto_mode = ((*data) == HID_PAR_PROTOCOL_REPORT)
747 ? BTA_HH_PROTO_RPT_MODE
748 : BTA_HH_PROTO_BOOT_MODE;
749 #if (BTA_HH_DEBUG == TRUE)
750 APPL_TRACE_DEBUG("GET_PROTOCOL Mode = [%s]",
751 (hs_data.rsp_data.proto_mode == BTA_HH_PROTO_RPT_MODE)
752 ? "Report"
753 : "Boot");
754 #endif
755 break;
756 /* should not expect control DATA for SET_ transaction */
757 case BTA_HH_SET_PROTO_EVT:
758 FALLTHROUGH_INTENDED; /* FALLTHROUGH */
759 case BTA_HH_SET_RPT_EVT:
760 FALLTHROUGH_INTENDED; /* FALLTHROUGH */
761 case BTA_HH_SET_IDLE_EVT:
762 FALLTHROUGH_INTENDED; /* FALLTHROUGH */
763 default:
764 #if (BTA_HH_DEBUG == TRUE)
765 APPL_TRACE_DEBUG("invalid transaction type for DATA payload: 4_evt[%s]",
766 bta_hh_get_w4_event(p_cb->w4_evt));
767 #endif
768 break;
769 }
770
771 /* inform PM for mode change */
772 bta_sys_busy(BTA_ID_HH, p_cb->app_id, p_cb->addr);
773 bta_sys_idle(BTA_ID_HH, p_cb->app_id, p_cb->addr);
774
775 (*bta_hh_cb.p_cback)(p_cb->w4_evt, (tBTA_HH*)&hs_data);
776
777 p_cb->w4_evt = 0;
778 osi_free_and_reset((void**)&pdata);
779 }
780
781 /*******************************************************************************
782 *
783 * Function bta_hh_open_failure
784 *
785 * Description report HID open failure when at wait for connection state
786 * and receive device close event.
787 *
788 *
789 * Returns void
790 *
791 ******************************************************************************/
bta_hh_open_failure(tBTA_HH_DEV_CB * p_cb,tBTA_HH_DATA * p_data)792 void bta_hh_open_failure(tBTA_HH_DEV_CB* p_cb, tBTA_HH_DATA* p_data) {
793 tBTA_HH_CONN conn_dat;
794 uint32_t reason = p_data->hid_cback.data; /* Reason for closing (32-bit) */
795
796 memset(&conn_dat, 0, sizeof(tBTA_HH_CONN));
797 conn_dat.handle = p_cb->hid_handle;
798 conn_dat.status =
799 (reason == HID_ERR_AUTH_FAILED) ? BTA_HH_ERR_AUTH_FAILED : BTA_HH_ERR;
800 conn_dat.bda = p_cb->addr;
801 HID_HostCloseDev(p_cb->hid_handle);
802
803 /* Report OPEN fail event */
804 (*bta_hh_cb.p_cback)(BTA_HH_OPEN_EVT, (tBTA_HH*)&conn_dat);
805
806 #if (BTA_HH_DEBUG == TRUE)
807 bta_hh_trace_dev_db();
808 #endif
809 /* clean up control block, but retain SDP info and device handle */
810 p_cb->vp = false;
811 p_cb->w4_evt = 0;
812
813 /* if no connection is active and HH disable is signaled, disable service */
814 if (bta_hh_cb.cnt_num == 0 && bta_hh_cb.w4_disable) {
815 bta_hh_disc_cmpl();
816 }
817
818 /* Error in opening hid connection, reset flags */
819 p_cb->incoming_conn = false;
820 p_cb->incoming_hid_handle = BTA_HH_INVALID_HANDLE;
821 }
822
823 /*******************************************************************************
824 *
825 * Function bta_hh_close_act
826 *
827 * Description HID Host process a close event
828 *
829 *
830 * Returns void
831 *
832 ******************************************************************************/
bta_hh_close_act(tBTA_HH_DEV_CB * p_cb,tBTA_HH_DATA * p_data)833 void bta_hh_close_act(tBTA_HH_DEV_CB* p_cb, tBTA_HH_DATA* p_data) {
834 tBTA_HH_CONN conn_dat;
835 tBTA_HH_CBDATA disc_dat = {BTA_HH_OK, 0};
836 uint32_t reason = p_data->hid_cback.data; /* Reason for closing (32-bit) */
837
838 /* if HID_HDEV_EVT_VC_UNPLUG was received, report BTA_HH_VC_UNPLUG_EVT */
839 uint16_t event = p_cb->vp ? BTA_HH_VC_UNPLUG_EVT : BTA_HH_CLOSE_EVT;
840
841 disc_dat.handle = p_cb->hid_handle;
842 disc_dat.status = p_data->hid_cback.data;
843
844 /* Check reason for closing */
845 if ((reason & (HID_L2CAP_CONN_FAIL |
846 HID_L2CAP_REQ_FAIL)) || /* Failure to initialize connection
847 (page timeout or l2cap error) */
848 (reason ==
849 HID_ERR_AUTH_FAILED) || /* Authenication error (while initiating) */
850 (reason == HID_ERR_L2CAP_FAILED)) /* Failure creating l2cap connection */
851 {
852 /* Failure in opening connection */
853 conn_dat.handle = p_cb->hid_handle;
854 conn_dat.status =
855 (reason == HID_ERR_AUTH_FAILED) ? BTA_HH_ERR_AUTH_FAILED : BTA_HH_ERR;
856 conn_dat.bda = p_cb->addr;
857 HID_HostCloseDev(p_cb->hid_handle);
858
859 /* Report OPEN fail event */
860 (*bta_hh_cb.p_cback)(BTA_HH_OPEN_EVT, (tBTA_HH*)&conn_dat);
861
862 #if (BTA_HH_DEBUG == TRUE)
863 bta_hh_trace_dev_db();
864 #endif
865 return;
866 }
867 /* otherwise report CLOSE/VC_UNPLUG event */
868 else {
869 /* finaliza device driver */
870 bta_hh_co_close(p_cb->hid_handle, p_cb->app_id);
871 /* inform role manager */
872 bta_sys_conn_close(BTA_ID_HH, p_cb->app_id, p_cb->addr);
873 /* update total conn number */
874 bta_hh_cb.cnt_num--;
875
876 if (disc_dat.status) disc_dat.status = BTA_HH_ERR;
877
878 (*bta_hh_cb.p_cback)(event, (tBTA_HH*)&disc_dat);
879
880 /* if virtually unplug, remove device */
881 if (p_cb->vp) {
882 HID_HostRemoveDev(p_cb->hid_handle);
883 bta_hh_clean_up_kdev(p_cb);
884 }
885
886 #if (BTA_HH_DEBUG == TRUE)
887 bta_hh_trace_dev_db();
888 #endif
889 }
890
891 /* clean up control block, but retain SDP info and device handle */
892 p_cb->vp = false;
893 p_cb->w4_evt = 0;
894
895 /* if no connection is active and HH disable is signaled, disable service */
896 if (bta_hh_cb.cnt_num == 0 && bta_hh_cb.w4_disable) {
897 bta_hh_disc_cmpl();
898 }
899
900 return;
901 }
902
903 /*******************************************************************************
904 *
905 * Function bta_hh_get_dscp_act
906 *
907 * Description Get device report descriptor
908 *
909 *
910 * Returns void
911 *
912 ******************************************************************************/
bta_hh_get_dscp_act(tBTA_HH_DEV_CB * p_cb,UNUSED_ATTR tBTA_HH_DATA * p_data)913 void bta_hh_get_dscp_act(tBTA_HH_DEV_CB* p_cb,
914 UNUSED_ATTR tBTA_HH_DATA* p_data) {
915 #if (BTA_HH_LE_INCLUDED == TRUE)
916 if (p_cb->is_le_device) {
917 bta_hh_le_get_dscp_act(p_cb);
918 } else
919 #endif
920 (*bta_hh_cb.p_cback)(BTA_HH_GET_DSCP_EVT, (tBTA_HH*)&p_cb->dscp_info);
921 }
922
923 /*******************************************************************************
924 *
925 * Function bta_hh_maint_dev_act
926 *
927 * Description HID Host maintain device list.
928 *
929 *
930 * Returns void
931 *
932 ******************************************************************************/
bta_hh_maint_dev_act(tBTA_HH_DEV_CB * p_cb,tBTA_HH_DATA * p_data)933 void bta_hh_maint_dev_act(tBTA_HH_DEV_CB* p_cb, tBTA_HH_DATA* p_data) {
934 tBTA_HH_MAINT_DEV* p_dev_info = &p_data->api_maintdev;
935 tBTA_HH_DEV_INFO dev_info;
936 uint8_t dev_handle;
937
938 dev_info.status = BTA_HH_ERR;
939 dev_info.handle = BTA_HH_INVALID_HANDLE;
940
941 switch (p_dev_info->sub_event) {
942 case BTA_HH_ADD_DEV_EVT: /* add a device */
943 dev_info.bda = p_dev_info->bda;
944 /* initialize callback data */
945 if (p_cb->hid_handle == BTA_HH_INVALID_HANDLE) {
946 #if (BTA_HH_LE_INCLUDED == TRUE)
947 if (bta_hh_is_le_device(p_cb, p_data->api_conn.bd_addr)) {
948 dev_info.handle = bta_hh_le_add_device(p_cb, p_dev_info);
949 if (dev_info.handle != BTA_HH_INVALID_HANDLE)
950 dev_info.status = BTA_HH_OK;
951 } else
952 #endif
953
954 if (HID_HostAddDev(p_dev_info->bda, p_dev_info->attr_mask,
955 &dev_handle) == HID_SUCCESS) {
956 dev_info.handle = dev_handle;
957 dev_info.status = BTA_HH_OK;
958
959 #if (BTA_HH_LE_INCLUDED == TRUE)
960 /* update DI information */
961 bta_hh_update_di_info(p_cb, p_dev_info->dscp_info.vendor_id,
962 p_dev_info->dscp_info.product_id,
963 p_dev_info->dscp_info.version,
964 p_dev_info->dscp_info.flag);
965 #else
966 bta_hh_update_di_info(p_cb, p_dev_info->dscp_info.vendor_id,
967 p_dev_info->dscp_info.product_id,
968 p_dev_info->dscp_info.version, 0);
969
970 #endif
971 /* add to BTA device list */
972 bta_hh_add_device_to_list(
973 p_cb, dev_handle, p_dev_info->attr_mask,
974 &p_dev_info->dscp_info.descriptor, p_dev_info->sub_class,
975 p_dev_info->dscp_info.ssr_max_latency,
976 p_dev_info->dscp_info.ssr_min_tout, p_dev_info->app_id);
977 /* update cb_index[] map */
978 bta_hh_cb.cb_index[dev_handle] = p_cb->index;
979 }
980 } else /* device already been added */
981 {
982 dev_info.handle = p_cb->hid_handle;
983 dev_info.status = BTA_HH_OK;
984 }
985 #if (BTA_HH_DEBUG == TRUE)
986 bta_hh_trace_dev_db();
987 #endif
988
989 break;
990 case BTA_HH_RMV_DEV_EVT: /* remove device */
991 dev_info.handle = (uint8_t)p_dev_info->hdr.layer_specific;
992 dev_info.bda = p_cb->addr;
993
994 #if (BTA_HH_LE_INCLUDED == TRUE)
995 if (p_cb->is_le_device) {
996 bta_hh_le_remove_dev_bg_conn(p_cb);
997 bta_hh_sm_execute(p_cb, BTA_HH_API_CLOSE_EVT, NULL);
998 bta_hh_clean_up_kdev(p_cb);
999 } else
1000 #endif
1001 {
1002 if (HID_HostRemoveDev(dev_info.handle) == HID_SUCCESS) {
1003 dev_info.status = BTA_HH_OK;
1004
1005 /* remove from known device list in BTA */
1006 bta_hh_clean_up_kdev(p_cb);
1007 }
1008 }
1009 break;
1010
1011 default:
1012 APPL_TRACE_DEBUG("invalid command");
1013 break;
1014 }
1015
1016 (*bta_hh_cb.p_cback)(p_dev_info->sub_event, (tBTA_HH*)&dev_info);
1017 }
1018 /*******************************************************************************
1019 *
1020 * Function bta_hh_write_dev_act
1021 *
1022 * Description Write device action. can be SET/GET/DATA transaction.
1023 *
1024 * Returns void
1025 *
1026 ******************************************************************************/
bta_hh_write_dev_act(tBTA_HH_DEV_CB * p_cb,tBTA_HH_DATA * p_data)1027 void bta_hh_write_dev_act(tBTA_HH_DEV_CB* p_cb, tBTA_HH_DATA* p_data) {
1028 tBTA_HH_CBDATA cbdata = {BTA_HH_OK, 0};
1029 uint16_t event = (p_data->api_sndcmd.t_type - BTA_HH_FST_BTE_TRANS_EVT) +
1030 BTA_HH_FST_TRANS_CB_EVT;
1031
1032 #if (BTA_HH_LE_INCLUDED == TRUE)
1033 if (p_cb->is_le_device)
1034 bta_hh_le_write_dev_act(p_cb, p_data);
1035 else
1036 #endif
1037 {
1038
1039 cbdata.handle = p_cb->hid_handle;
1040
1041 /* match up BTE/BTA report/boot mode def */
1042 if (p_data->api_sndcmd.t_type == HID_TRANS_SET_PROTOCOL) {
1043 p_data->api_sndcmd.param =
1044 (p_data->api_sndcmd.param == BTA_HH_PROTO_RPT_MODE)
1045 ? HID_PAR_PROTOCOL_REPORT
1046 : HID_PAR_PROTOCOL_BOOT_MODE;
1047 }
1048
1049 if (HID_HostWriteDev(p_cb->hid_handle, p_data->api_sndcmd.t_type,
1050 p_data->api_sndcmd.param, p_data->api_sndcmd.data,
1051 p_data->api_sndcmd.rpt_id,
1052 p_data->api_sndcmd.p_data) != HID_SUCCESS) {
1053 APPL_TRACE_ERROR("HID_HostWriteDev Error ");
1054 cbdata.status = BTA_HH_ERR;
1055
1056 if (p_data->api_sndcmd.t_type != HID_TRANS_CONTROL &&
1057 p_data->api_sndcmd.t_type != HID_TRANS_DATA)
1058 (*bta_hh_cb.p_cback)(event, (tBTA_HH*)&cbdata);
1059 else if (p_data->api_sndcmd.param == BTA_HH_CTRL_VIRTUAL_CABLE_UNPLUG)
1060 (*bta_hh_cb.p_cback)(BTA_HH_VC_UNPLUG_EVT, (tBTA_HH*)&cbdata);
1061 } else {
1062 switch (p_data->api_sndcmd.t_type) {
1063 case HID_TRANS_SET_PROTOCOL:
1064 FALLTHROUGH_INTENDED; /* FALLTHROUGH */
1065 case HID_TRANS_GET_REPORT:
1066 FALLTHROUGH_INTENDED; /* FALLTHROUGH */
1067 case HID_TRANS_SET_REPORT:
1068 FALLTHROUGH_INTENDED; /* FALLTHROUGH */
1069 case HID_TRANS_GET_PROTOCOL:
1070 FALLTHROUGH_INTENDED; /* FALLTHROUGH */
1071 case HID_TRANS_GET_IDLE:
1072 FALLTHROUGH_INTENDED; /* FALLTHROUGH */
1073 case HID_TRANS_SET_IDLE: /* set w4_handsk event name for callback
1074 function use */
1075 p_cb->w4_evt = event;
1076 break;
1077 case HID_TRANS_DATA: /* output report */
1078 FALLTHROUGH_INTENDED; /* FALLTHROUGH */
1079 case HID_TRANS_CONTROL:
1080 /* no handshake event will be generated */
1081 /* if VC_UNPLUG is issued, set flag */
1082 if (p_data->api_sndcmd.param == BTA_HH_CTRL_VIRTUAL_CABLE_UNPLUG)
1083 p_cb->vp = true;
1084
1085 break;
1086 /* currently not expected */
1087 case HID_TRANS_DATAC:
1088 default:
1089 APPL_TRACE_DEBUG("%s: cmd type = %d", __func__,
1090 p_data->api_sndcmd.t_type);
1091 break;
1092 }
1093
1094 /* if not control type transaction, notify PM for energy control */
1095 if (p_data->api_sndcmd.t_type != HID_TRANS_CONTROL) {
1096 /* inform PM for mode change */
1097 bta_sys_busy(BTA_ID_HH, p_cb->app_id, p_cb->addr);
1098 bta_sys_idle(BTA_ID_HH, p_cb->app_id, p_cb->addr);
1099 } else if (p_data->api_sndcmd.param == BTA_HH_CTRL_SUSPEND) {
1100 bta_sys_sco_close(BTA_ID_HH, p_cb->app_id, p_cb->addr);
1101 } else if (p_data->api_sndcmd.param == BTA_HH_CTRL_EXIT_SUSPEND) {
1102 bta_sys_busy(BTA_ID_HH, p_cb->app_id, p_cb->addr);
1103 }
1104 }
1105 }
1106 return;
1107 }
1108
1109 /*****************************************************************************
1110 * Static Function
1111 ****************************************************************************/
1112 /*******************************************************************************
1113 *
1114 * Function bta_hh_cback
1115 *
1116 * Description BTA HH callback function.
1117 *
1118 *
1119 * Returns void
1120 *
1121 ******************************************************************************/
bta_hh_cback(uint8_t dev_handle,const RawAddress & addr,uint8_t event,uint32_t data,BT_HDR * pdata)1122 static void bta_hh_cback(uint8_t dev_handle, const RawAddress& addr,
1123 uint8_t event, uint32_t data, BT_HDR* pdata) {
1124 uint16_t sm_event = BTA_HH_INVALID_EVT;
1125 uint8_t xx = 0;
1126
1127 #if (BTA_HH_DEBUG == TRUE)
1128 APPL_TRACE_DEBUG("%s::HID_event [%s]", __func__,
1129 bta_hh_hid_event_name(event));
1130 #endif
1131
1132 switch (event) {
1133 case HID_HDEV_EVT_OPEN:
1134 sm_event = BTA_HH_INT_OPEN_EVT;
1135 break;
1136 case HID_HDEV_EVT_CLOSE:
1137 sm_event = BTA_HH_INT_CLOSE_EVT;
1138 break;
1139 case HID_HDEV_EVT_INTR_DATA:
1140 sm_event = BTA_HH_INT_DATA_EVT;
1141 break;
1142 case HID_HDEV_EVT_HANDSHAKE:
1143 sm_event = BTA_HH_INT_HANDSK_EVT;
1144 break;
1145 case HID_HDEV_EVT_CTRL_DATA:
1146 sm_event = BTA_HH_INT_CTRL_DATA;
1147 break;
1148 case HID_HDEV_EVT_RETRYING:
1149 break;
1150 case HID_HDEV_EVT_INTR_DATC:
1151 case HID_HDEV_EVT_CTRL_DATC:
1152 /* Unhandled events: Free buffer for DATAC */
1153 osi_free_and_reset((void**)&pdata);
1154 break;
1155 case HID_HDEV_EVT_VC_UNPLUG:
1156 for (xx = 0; xx < BTA_HH_MAX_DEVICE; xx++) {
1157 if (bta_hh_cb.kdev[xx].hid_handle == dev_handle) {
1158 bta_hh_cb.kdev[xx].vp = true;
1159 break;
1160 }
1161 }
1162 break;
1163 }
1164
1165 if (sm_event != BTA_HH_INVALID_EVT) {
1166 tBTA_HH_CBACK_DATA* p_buf = (tBTA_HH_CBACK_DATA*)osi_malloc(
1167 sizeof(tBTA_HH_CBACK_DATA) + sizeof(BT_HDR));
1168 p_buf->hdr.event = sm_event;
1169 p_buf->hdr.layer_specific = (uint16_t)dev_handle;
1170 p_buf->data = data;
1171 p_buf->addr = addr;
1172 p_buf->p_data = pdata;
1173
1174 bta_sys_sendmsg(p_buf);
1175 }
1176 }
1177
1178 /*******************************************************************************
1179 *
1180 * Function bta_hh_get_trans_status
1181 *
1182 * Description translate a handshake result code into BTA HH
1183 * status code
1184 *
1185 ******************************************************************************/
bta_hh_get_trans_status(uint32_t result)1186 static tBTA_HH_STATUS bta_hh_get_trans_status(uint32_t result) {
1187 switch (result) {
1188 case HID_PAR_HANDSHAKE_RSP_SUCCESS: /* (0) */
1189 return BTA_HH_OK;
1190 case HID_PAR_HANDSHAKE_RSP_NOT_READY: /* (1) */
1191 case HID_PAR_HANDSHAKE_RSP_ERR_INVALID_REP_ID: /* (2) */
1192 case HID_PAR_HANDSHAKE_RSP_ERR_UNSUPPORTED_REQ: /* (3) */
1193 case HID_PAR_HANDSHAKE_RSP_ERR_INVALID_PARAM: /* (4) */
1194 return (tBTA_HH_STATUS)result;
1195 case HID_PAR_HANDSHAKE_RSP_ERR_UNKNOWN: /* (14) */
1196 case HID_PAR_HANDSHAKE_RSP_ERR_FATAL: /* (15) */
1197 default:
1198 return BTA_HH_HS_ERROR;
1199 break;
1200 }
1201 }
1202 /*****************************************************************************
1203 * Debug Functions
1204 ****************************************************************************/
1205
1206 #if (BTA_HH_DEBUG == TRUE)
bta_hh_get_w4_event(uint16_t event)1207 static const char* bta_hh_get_w4_event(uint16_t event) {
1208 switch (event) {
1209 case BTA_HH_GET_RPT_EVT:
1210 return "BTA_HH_GET_RPT_EVT";
1211 case BTA_HH_SET_RPT_EVT:
1212 return "BTA_HH_SET_RPT_EVT";
1213 case BTA_HH_GET_PROTO_EVT:
1214 return "BTA_HH_GET_PROTO_EVT";
1215 case BTA_HH_SET_PROTO_EVT:
1216 return "BTA_HH_SET_PROTO_EVT";
1217 case BTA_HH_GET_IDLE_EVT:
1218 return "BTA_HH_GET_IDLE_EVT";
1219 case BTA_HH_SET_IDLE_EVT:
1220 return "BTA_HH_SET_IDLE_EVT";
1221 case BTA_HH_OPEN_EVT:
1222 return "BTA_HH_OPEN_EVT";
1223 default:
1224 return "Unknown event";
1225 }
1226 }
1227
bta_hh_hid_event_name(uint16_t event)1228 static const char* bta_hh_hid_event_name(uint16_t event) {
1229 switch (event) {
1230 case HID_HDEV_EVT_OPEN:
1231 return "HID_HDEV_EVT_OPEN";
1232 case HID_HDEV_EVT_CLOSE:
1233 return "HID_HDEV_EVT_CLOSE";
1234 case HID_HDEV_EVT_RETRYING:
1235 return "HID_HDEV_EVT_RETRYING";
1236 case HID_HDEV_EVT_INTR_DATA:
1237 return "HID_HDEV_EVT_INTR_DATA";
1238 case HID_HDEV_EVT_INTR_DATC:
1239 return "HID_HDEV_EVT_INTR_DATC";
1240 case HID_HDEV_EVT_CTRL_DATA:
1241 return "HID_HDEV_EVT_CTRL_DATA";
1242 case HID_HDEV_EVT_CTRL_DATC:
1243 return "HID_HDEV_EVT_CTRL_DATC";
1244 case HID_HDEV_EVT_HANDSHAKE:
1245 return "HID_HDEV_EVT_HANDSHAKE";
1246 case HID_HDEV_EVT_VC_UNPLUG:
1247 return "HID_HDEV_EVT_VC_UNPLUG";
1248 default:
1249 return "Unknown HID event";
1250 }
1251 }
1252 #endif
1253 #endif /* BTA_HH_INCLUDED */
1254