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