btif_hh.c revision 390c94dc0f9deee917f52caaf3f8bb9f79aa98b4 
1/******************************************************************************
2 *
3 *  Copyright (C) 2009-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 *  Filename:      btif_hh.c
22 *
23 *  Description:   HID Host Profile Bluetooth Interface
24 *
25 *
26 ***********************************************************************************/
27#include <hardware/bluetooth.h>
28#include <hardware/bt_hh.h>
29#include <stdio.h>
30#include <stdlib.h>
31#include <errno.h>
32#include <string.h>
33
34#define LOG_TAG "BTIF_HH"
35
36#include "bta_api.h"
37#include "bta_hh_api.h"
38#include "bd.h"
39#include "btif_storage.h"
40
41#include "btif_common.h"
42#include "btif_util.h"
43#include "btif_hh.h"
44#include "gki.h"
45#include "l2c_api.h"
46
47
48#define BTIF_HH_APP_ID_MI       0x01
49#define BTIF_HH_APP_ID_KB       0x02
50
51#define COD_HID_KEYBOARD        0x0540
52#define COD_HID_POINTING        0x0580
53#define COD_HID_COMBO           0x05C0
54#define COD_HID_MAJOR           0x0500
55
56#define KEYSTATE_FILEPATH "/data/misc/bluedroid/bt_hh_ks" //keep this in sync with HID host jni
57
58#define HID_REPORT_CAPSLOCK   0x39
59#define HID_REPORT_NUMLOCK    0x53
60#define HID_REPORT_SCROLLLOCK 0x47
61
62//For Apple Magic Mouse
63#define MAGICMOUSE_VENDOR_ID 0x05ac
64#define MAGICMOUSE_PRODUCT_ID 0x030d
65
66#define LOGITECH_KB_MX5500_VENDOR_ID  0x046D
67#define LOGITECH_KB_MX5500_PRODUCT_ID 0xB30B
68
69extern const int BT_UID;
70extern const int BT_GID;
71static int btif_hh_prev_keyevents=0; //The previous key events
72static int btif_hh_keylockstates=0; //The current key state of each key
73
74#define BTIF_HH_ID_1        0
75#define BTIF_HH_DEV_DISCONNECTED 3
76
77#define BTIF_TIMEOUT_VUP_SECS   3
78
79
80#ifndef BTUI_HH_SECURITY
81#define BTUI_HH_SECURITY (BTA_SEC_AUTHENTICATE | BTA_SEC_ENCRYPT)
82#endif
83
84#ifndef BTUI_HH_MOUSE_SECURITY
85#define BTUI_HH_MOUSE_SECURITY (BTA_SEC_NONE)
86#endif
87
88/* HH request events */
89typedef enum
90{
91    BTIF_HH_CONNECT_REQ_EVT = 0,
92    BTIF_HH_DISCONNECT_REQ_EVT,
93    BTIF_HH_VUP_REQ_EVT
94} btif_hh_req_evt_t;
95
96
97/************************************************************************************
98**  Constants & Macros
99************************************************************************************/
100#define BTIF_HH_SERVICES    (BTA_HID_SERVICE_MASK)
101
102
103
104/************************************************************************************
105**  Local type definitions
106************************************************************************************/
107
108typedef struct hid_kb_list
109{
110    UINT16 product_id;
111    UINT16 version_id;
112    char*  kb_name;
113} tHID_KB_LIST;
114
115/************************************************************************************
116**  Static variables
117************************************************************************************/
118btif_hh_cb_t btif_hh_cb;
119
120static bthh_callbacks_t *bt_hh_callbacks = NULL;
121
122/* List of HID keyboards for which the NUMLOCK state needs to be
123 * turned ON by default. Add devices to this list to apply the
124 * NUMLOCK state toggle on fpr first connect.*/
125static tHID_KB_LIST hid_kb_numlock_on_list[] =
126{
127    {LOGITECH_KB_MX5500_PRODUCT_ID,
128    LOGITECH_KB_MX5500_VENDOR_ID,
129    "Logitech MX5500 Keyboard"}
130};
131
132
133#define CHECK_BTHH_INIT() if (bt_hh_callbacks == NULL)\
134    {\
135        BTIF_TRACE_WARNING1("BTHH: %s: BTHH not initialized", __FUNCTION__);\
136        return BT_STATUS_NOT_READY;\
137    }\
138    else\
139    {\
140        BTIF_TRACE_EVENT1("BTHH: %s", __FUNCTION__);\
141    }
142
143
144
145/************************************************************************************
146**  Static functions
147************************************************************************************/
148
149/************************************************************************************
150**  Externs
151************************************************************************************/
152extern void bta_hh_co_destroy(int fd);
153extern void bta_hh_co_write(int fd, UINT8* rpt, UINT16 len);
154extern bt_status_t btif_dm_remove_bond(const bt_bdaddr_t *bd_addr);
155extern void bta_hh_co_send_hid_info(btif_hh_device_t *p_dev, char *dev_name, UINT16 vendor_id,
156                                    UINT16 product_id, UINT16 version, UINT8 ctry_code,
157                                    int dscp_len, UINT8 *p_dscp);
158extern BOOLEAN check_cod(const bt_bdaddr_t *remote_bdaddr, uint32_t cod);
159extern void btif_dm_cb_remove_bond(bt_bdaddr_t *bd_addr);
160extern BOOLEAN check_cod_hid(const bt_bdaddr_t *remote_bdaddr, uint32_t cod);
161extern int  scru_ascii_2_hex(char *p_ascii, int len, UINT8 *p_hex);
162
163/*****************************************************************************
164**  Local Function prototypes
165*****************************************************************************/
166static void set_keylockstate(int keymask, BOOLEAN isSet);
167static void toggle_os_keylockstates(int fd, int changedkeystates);
168static void sync_lockstate_on_connect(btif_hh_device_t *p_dev);
169//static void hh_update_keyboard_lockstates(btif_hh_device_t *p_dev);
170void btif_hh_tmr_hdlr(TIMER_LIST_ENT *tle);
171
172
173/************************************************************************************
174**  Functions
175************************************************************************************/
176
177static int get_keylockstates()
178{
179    return btif_hh_keylockstates;
180}
181
182static void set_keylockstate(int keymask, BOOLEAN isSet)
183{
184    if(isSet)
185        btif_hh_keylockstates |= keymask;
186}
187
188/*******************************************************************************
189**
190** Function         toggle_os_keylockstates
191**
192** Description      Function to toggle the keyboard lock states managed by the linux.
193**                  This function is used in by two call paths
194**                  (1) if the lock state change occurred from an onscreen keyboard,
195**                  this function is called to update the lock state maintained
196                    for the HID keyboard(s)
197**                  (2) if a HID keyboard is disconnected and reconnected,
198**                  this function is called to update the lock state maintained
199                    for the HID keyboard(s)
200** Returns          void
201*******************************************************************************/
202
203static void toggle_os_keylockstates(int fd, int changedlockstates)
204{
205    BTIF_TRACE_EVENT3("%s: fd = %d, changedlockstates = 0x%x",
206        __FUNCTION__, fd, changedlockstates);
207    UINT8 hidreport[9];
208    int reportIndex;
209    memset(hidreport,0,9);
210    hidreport[0]=1;
211    reportIndex=4;
212
213    if (changedlockstates & BTIF_HH_KEYSTATE_MASK_CAPSLOCK) {
214        BTIF_TRACE_DEBUG1("%s Setting CAPSLOCK", __FUNCTION__);
215        hidreport[reportIndex++] = (UINT8)HID_REPORT_CAPSLOCK;
216    }
217
218    if (changedlockstates & BTIF_HH_KEYSTATE_MASK_NUMLOCK)  {
219        BTIF_TRACE_DEBUG1("%s Setting NUMLOCK", __FUNCTION__);
220        hidreport[reportIndex++] = (UINT8)HID_REPORT_NUMLOCK;
221    }
222
223    if (changedlockstates & BTIF_HH_KEYSTATE_MASK_SCROLLLOCK) {
224        BTIF_TRACE_DEBUG1("%s Setting SCROLLLOCK", __FUNCTION__);
225        hidreport[reportIndex++] = (UINT8) HID_REPORT_SCROLLLOCK;
226    }
227
228     BTIF_TRACE_DEBUG4("Writing hidreport #1 to os: "\
229        "%s:  %x %x %x", __FUNCTION__,
230         hidreport[0], hidreport[1], hidreport[2]);
231    BTIF_TRACE_DEBUG4("%s:  %x %x %x", __FUNCTION__,
232         hidreport[3], hidreport[4], hidreport[5]);
233    BTIF_TRACE_DEBUG4("%s:  %x %x %x", __FUNCTION__,
234         hidreport[6], hidreport[7], hidreport[8]);
235    bta_hh_co_write(fd , hidreport, sizeof(hidreport));
236    usleep(200000);
237    memset(hidreport,0,9);
238    hidreport[0]=1;
239    BTIF_TRACE_DEBUG4("Writing hidreport #2 to os: "\
240       "%s:  %x %x %x", __FUNCTION__,
241         hidreport[0], hidreport[1], hidreport[2]);
242    BTIF_TRACE_DEBUG4("%s:  %x %x %x", __FUNCTION__,
243         hidreport[3], hidreport[4], hidreport[5]);
244    BTIF_TRACE_DEBUG4("%s:  %x %x %x ", __FUNCTION__,
245         hidreport[6], hidreport[7], hidreport[8]);
246    bta_hh_co_write(fd , hidreport, sizeof(hidreport));
247}
248
249/*******************************************************************************
250**
251** Function         update_keyboard_lockstates
252**
253** Description      Sends a report to the keyboard to set the lock states of keys
254**
255*******************************************************************************/
256static void update_keyboard_lockstates(btif_hh_device_t *p_dev)
257{
258    UINT8 len = 2;  /* reportid + 1 byte report*/
259    BD_ADDR* bda;
260
261    /* Set report for other keyboards */
262    BTIF_TRACE_EVENT3("%s: setting report on dev_handle %d to 0x%x",
263         __FUNCTION__, p_dev->dev_handle, btif_hh_keylockstates);
264
265    if (p_dev->p_buf != NULL) {
266        GKI_freebuf(p_dev->p_buf);
267    }
268    /* Get SetReport buffer */
269    p_dev->p_buf = GKI_getbuf((UINT16) (len + BTA_HH_MIN_OFFSET +
270        sizeof(BT_HDR)));
271    if (p_dev->p_buf != NULL) {
272        p_dev->p_buf->len = len;
273        p_dev->p_buf->offset = BTA_HH_MIN_OFFSET;
274        p_dev->p_buf->layer_specific = BTA_HH_RPTT_OUTPUT;
275
276        /* LED status updated by data event */
277        UINT8 *pbuf_data  = (UINT8 *)(p_dev->p_buf + 1)
278            + p_dev->p_buf->offset;
279        pbuf_data[0]=0x01; /*report id */
280        pbuf_data[1]=btif_hh_keylockstates; /*keystate*/
281        bda = (BD_ADDR*) (&p_dev->bd_addr);
282        BTA_HhSendData(p_dev->dev_handle, *bda,
283            p_dev->p_buf);
284    }
285}
286
287/*******************************************************************************
288**
289** Function         sync_lockstate_on_connect
290**
291** Description      Function to update the keyboard lock states managed by the OS
292**                  when a HID keyboard is connected or disconnected and reconnected
293** Returns          void
294*******************************************************************************/
295static void sync_lockstate_on_connect(btif_hh_device_t *p_dev)
296{
297    int keylockstates;
298
299    BTIF_TRACE_EVENT1("%s: Syncing keyboard lock states after "\
300        "reconnect...",__FUNCTION__);
301    /*If the device is connected, update keyboard state */
302    update_keyboard_lockstates(p_dev);
303
304    /*Check if the lockstate of caps,scroll,num is set.
305     If so, send a report to the kernel
306    so the lockstate is in sync */
307    keylockstates = get_keylockstates();
308    if (keylockstates)
309    {
310        BTIF_TRACE_DEBUG2("%s: Sending hid report to kernel "\
311            "indicating lock key state 0x%x",__FUNCTION__,
312            keylockstates);
313        usleep(200000);
314        toggle_os_keylockstates(p_dev->fd, keylockstates);
315    }
316    else
317    {
318        BTIF_TRACE_DEBUG2("%s: NOT sending hid report to kernel "\
319            "indicating lock key state 0x%x",__FUNCTION__,
320            keylockstates);
321    }
322}
323
324/*******************************************************************************
325**
326** Function         btif_hh_find_dev_by_handle
327**
328** Description      Return the device pointer of the specified device handle
329**
330** Returns          Device entry pointer in the device table
331*******************************************************************************/
332static btif_hh_device_t *btif_hh_find_dev_by_handle(UINT8 handle)
333{
334    UINT32 i;
335    // LOGV("%s: handle = %d", __FUNCTION__, handle);
336    for (i = 0; i < BTIF_HH_MAX_HID; i++) {
337        if (btif_hh_cb.devices[i].dev_status != BTHH_CONN_STATE_UNKNOWN &&
338            btif_hh_cb.devices[i].dev_handle == handle)
339        {
340            return &btif_hh_cb.devices[i];
341        }
342    }
343    return NULL;
344}
345
346
347/*******************************************************************************
348**
349** Function         btif_hh_find_connected_dev_by_handle
350**
351** Description      Return the connected device pointer of the specified device handle
352**
353** Returns          Device entry pointer in the device table
354*******************************************************************************/
355btif_hh_device_t *btif_hh_find_connected_dev_by_handle(UINT8 handle)
356{
357    UINT32 i;
358    for (i = 0; i < BTIF_HH_MAX_HID; i++) {
359        if (btif_hh_cb.devices[i].dev_status == BTHH_CONN_STATE_CONNECTED &&
360            btif_hh_cb.devices[i].dev_handle == handle)
361        {
362            return &btif_hh_cb.devices[i];
363        }
364    }
365    return NULL;
366}
367
368/*******************************************************************************
369**
370** Function         btif_hh_find_dev_by_bda
371**
372** Description      Return the device pointer of the specified bt_bdaddr_t.
373**
374** Returns          Device entry pointer in the device table
375*******************************************************************************/
376static btif_hh_device_t *btif_hh_find_dev_by_bda(bt_bdaddr_t *bd_addr)
377{
378    UINT32 i;
379    for (i = 0; i < BTIF_HH_MAX_HID; i++) {
380        if (btif_hh_cb.devices[i].dev_status != BTHH_CONN_STATE_UNKNOWN &&
381            memcmp(&(btif_hh_cb.devices[i].bd_addr), bd_addr, BD_ADDR_LEN) == 0)
382        {
383            return &btif_hh_cb.devices[i];
384        }
385    }
386    return NULL;
387}
388
389/*******************************************************************************
390**
391** Function         btif_hh_find_connected_dev_by_bda
392**
393** Description      Return the connected device pointer of the specified bt_bdaddr_t.
394**
395** Returns          Device entry pointer in the device table
396*******************************************************************************/
397static btif_hh_device_t *btif_hh_find_connected_dev_by_bda(bt_bdaddr_t *bd_addr)
398{
399    UINT32 i;
400    for (i = 0; i < BTIF_HH_MAX_HID; i++) {
401        if (btif_hh_cb.devices[i].dev_status == BTHH_CONN_STATE_CONNECTED &&
402            memcmp(&(btif_hh_cb.devices[i].bd_addr), bd_addr, BD_ADDR_LEN) == 0)
403        {
404            return &btif_hh_cb.devices[i];
405        }
406    }
407    return NULL;
408}
409
410/*******************************************************************************
411**
412** Function      btif_hh_stop_vup_timer
413**
414** Description  stop vitual unplug timer
415**
416** Returns      void
417*******************************************************************************/
418void btif_hh_stop_vup_timer(bt_bdaddr_t *bd_addr)
419{
420    btif_hh_device_t *p_dev  = btif_hh_find_connected_dev_by_bda(bd_addr);
421    if(p_dev != NULL)
422    {
423        if (p_dev->vup_timer_active)
424        {
425            BTIF_TRACE_DEBUG0("stop VUP timer ");
426            btu_stop_timer(&p_dev->vup_timer);
427        }
428        p_dev->vup_timer_active = FALSE;
429    }
430}
431/*******************************************************************************
432**
433** Function      btif_hh_start_vup_timer
434**
435** Description  start virtual unplug timer
436**
437** Returns      void
438*******************************************************************************/
439void btif_hh_start_vup_timer(bt_bdaddr_t *bd_addr)
440{
441    btif_hh_device_t *p_dev  = btif_hh_find_connected_dev_by_bda(bd_addr);
442
443    if (p_dev->vup_timer_active == FALSE)
444    {
445        BTIF_TRACE_DEBUG0("Start VUP timer ");
446        memset(&p_dev->vup_timer, 0, sizeof(TIMER_LIST_ENT));
447        p_dev->vup_timer.param = (UINT32)btif_hh_tmr_hdlr;
448        btu_start_timer(&p_dev->vup_timer, BTU_TTYPE_USER_FUNC,
449                        BTIF_TIMEOUT_VUP_SECS);
450    }
451    else
452    {
453        BTIF_TRACE_DEBUG0("Restart VUP timer ");
454        btu_stop_timer(&p_dev->vup_timer);
455        btu_start_timer(&p_dev->vup_timer, BTU_TTYPE_USER_FUNC,
456                        BTIF_TIMEOUT_VUP_SECS);
457    }
458        p_dev->vup_timer_active = TRUE;
459
460}
461
462/*******************************************************************************
463**
464** Function         btif_hh_add_added_dev
465**
466** Description      Add a new device to the added device list.
467**
468** Returns          TRUE if add successfully, otherwise FALSE.
469*******************************************************************************/
470BOOLEAN btif_hh_add_added_dev(bt_bdaddr_t bda, tBTA_HH_ATTR_MASK attr_mask)
471{
472    int i;
473    for (i = 0; i < BTIF_HH_MAX_ADDED_DEV; i++) {
474        if (memcmp(&(btif_hh_cb.added_devices[i].bd_addr), &bda, BD_ADDR_LEN) == 0) {
475            BTIF_TRACE_WARNING6(" Device %02X:%02X:%02X:%02X:%02X:%02X already added",
476                  bda.address[0], bda.address[1], bda.address[2], bda.address[3], bda.address[4], bda.address[5]);
477            return FALSE;
478        }
479    }
480    for (i = 0; i < BTIF_HH_MAX_ADDED_DEV; i++) {
481        if (btif_hh_cb.added_devices[i].bd_addr.address[0] == 0 &&
482            btif_hh_cb.added_devices[i].bd_addr.address[1] == 0 &&
483            btif_hh_cb.added_devices[i].bd_addr.address[2] == 0 &&
484            btif_hh_cb.added_devices[i].bd_addr.address[3] == 0 &&
485            btif_hh_cb.added_devices[i].bd_addr.address[4] == 0 &&
486            btif_hh_cb.added_devices[i].bd_addr.address[5] == 0)
487        {
488            BTIF_TRACE_WARNING6(" Added device %02X:%02X:%02X:%02X:%02X:%02X",
489                  bda.address[0], bda.address[1], bda.address[2], bda.address[3], bda.address[4], bda.address[5]);
490            memcpy(&(btif_hh_cb.added_devices[i].bd_addr), &bda, BD_ADDR_LEN);
491            btif_hh_cb.added_devices[i].dev_handle = BTA_HH_INVALID_HANDLE;
492            btif_hh_cb.added_devices[i].attr_mask  = attr_mask;
493            return TRUE;
494        }
495    }
496
497    BTIF_TRACE_WARNING1("%s: Error, out of space to add device",__FUNCTION__);
498    return FALSE;
499}
500
501/*******************************************************************************
502 **
503 ** Function         btif_hh_remove_device
504 **
505 ** Description      Remove an added device from the stack.
506 **
507 ** Returns          void
508 *******************************************************************************/
509void btif_hh_remove_device(bt_bdaddr_t bd_addr)
510{
511    int                    i;
512    btif_hh_device_t       *p_dev;
513    btif_hh_added_device_t *p_added_dev;
514
515    ALOGI("%s: bda = %02x:%02x:%02x:%02x:%02x:%02x", __FUNCTION__,
516         bd_addr.address[0], bd_addr.address[1], bd_addr.address[2], bd_addr.address[3], bd_addr.address[4], bd_addr.address[5]);
517
518    for (i = 0; i < BTIF_HH_MAX_ADDED_DEV; i++) {
519        p_added_dev = &btif_hh_cb.added_devices[i];
520        if (memcmp(&(p_added_dev->bd_addr),&bd_addr, 6) == 0) {
521            BTA_HhRemoveDev(p_added_dev->dev_handle);
522            btif_storage_remove_hid_info(&(p_added_dev->bd_addr));
523            memset(&(p_added_dev->bd_addr), 0, 6);
524            p_added_dev->dev_handle = BTA_HH_INVALID_HANDLE;
525            break;
526        }
527    }
528
529    p_dev = btif_hh_find_dev_by_bda(&bd_addr);
530    if (p_dev == NULL) {
531        BTIF_TRACE_WARNING6(" Oops, can't find device [%02x:%02x:%02x:%02x:%02x:%02x]",
532             bd_addr.address[0], bd_addr.address[1], bd_addr.address[2], bd_addr.address[3], bd_addr.address[4], bd_addr.address[5]);
533        return;
534    }
535
536    p_dev->dev_status = BTHH_CONN_STATE_UNKNOWN;
537    p_dev->dev_handle = BTA_HH_INVALID_HANDLE;
538    if (btif_hh_cb.device_num > 0) {
539        btif_hh_cb.device_num--;
540    }
541    else {
542        BTIF_TRACE_WARNING1("%s: device_num = 0", __FUNCTION__);
543    }
544    if (p_dev->p_buf != NULL) {
545        GKI_freebuf(p_dev->p_buf);
546        p_dev->p_buf = NULL;
547    }
548
549    p_dev->hh_keep_polling = 0;
550    p_dev->hh_poll_thread_id = -1;
551    BTIF_TRACE_DEBUG2("%s: uhid fd = %d", __FUNCTION__, p_dev->fd);
552    if (p_dev->fd >= 0) {
553        bta_hh_co_destroy(p_dev->fd);
554        p_dev->fd = -1;
555    }
556}
557
558
559BOOLEAN btif_hh_copy_hid_info(tBTA_HH_DEV_DSCP_INFO* dest , tBTA_HH_DEV_DSCP_INFO* src)
560{
561    dest->descriptor.dl_len = 0;
562    if (src->descriptor.dl_len >0)
563    {
564        dest->descriptor.dsc_list = (UINT8 *) GKI_getbuf(src->descriptor.dl_len);
565        if (dest->descriptor.dsc_list == NULL)
566        {
567            BTIF_TRACE_WARNING1("%s: Failed to allocate DSCP for CB", __FUNCTION__);
568            return FALSE;
569        }
570    }
571    memcpy(dest->descriptor.dsc_list, src->descriptor.dsc_list, src->descriptor.dl_len);
572    dest->descriptor.dl_len = src->descriptor.dl_len;
573    dest->vendor_id  = src->vendor_id;
574    dest->product_id = src->product_id;
575    dest->version    = src->version;
576    dest->ctry_code  = src->ctry_code;
577    return TRUE;
578}
579
580
581/*******************************************************************************
582**
583** Function         btif_hh_virtual_unplug
584**
585** Description      Virtual unplug initiated from the BTIF thread context
586**                  Special handling for HID mouse-
587**
588** Returns          void
589**
590*******************************************************************************/
591
592bt_status_t btif_hh_virtual_unplug(bt_bdaddr_t *bd_addr)
593{
594    BTIF_TRACE_DEBUG1("%s", __FUNCTION__);
595    btif_hh_device_t *p_dev;
596    char bd_str[18];
597    sprintf(bd_str, "%02X:%02X:%02X:%02X:%02X:%02X",
598            bd_addr->address[0],  bd_addr->address[1],  bd_addr->address[2],  bd_addr->address[3],
599            bd_addr->address[4], bd_addr->address[5]);
600    p_dev = btif_hh_find_dev_by_bda(bd_addr);
601    if ((p_dev != NULL) && (p_dev->dev_status == BTHH_CONN_STATE_CONNECTED)
602        && (p_dev->attr_mask & HID_VIRTUAL_CABLE))
603    {
604        BTIF_TRACE_DEBUG1("%s Sending BTA_HH_CTRL_VIRTUAL_CABLE_UNPLUG", __FUNCTION__);
605        /* start the timer */
606        btif_hh_start_vup_timer(bd_addr);
607        p_dev->local_vup = TRUE;
608        BTA_HhSendCtrl(p_dev->dev_handle, BTA_HH_CTRL_VIRTUAL_CABLE_UNPLUG);
609        return BT_STATUS_SUCCESS;
610    }
611    else
612    {
613        BTIF_TRACE_ERROR2("%s: Error, device %s not opened.", __FUNCTION__, bd_str);
614        return BT_STATUS_FAIL;
615    }
616}
617
618/*******************************************************************************
619**
620** Function         btif_hh_connect
621**
622** Description      connection initiated from the BTIF thread context
623**
624** Returns          int status
625**
626*******************************************************************************/
627
628bt_status_t btif_hh_connect(bt_bdaddr_t *bd_addr)
629{
630    btif_hh_device_t *dev;
631    btif_hh_added_device_t *added_dev = NULL;
632    char bda_str[20];
633    int i;
634    BD_ADDR *bda = (BD_ADDR*)bd_addr;
635    tBTA_HH_CONN conn;
636    CHECK_BTHH_INIT();
637    dev = btif_hh_find_dev_by_bda(bd_addr);
638    BTIF_TRACE_DEBUG0("Connect _hh");
639    sprintf(bda_str, "%02X:%02X:%02X:%02X:%02X:%02X",
640            (*bda)[0], (*bda)[1], (*bda)[2], (*bda)[3], (*bda)[4], (*bda)[5]);
641    if (dev == NULL && btif_hh_cb.device_num >= BTIF_HH_MAX_HID) {
642        // No space for more HID device now.
643         BTIF_TRACE_WARNING2("%s: Error, exceeded the maximum supported HID device number %d",
644             __FUNCTION__, BTIF_HH_MAX_HID);
645        return BT_STATUS_FAIL;
646    }
647
648    for (i = 0; i < BTIF_HH_MAX_ADDED_DEV; i++) {
649        if (memcmp(&(btif_hh_cb.added_devices[i].bd_addr), bd_addr, BD_ADDR_LEN) == 0) {
650            added_dev = &btif_hh_cb.added_devices[i];
651             BTIF_TRACE_WARNING3("%s: Device %s already added, attr_mask = 0x%x",
652                 __FUNCTION__, bda_str, added_dev->attr_mask);
653        }
654    }
655
656    if (added_dev != NULL) {
657        if (added_dev->dev_handle == BTA_HH_INVALID_HANDLE) {
658            // No space for more HID device now.
659            BTIF_TRACE_ERROR2("%s: Error, device %s added but addition failed", __FUNCTION__, bda_str);
660            memset(&(added_dev->bd_addr), 0, 6);
661            added_dev->dev_handle = BTA_HH_INVALID_HANDLE;
662            return BT_STATUS_FAIL;
663        }
664    }
665
666    if (added_dev == NULL ||
667        (added_dev->attr_mask & HID_NORMALLY_CONNECTABLE) != 0 ||
668        (added_dev->attr_mask & HID_RECONN_INIT) == 0)
669    {
670        tBTA_SEC sec_mask = BTUI_HH_SECURITY;
671        btif_hh_cb.status = BTIF_HH_DEV_CONNECTING;
672        BD_ADDR *bda = (BD_ADDR*)bd_addr;
673        BTA_HhOpen(*bda, BTA_HH_PROTO_RPT_MODE, sec_mask);
674    }
675    else
676    {
677        // This device shall be connected from the host side.
678        BTIF_TRACE_ERROR2("%s: Error, device %s can only be reconnected from device side",
679             __FUNCTION__, bda_str);
680        return BT_STATUS_FAIL;
681    }
682
683    HAL_CBACK(bt_hh_callbacks, connection_state_cb, bd_addr, BTHH_CONN_STATE_CONNECTING);
684    return BT_STATUS_SUCCESS;
685}
686
687/*******************************************************************************
688**
689** Function         btif_hh_disconnect
690**
691** Description      disconnection initiated from the BTIF thread context
692**
693** Returns          void
694**
695*******************************************************************************/
696
697void btif_hh_disconnect(bt_bdaddr_t *bd_addr)
698{
699    BD_ADDR *bda = (BD_ADDR*)bd_addr;
700    btif_hh_device_t *p_dev;
701    p_dev = btif_hh_find_connected_dev_by_bda(bd_addr);
702    if (p_dev != NULL)
703    {
704        BTA_HhClose(p_dev->dev_handle);
705    }
706    else
707        BTIF_TRACE_DEBUG1("%s-- Error: device not connected:",__FUNCTION__);
708}
709
710/*******************************************************************************
711**
712** Function         btif_btif_hh_setreport
713**
714** Description      setreport initiated from the BTIF thread context
715**
716** Returns          void
717**
718*******************************************************************************/
719
720void btif_hh_setreport(btif_hh_device_t *p_dev, bthh_report_type_t r_type, UINT16 size,
721                            UINT8* report)
722{
723    UINT8  hexbuf[20];
724    UINT16 len = size;
725    int i = 0;
726    if (p_dev->p_buf != NULL) {
727        GKI_freebuf(p_dev->p_buf);
728    }
729    p_dev->p_buf = GKI_getbuf((UINT16) (len + BTA_HH_MIN_OFFSET + sizeof(BT_HDR)));
730    if (p_dev->p_buf == NULL) {
731        APPL_TRACE_ERROR2("%s: Error, failed to allocate RPT buffer, len = %d", __FUNCTION__, len);
732        return;
733    }
734
735    p_dev->p_buf->len = len;
736    p_dev->p_buf->offset = BTA_HH_MIN_OFFSET;
737
738    //Build a SetReport data buffer
739    memset(hexbuf, 0, 20);
740    for(i=0; i<len; i++)
741        hexbuf[i] = report[i];
742
743    UINT8* pbuf_data;
744    pbuf_data = (UINT8*) (p_dev->p_buf + 1) + p_dev->p_buf->offset;
745    memcpy(pbuf_data, hexbuf, len);
746    BTA_HhSetReport(p_dev->dev_handle, r_type, p_dev->p_buf);
747
748}
749
750/*****************************************************************************
751**   Section name (Group of functions)
752*****************************************************************************/
753
754/*****************************************************************************
755**
756**   btif hh api functions (no context switch)
757**
758*****************************************************************************/
759
760
761/*******************************************************************************
762**
763** Function         btif_hh_upstreams_evt
764**
765** Description      Executes HH UPSTREAMS events in btif context
766**
767** Returns          void
768**
769*******************************************************************************/
770static void btif_hh_upstreams_evt(UINT16 event, char* p_param)
771{
772    tBTA_HH *p_data = (tBTA_HH *)p_param;
773    bdstr_t bdstr;
774    btif_hh_device_t *p_dev = NULL;
775    int i;
776    int len, tmplen;
777
778    BTIF_TRACE_DEBUG2("%s: event=%s", __FUNCTION__, dump_hh_event(event));
779
780    switch (event)
781    {
782        case BTA_HH_ENABLE_EVT:
783            BTIF_TRACE_DEBUG2("%s: BTA_HH_ENABLE_EVT: status =%d",__FUNCTION__, p_data->status);
784            if (p_data->status == BTA_HH_OK) {
785                btif_hh_cb.status = BTIF_HH_ENABLED;
786                BTIF_TRACE_DEBUG1("%s--Loading added devices",__FUNCTION__);
787                /* Add hid descriptors for already bonded hid devices*/
788                btif_storage_load_bonded_hid_info();
789            }
790            else {
791                btif_hh_cb.status = BTIF_HH_DISABLED;
792                BTIF_TRACE_WARNING1("BTA_HH_ENABLE_EVT: Error, HH enabling failed, status = %d", p_data->status);
793            }
794            break;
795
796        case BTA_HH_DISABLE_EVT:
797            btif_hh_cb.status = BTIF_HH_DISABLED;
798            if (p_data->status == BTA_HH_OK) {
799                int i;
800                //Clear the control block
801                memset(&btif_hh_cb, 0, sizeof(btif_hh_cb));
802                for (i = 0; i < BTIF_HH_MAX_HID; i++){
803                    btif_hh_cb.devices[i].dev_status = BTHH_CONN_STATE_UNKNOWN;
804                }
805            }
806            else
807                BTIF_TRACE_WARNING1("BTA_HH_DISABLE_EVT: Error, HH disabling failed, status = %d", p_data->status);
808            break;
809
810        case BTA_HH_OPEN_EVT:
811            BTIF_TRACE_WARNING3("%s: BTA_HH_OPN_EVT: handle=%d, status =%d",__FUNCTION__, p_data->conn.handle, p_data->conn.status);
812            if (p_data->conn.status == BTA_HH_OK) {
813                p_dev = btif_hh_find_connected_dev_by_handle(p_data->conn.handle);
814                if (p_dev == NULL) {
815                    BTIF_TRACE_WARNING1("BTA_HH_OPEN_EVT: Error, cannot find device with handle %d", p_data->conn.handle);
816                    btif_hh_cb.status = BTIF_HH_DEV_DISCONNECTED;
817                    // The connect request must come from device side and exceeded the connected
818                                   // HID device number.
819                    BTA_HhClose(p_data->conn.handle);
820                    HAL_CBACK(bt_hh_callbacks, connection_state_cb, (bt_bdaddr_t*) &p_data->conn.bda,BTHH_CONN_STATE_DISCONNECTED);
821                }
822                else if (p_dev->fd < 0) {
823                    BTIF_TRACE_WARNING0("BTA_HH_OPEN_EVT: Error, failed to find the uhid driver...");
824                    memcpy(&(p_dev->bd_addr), p_data->conn.bda, BD_ADDR_LEN);
825                    //remove the connection  and then try again to reconnect from the mouse side to recover
826                    btif_hh_cb.status = BTIF_HH_DEV_DISCONNECTED;
827                    BTA_HhClose(p_data->conn.handle);
828                }
829                else {
830                    BTIF_TRACE_WARNING1("BTA_HH_OPEN_EVT: Found device...Getting dscp info for handle ... %d",p_data->conn.handle);
831                    memcpy(&(p_dev->bd_addr), p_data->conn.bda, BD_ADDR_LEN);
832                    btif_hh_cb.status = BTIF_HH_DEV_CONNECTED;
833                    // Send set_idle if the peer_device is a keyboard
834                    if (check_cod((bt_bdaddr_t*)p_data->conn.bda, COD_HID_KEYBOARD )||
835                                check_cod((bt_bdaddr_t*)p_data->conn.bda, COD_HID_COMBO))
836                        BTA_HhSetIdle(p_data->conn.handle, 0);
837                    btif_hh_cb.p_curr_dev = btif_hh_find_connected_dev_by_handle(p_data->conn.handle);
838                    BTA_HhGetDscpInfo(p_data->conn.handle);
839                    p_dev->dev_status = BTHH_CONN_STATE_CONNECTED;
840                    HAL_CBACK(bt_hh_callbacks, connection_state_cb,&(p_dev->bd_addr), p_dev->dev_status);
841                }
842            }
843            else {
844                bt_bdaddr_t *bdaddr = (bt_bdaddr_t*)p_data->conn.bda;
845                HAL_CBACK(bt_hh_callbacks, connection_state_cb, (bt_bdaddr_t*) &p_data->conn.bda,BTHH_CONN_STATE_DISCONNECTED);
846                btif_hh_cb.status = BTIF_HH_DEV_DISCONNECTED;
847            }
848            break;
849        case BTA_HH_CLOSE_EVT:
850            BTIF_TRACE_DEBUG2("BTA_HH_CLOSE_EVT: status = %d, handle = %d",
851            p_data->dev_status.status, p_data->dev_status.handle);
852            p_dev = btif_hh_find_connected_dev_by_handle(p_data->dev_status.handle);
853            if (p_dev != NULL) {
854                BTIF_TRACE_DEBUG2("%s: uhid fd = %d", __FUNCTION__, p_dev->fd);
855                if (p_dev->fd >= 0){
856                    UINT8 hidreport[9];
857                    memset(hidreport,0,9);
858                    hidreport[0]=1;
859                    bta_hh_co_write(p_dev->fd , hidreport, sizeof(hidreport));
860                }
861                if(p_dev->vup_timer_active)
862                {
863                    btif_hh_stop_vup_timer(&(p_dev->bd_addr));
864                }
865                btif_hh_cb.status = BTIF_HH_DEV_DISCONNECTED;
866                p_dev->dev_status = BTHH_CONN_STATE_DISCONNECTED;
867                HAL_CBACK(bt_hh_callbacks, connection_state_cb,&(p_dev->bd_addr), p_dev->dev_status);
868                BTIF_TRACE_DEBUG2("%s: Closing uhid fd = %d", __FUNCTION__, p_dev->fd);
869                bta_hh_co_destroy(p_dev->fd);
870                p_dev->fd = -1;
871            }
872            else {
873                BTIF_TRACE_WARNING1("Error: cannot find device with handle %d", p_data->dev_status.handle);
874            }
875            break;
876        case BTA_HH_GET_RPT_EVT:
877            BTIF_TRACE_DEBUG2("BTA_HH_GET_RPT_EVT: status = %d, handle = %d",
878                 p_data->hs_data.status, p_data->hs_data.handle);
879            p_dev = btif_hh_find_connected_dev_by_handle(p_data->conn.handle);
880            HAL_CBACK(bt_hh_callbacks, get_report_cb,(bt_bdaddr_t*) &(p_dev->bd_addr), (bthh_status_t) p_data->hs_data.status,
881                (uint8_t*) p_data->hs_data.rsp_data.p_rpt_data, BT_HDR_SIZE);
882            break;
883
884        case BTA_HH_SET_RPT_EVT:
885            BTIF_TRACE_DEBUG2("BTA_HH_SET_RPT_EVT: status = %d, handle = %d",
886            p_data->dev_status.status, p_data->dev_status.handle);
887            p_dev = btif_hh_find_connected_dev_by_handle(p_data->dev_status.handle);
888            if (p_dev != NULL && p_dev->p_buf != NULL) {
889                BTIF_TRACE_DEBUG0("Freeing buffer..." );
890                GKI_freebuf(p_dev->p_buf);
891                p_dev->p_buf = NULL;
892            }
893            break;
894
895        case BTA_HH_GET_PROTO_EVT:
896            p_dev = btif_hh_find_connected_dev_by_handle(p_data->dev_status.handle);
897            BTIF_TRACE_WARNING4("BTA_HH_GET_PROTO_EVT: status = %d, handle = %d, proto = [%d], %s",
898                 p_data->hs_data.status, p_data->hs_data.handle,
899                 p_data->hs_data.rsp_data.proto_mode,
900                 (p_data->hs_data.rsp_data.proto_mode == BTA_HH_PROTO_RPT_MODE) ? "Report Mode" :
901                 (p_data->hs_data.rsp_data.proto_mode == BTA_HH_PROTO_BOOT_MODE) ? "Boot Mode" : "Unsupported");
902            HAL_CBACK(bt_hh_callbacks, protocol_mode_cb,(bt_bdaddr_t*) &(p_dev->bd_addr), (bthh_status_t)p_data->hs_data.status,
903                             (bthh_protocol_mode_t) p_data->hs_data.rsp_data.proto_mode);
904            break;
905
906        case BTA_HH_SET_PROTO_EVT:
907            BTIF_TRACE_DEBUG2("BTA_HH_SET_PROTO_EVT: status = %d, handle = %d",
908                 p_data->dev_status.status, p_data->dev_status.handle);
909            break;
910
911        case BTA_HH_GET_IDLE_EVT:
912            BTIF_TRACE_DEBUG3("BTA_HH_GET_IDLE_EVT: handle = %d, status = %d, rate = %d",
913                 p_data->hs_data.handle, p_data->hs_data.status,
914                 p_data->hs_data.rsp_data.idle_rate);
915            break;
916
917        case BTA_HH_SET_IDLE_EVT:
918            BTIF_TRACE_DEBUG2("BTA_HH_SET_IDLE_EVT: status = %d, handle = %d",
919            p_data->dev_status.status, p_data->dev_status.handle);
920            break;
921
922        case BTA_HH_GET_DSCP_EVT:
923            BTIF_TRACE_WARNING2("BTA_HH_GET_DSCP_EVT: status = %d, handle = %d",
924                p_data->dev_status.status, p_data->dev_status.handle);
925                len = p_data->dscp_info.descriptor.dl_len;
926                BTIF_TRACE_DEBUG1("BTA_HH_GET_DSCP_EVT: len = %d", len);
927            p_dev = btif_hh_cb.p_curr_dev;
928            if (p_dev == NULL) {
929                BTIF_TRACE_ERROR0("BTA_HH_GET_DSCP_EVT: No HID device is currently connected");
930                return;
931            }
932            if (p_dev->fd < 0) {
933                ALOGE("BTA_HH_GET_DSCP_EVT: Error, failed to find the uhid driver...");
934                return;
935            }
936            {
937                char *cached_name = NULL;
938                char name[] = "Broadcom Bluetooth HID";
939                if (cached_name == NULL) {
940                    cached_name = name;
941                }
942
943                BTIF_TRACE_WARNING2("%s: name = %s", __FUNCTION__, cached_name);
944                bta_hh_co_send_hid_info(p_dev, cached_name,
945                    p_data->dscp_info.vendor_id, p_data->dscp_info.product_id,
946                    p_data->dscp_info.version,   p_data->dscp_info.ctry_code,
947                    len, p_data->dscp_info.descriptor.dsc_list);
948                if (btif_hh_add_added_dev(p_dev->bd_addr, p_dev->attr_mask)) {
949                    BD_ADDR bda;
950                    bdcpy(bda, p_dev->bd_addr.address);
951                    tBTA_HH_DEV_DSCP_INFO dscp_info;
952                    bt_status_t ret;
953                    bdcpy(bda, p_dev->bd_addr.address);
954                    btif_hh_copy_hid_info(&dscp_info, &p_data->dscp_info);
955                    BTIF_TRACE_DEBUG6("BTA_HH_GET_DSCP_EVT:bda = %02x:%02x:%02x:%02x:%02x:%02x",
956                              p_dev->bd_addr.address[0], p_dev->bd_addr.address[1],
957                              p_dev->bd_addr.address[2],p_dev->bd_addr.address[3],
958                              p_dev->bd_addr.address[4], p_dev->bd_addr.address[5]);
959                    BTA_HhAddDev(bda, p_dev->attr_mask,p_dev->sub_class,p_dev->app_id, dscp_info);
960                    // write hid info to nvram
961                    ret = btif_storage_add_hid_device_info(&(p_dev->bd_addr), p_dev->attr_mask,p_dev->sub_class,p_dev->app_id,
962                                                        p_data->dscp_info.vendor_id, p_data->dscp_info.product_id,
963                                                        p_data->dscp_info.version,   p_data->dscp_info.ctry_code,
964                                                        len, p_data->dscp_info.descriptor.dsc_list);
965
966                    ASSERTC(ret == BT_STATUS_SUCCESS, "storing hid info failed", ret);
967                    BTIF_TRACE_WARNING0("BTA_HH_GET_DSCP_EVT: Called add device");
968
969                    //Free buffer created for dscp_info;
970                    if (dscp_info.descriptor.dl_len >0 && dscp_info.descriptor.dsc_list != NULL)
971                    {
972                      GKI_freebuf(dscp_info.descriptor.dsc_list);
973                      dscp_info.descriptor.dsc_list = NULL;
974                      dscp_info.descriptor.dl_len=0;
975                    }
976                }
977                else {
978                    //Device already added.
979                    BTIF_TRACE_WARNING1("%s: Device already added ",__FUNCTION__);
980                }
981                /*Sync HID Keyboard lockstates */
982                tmplen = sizeof(hid_kb_numlock_on_list)
983                            / sizeof(tHID_KB_LIST);
984                for(i = 0; i< tmplen; i++)
985                {
986                    if(p_data->dscp_info.vendor_id
987                        == hid_kb_numlock_on_list[i].version_id &&
988                        p_data->dscp_info.product_id
989                        == hid_kb_numlock_on_list[i].product_id)
990                    {
991                        BTIF_TRACE_DEBUG3("%s() idx[%d] Enabling "\
992                            "NUMLOCK for device :: %s", __FUNCTION__,
993                            i, hid_kb_numlock_on_list[i].kb_name);
994                        /* Enable NUMLOCK by default so that numeric
995                            keys work from first keyboard connect */
996                        set_keylockstate(BTIF_HH_KEYSTATE_MASK_NUMLOCK,
997                                        TRUE);
998                        sync_lockstate_on_connect(p_dev);
999                        /* End Sync HID Keyboard lockstates */
1000                        break;
1001                    }
1002                }
1003            }
1004            break;
1005
1006        case BTA_HH_ADD_DEV_EVT:
1007            BTIF_TRACE_WARNING2("BTA_HH_ADD_DEV_EVT: status = %d, handle = %d",p_data->dev_info.status, p_data->dev_info.handle);
1008            int i;
1009            for (i = 0; i < BTIF_HH_MAX_ADDED_DEV; i++) {
1010                if (memcmp(btif_hh_cb.added_devices[i].bd_addr.address, p_data->dev_info.bda, 6) == 0) {
1011                    if (p_data->dev_info.status == BTA_HH_OK) {
1012                        btif_hh_cb.added_devices[i].dev_handle = p_data->dev_info.handle;
1013                    }
1014                    else {
1015                        memset(btif_hh_cb.added_devices[i].bd_addr.address, 0, 6);
1016                        btif_hh_cb.added_devices[i].dev_handle = BTA_HH_INVALID_HANDLE;
1017                    }
1018                    break;
1019                }
1020            }
1021            break;
1022        case BTA_HH_RMV_DEV_EVT:
1023                BTIF_TRACE_DEBUG2("BTA_HH_RMV_DEV_EVT: status = %d, handle = %d",
1024                     p_data->dev_info.status, p_data->dev_info.handle);
1025                BTIF_TRACE_DEBUG6("BTA_HH_RMV_DEV_EVT:bda = %02x:%02x:%02x:%02x:%02x:%02x",
1026                     p_data->dev_info.bda[0], p_data->dev_info.bda[1], p_data->dev_info.bda[2],
1027                     p_data->dev_info.bda[3], p_data->dev_info.bda[4], p_data->dev_info.bda[5]);
1028                break;
1029
1030
1031        case BTA_HH_VC_UNPLUG_EVT:
1032                BTIF_TRACE_DEBUG2("BTA_HH_VC_UNPLUG_EVT: status = %d, handle = %d",
1033                     p_data->dev_status.status, p_data->dev_status.handle);
1034                p_dev = btif_hh_find_connected_dev_by_handle(p_data->dev_status.handle);
1035                btif_hh_cb.status = BTIF_HH_DEV_DISCONNECTED;
1036                if (p_dev != NULL) {
1037                    BTIF_TRACE_DEBUG6("BTA_HH_VC_UNPLUG_EVT:bda = %02x:%02x:%02x:%02x:%02x:%02x",
1038                         p_dev->bd_addr.address[0], p_dev->bd_addr.address[1],
1039                         p_dev->bd_addr.address[2],p_dev->bd_addr.address[3],
1040                         p_dev->bd_addr.address[4], p_dev->bd_addr.address[5]);
1041                    /* Stop the VUP timer */
1042                    if(p_dev->vup_timer_active)
1043                    {
1044                        btif_hh_stop_vup_timer(&(p_dev->bd_addr));
1045                    }
1046                    p_dev->dev_status = BTHH_CONN_STATE_DISCONNECTED;
1047                    BTIF_TRACE_DEBUG1("%s---Sending connection state change", __FUNCTION__);
1048                    HAL_CBACK(bt_hh_callbacks, connection_state_cb,&(p_dev->bd_addr), p_dev->dev_status);
1049                    BTIF_TRACE_DEBUG1("%s---Removing HID bond", __FUNCTION__);
1050                    /* If it is locally initiated VUP or remote device has its major COD as
1051                    Peripheral removed the bond.*/
1052                    if (p_dev->local_vup  || check_cod_hid(&(p_dev->bd_addr), COD_HID_MAJOR))
1053                    {
1054                        p_dev->local_vup = FALSE;
1055                        BTA_DmRemoveDevice((UINT8 *)p_dev->bd_addr.address);
1056                    }
1057                    else
1058                        btif_hh_remove_device(p_dev->bd_addr);
1059                    HAL_CBACK(bt_hh_callbacks, virtual_unplug_cb,&(p_dev->bd_addr),
1060                                    p_data->dev_status.status);
1061                }
1062                break;
1063
1064        case BTA_HH_API_ERR_EVT  :
1065                ALOGI("BTA_HH API_ERR");
1066                break;
1067
1068
1069
1070            default:
1071                BTIF_TRACE_WARNING2("%s: Unhandled event: %d", __FUNCTION__, event);
1072                break;
1073        }
1074}
1075
1076/*******************************************************************************
1077**
1078** Function         bte_hh_evt
1079**
1080** Description      Switches context from BTE to BTIF for all HH events
1081**
1082** Returns          void
1083**
1084*******************************************************************************/
1085
1086static void bte_hh_evt(tBTA_HH_EVT event, tBTA_HH *p_data)
1087{
1088    bt_status_t status;
1089    int param_len = 0;
1090
1091    if (BTA_HH_ENABLE_EVT == event)
1092        param_len = sizeof(tBTA_HH_STATUS);
1093    else if (BTA_HH_OPEN_EVT == event)
1094        param_len = sizeof(tBTA_HH_CONN);
1095    else if (BTA_HH_DISABLE_EVT == event)
1096        param_len = sizeof(tBTA_HH_STATUS);
1097    else if (BTA_HH_CLOSE_EVT == event)
1098        param_len = sizeof(tBTA_HH_CBDATA);
1099    else if (BTA_HH_GET_DSCP_EVT == event)
1100        param_len = sizeof(tBTA_HH_DEV_DSCP_INFO);
1101    else if ((BTA_HH_GET_PROTO_EVT == event) || (BTA_HH_GET_RPT_EVT == event)|| (BTA_HH_GET_IDLE_EVT == event))
1102        param_len = sizeof(tBTA_HH_HSDATA);
1103    else if ((BTA_HH_SET_PROTO_EVT == event) || (BTA_HH_SET_RPT_EVT == event) || (BTA_HH_VC_UNPLUG_EVT == event) || (BTA_HH_SET_IDLE_EVT == event))
1104        param_len = sizeof(tBTA_HH_CBDATA);
1105    else if ((BTA_HH_ADD_DEV_EVT == event) || (BTA_HH_RMV_DEV_EVT == event) )
1106        param_len = sizeof(tBTA_HH_DEV_INFO);
1107    else if (BTA_HH_API_ERR_EVT == event)
1108        param_len = 0;
1109    /* switch context to btif task context (copy full union size for convenience) */
1110    status = btif_transfer_context(btif_hh_upstreams_evt, (uint16_t)event, (void*)p_data, param_len, NULL);
1111
1112    /* catch any failed context transfers */
1113    ASSERTC(status == BT_STATUS_SUCCESS, "context transfer failed", status);
1114}
1115
1116/*******************************************************************************
1117**
1118** Function         btif_hh_handle_evt
1119**
1120** Description      Switches context for immediate callback
1121**
1122** Returns          void
1123**
1124*******************************************************************************/
1125
1126static void btif_hh_handle_evt(UINT16 event, char *p_param)
1127{
1128    bt_bdaddr_t *bd_addr = (bt_bdaddr_t*)p_param;
1129    BTIF_TRACE_EVENT2("%s: event=%d", __FUNCTION__, event);
1130    int ret;
1131    switch(event)
1132    {
1133        case BTIF_HH_CONNECT_REQ_EVT:
1134        {
1135            ret = btif_hh_connect(bd_addr);
1136            if(ret == BT_STATUS_SUCCESS)
1137            {
1138                HAL_CBACK(bt_hh_callbacks, connection_state_cb,bd_addr,BTHH_CONN_STATE_CONNECTING);
1139            }
1140            else
1141                HAL_CBACK(bt_hh_callbacks, connection_state_cb,bd_addr,BTHH_CONN_STATE_DISCONNECTED);
1142        }
1143        break;
1144
1145        case BTIF_HH_DISCONNECT_REQ_EVT:
1146        {
1147            BTIF_TRACE_EVENT2("%s: event=%d", __FUNCTION__, event);
1148            btif_hh_disconnect(bd_addr);
1149            HAL_CBACK(bt_hh_callbacks, connection_state_cb,bd_addr,BTHH_CONN_STATE_DISCONNECTING);
1150        }
1151        break;
1152
1153        case BTIF_HH_VUP_REQ_EVT:
1154        {
1155            BTIF_TRACE_EVENT2("%s: event=%d", __FUNCTION__, event);
1156            ret = btif_hh_virtual_unplug(bd_addr);
1157        }
1158        break;
1159
1160        default:
1161        {
1162            BTIF_TRACE_WARNING2("%s : Unknown event 0x%x", __FUNCTION__, event);
1163        }
1164        break;
1165    }
1166}
1167
1168/*******************************************************************************
1169**
1170** Function      btif_hh_tmr_hdlr
1171**
1172** Description   Process timer timeout
1173**
1174** Returns      void
1175*******************************************************************************/
1176void btif_hh_tmr_hdlr(TIMER_LIST_ENT *tle)
1177{
1178    btif_hh_device_t *p_dev;
1179    UINT8               i,j;
1180    tBTA_HH_EVT event;
1181    tBTA_HH p_data;
1182    int param_len = 0;
1183    memset(&p_data, 0, sizeof(tBTA_HH));
1184
1185    BTIF_TRACE_DEBUG2("%s timer_in_use=%d",  __FUNCTION__, tle->in_use );
1186
1187    for (i = 0; i < BTIF_HH_MAX_HID; i++) {
1188        if (btif_hh_cb.devices[i].dev_status == BTHH_CONN_STATE_CONNECTED)
1189        {
1190
1191            p_dev = &btif_hh_cb.devices[i];
1192
1193            if (p_dev->vup_timer_active)
1194            {
1195                p_dev->vup_timer_active = FALSE;
1196                event = BTA_HH_VC_UNPLUG_EVT;
1197                p_data.dev_status.status = BTHH_ERR;
1198                p_data.dev_status.handle = p_dev->dev_handle;
1199                param_len = sizeof(tBTA_HH_CBDATA);
1200
1201                /* switch context to btif task context */
1202                btif_transfer_context(btif_hh_upstreams_evt, (uint16_t)event, (void*)&p_data,
1203                            param_len, NULL);
1204            }
1205        }
1206    }
1207}
1208
1209/*******************************************************************************
1210**
1211** Function         btif_hh_init
1212**
1213** Description     initializes the hh interface
1214**
1215** Returns         bt_status_t
1216**
1217*******************************************************************************/
1218static bt_status_t init( bthh_callbacks_t* callbacks )
1219{
1220    UINT32 i;
1221    BTIF_TRACE_EVENT1("%s", __FUNCTION__);
1222
1223    bt_hh_callbacks = callbacks;
1224    memset(&btif_hh_cb, 0, sizeof(btif_hh_cb));
1225    for (i = 0; i < BTIF_HH_MAX_HID; i++){
1226        btif_hh_cb.devices[i].dev_status = BTHH_CONN_STATE_UNKNOWN;
1227    }
1228    /* Invoke the enable service API to the core to set the appropriate service_id */
1229    btif_enable_service(BTA_HID_SERVICE_ID);
1230    return BT_STATUS_SUCCESS;
1231}
1232
1233/*******************************************************************************
1234**
1235** Function        connect
1236**
1237** Description     connect to hid device
1238**
1239** Returns         bt_status_t
1240**
1241*******************************************************************************/
1242static bt_status_t connect( bt_bdaddr_t *bd_addr)
1243{
1244    if(btif_hh_cb.status != BTIF_HH_DEV_CONNECTING)
1245    {
1246        btif_transfer_context(btif_hh_handle_evt, BTIF_HH_CONNECT_REQ_EVT,
1247                                 (char*)bd_addr, sizeof(bt_bdaddr_t), NULL);
1248        return BT_STATUS_SUCCESS;
1249    }
1250    else
1251        return BT_STATUS_BUSY;
1252}
1253
1254/*******************************************************************************
1255**
1256** Function         disconnect
1257**
1258** Description      disconnect from hid device
1259**
1260** Returns         bt_status_t
1261**
1262*******************************************************************************/
1263static bt_status_t disconnect( bt_bdaddr_t *bd_addr )
1264{
1265    CHECK_BTHH_INIT();
1266    btif_hh_device_t *p_dev;
1267
1268    if (btif_hh_cb.status == BTIF_HH_DISABLED)
1269    {
1270        BTIF_TRACE_WARNING2("%s: Error, HH status = %d", __FUNCTION__, btif_hh_cb.status);
1271        return BT_STATUS_FAIL;
1272    }
1273    p_dev = btif_hh_find_connected_dev_by_bda(bd_addr);
1274    if (p_dev != NULL)
1275    {
1276        return btif_transfer_context(btif_hh_handle_evt, BTIF_HH_DISCONNECT_REQ_EVT,
1277                     (char*)bd_addr, sizeof(bt_bdaddr_t), NULL);
1278    }
1279    else
1280    {
1281        BTIF_TRACE_WARNING1("%s: Error, device  not opened.", __FUNCTION__);
1282        return BT_STATUS_FAIL;
1283    }
1284}
1285
1286/*******************************************************************************
1287**
1288** Function         virtual_unplug
1289**
1290** Description      Virtual UnPlug (VUP) the specified HID device.
1291**
1292** Returns         bt_status_t
1293**
1294*******************************************************************************/
1295static bt_status_t virtual_unplug (bt_bdaddr_t *bd_addr)
1296{
1297    CHECK_BTHH_INIT();
1298    btif_hh_device_t *p_dev;
1299    char bd_str[18];
1300    sprintf(bd_str, "%02X:%02X:%02X:%02X:%02X:%02X",
1301            bd_addr->address[0],  bd_addr->address[1],  bd_addr->address[2],  bd_addr->address[3],
1302            bd_addr->address[4], bd_addr->address[5]);
1303    if (btif_hh_cb.status == BTIF_HH_DISABLED)
1304    {
1305        BTIF_TRACE_ERROR2("%s: Error, HH status = %d", __FUNCTION__, btif_hh_cb.status);
1306        return BT_STATUS_FAIL;
1307    }
1308    p_dev = btif_hh_find_dev_by_bda(bd_addr);
1309    if (!p_dev)
1310    {
1311        BTIF_TRACE_ERROR2("%s: Error, device %s not opened.", __FUNCTION__, bd_str);
1312        return BT_STATUS_FAIL;
1313    }
1314    btif_transfer_context(btif_hh_handle_evt, BTIF_HH_VUP_REQ_EVT,
1315                                 (char*)bd_addr, sizeof(bt_bdaddr_t), NULL);
1316    return BT_STATUS_SUCCESS;
1317}
1318
1319
1320/*******************************************************************************
1321**
1322** Function         set_info
1323**
1324** Description      Set the HID device descriptor for the specified HID device.
1325**
1326** Returns         bt_status_t
1327**
1328*******************************************************************************/
1329static bt_status_t set_info (bt_bdaddr_t *bd_addr, bthh_hid_info_t hid_info )
1330{
1331    CHECK_BTHH_INIT();
1332    tBTA_HH_DEV_DSCP_INFO dscp_info;
1333    BD_ADDR* bda = (BD_ADDR*) bd_addr;
1334
1335    BTIF_TRACE_DEBUG6("addr = %02X:%02X:%02X:%02X:%02X:%02X",
1336         (*bda)[0], (*bda)[1], (*bda)[2], (*bda)[3], (*bda)[4], (*bda)[5]);
1337    BTIF_TRACE_DEBUG6("%s: sub_class = 0x%02x, app_id = %d, vendor_id = 0x%04x, "
1338         "product_id = 0x%04x, version= 0x%04x",
1339         __FUNCTION__, hid_info.sub_class,
1340         hid_info.app_id, hid_info.vendor_id, hid_info.product_id,
1341         hid_info.version);
1342
1343    if (btif_hh_cb.status == BTIF_HH_DISABLED)
1344    {
1345        BTIF_TRACE_ERROR2("%s: Error, HH status = %d", __FUNCTION__, btif_hh_cb.status);
1346        return BT_STATUS_FAIL;
1347    }
1348
1349    dscp_info.vendor_id  = hid_info.vendor_id;
1350    dscp_info.product_id = hid_info.product_id;
1351    dscp_info.version    = hid_info.version;
1352    dscp_info.ctry_code  = hid_info.ctry_code;
1353
1354    dscp_info.descriptor.dl_len = hid_info.dl_len;
1355    dscp_info.descriptor.dsc_list = (UINT8 *) GKI_getbuf(dscp_info.descriptor.dl_len);
1356    if (dscp_info.descriptor.dsc_list == NULL)
1357    {
1358        ALOGE("%s: Failed to allocate DSCP for CB", __FUNCTION__);
1359        return BT_STATUS_FAIL;
1360    }
1361    memcpy(dscp_info.descriptor.dsc_list, &(hid_info.dsc_list), hid_info.dl_len);
1362
1363    if (btif_hh_add_added_dev(*bd_addr, hid_info.attr_mask))
1364    {
1365        BTA_HhAddDev(*bda, hid_info.attr_mask, hid_info.sub_class,
1366                     hid_info.app_id, dscp_info);
1367    }
1368
1369    GKI_freebuf(dscp_info.descriptor.dsc_list);
1370
1371    return BT_STATUS_SUCCESS;
1372}
1373/*******************************************************************************
1374**
1375** Function         get_idle_time
1376**
1377** Description      Get the HID idle time
1378**
1379** Returns         bt_status_t
1380**
1381*******************************************************************************/
1382static bt_status_t get_idle_time(bt_bdaddr_t *bd_addr)
1383{
1384    CHECK_BTHH_INIT();
1385    btif_hh_device_t *p_dev;
1386    BD_ADDR* bda = (BD_ADDR*) bd_addr;
1387
1388    BTIF_TRACE_DEBUG6(" addr = %02X:%02X:%02X:%02X:%02X:%02X",
1389         (*bda)[0], (*bda)[1], (*bda)[2], (*bda)[3], (*bda)[4], (*bda)[5]);
1390
1391    if (btif_hh_cb.status == BTIF_HH_DISABLED) {
1392        BTIF_TRACE_ERROR2("%s: Error, HH status = %d", __FUNCTION__, btif_hh_cb.status);
1393        return BT_STATUS_FAIL;
1394    }
1395
1396    p_dev = btif_hh_find_connected_dev_by_bda(bd_addr);
1397    if (p_dev != NULL) {
1398        //BTA_HhGetIdle(p_dev->dev_handle);
1399    }
1400    else {
1401        return BT_STATUS_FAIL;
1402    }
1403    return BT_STATUS_SUCCESS;
1404}
1405
1406/*******************************************************************************
1407**
1408** Function         set_idle_time
1409**
1410** Description      Set the HID idle time
1411**
1412** Returns         bt_status_t
1413**
1414*******************************************************************************/
1415static bt_status_t set_idle_time (bt_bdaddr_t *bd_addr, uint8_t idle_time)
1416{
1417    CHECK_BTHH_INIT();
1418    btif_hh_device_t *p_dev;
1419    BD_ADDR* bda = (BD_ADDR*) bd_addr;
1420
1421    BTIF_TRACE_DEBUG6("addr = %02X:%02X:%02X:%02X:%02X:%02X",
1422         (*bda)[0], (*bda)[1], (*bda)[2], (*bda)[3], (*bda)[4], (*bda)[5]);
1423
1424    if (btif_hh_cb.status == BTIF_HH_DISABLED) {
1425        BTIF_TRACE_ERROR2("%s: Error, HH status = %d", __FUNCTION__, btif_hh_cb.status);
1426        return BT_STATUS_FAIL;
1427    }
1428
1429    p_dev = btif_hh_find_connected_dev_by_bda(bd_addr);
1430    if (p_dev == NULL) {
1431        BTIF_TRACE_WARNING6(" Error, device %02X:%02X:%02X:%02X:%02X:%02X not opened.",
1432             (*bda)[0], (*bda)[1], (*bda)[2], (*bda)[3], (*bda)[4], (*bda)[5]);
1433        return BT_STATUS_FAIL;
1434    }
1435    else {
1436        //BTA_HhSetIdle(p_dev->dev_handle, idle_time);
1437    }
1438    return BT_STATUS_SUCCESS;
1439}
1440
1441/*******************************************************************************
1442**
1443** Function         get_protocol
1444**
1445** Description      Get the HID proto mode.
1446**
1447** Returns         bt_status_t
1448**
1449*******************************************************************************/
1450static bt_status_t get_protocol (bt_bdaddr_t *bd_addr, bthh_protocol_mode_t protocolMode)
1451{
1452    CHECK_BTHH_INIT();
1453    btif_hh_device_t *p_dev;
1454    BD_ADDR* bda = (BD_ADDR*) bd_addr;
1455
1456    BTIF_TRACE_DEBUG6(" addr = %02X:%02X:%02X:%02X:%02X:%02X",
1457         (*bda)[0], (*bda)[1], (*bda)[2], (*bda)[3], (*bda)[4], (*bda)[5]);
1458
1459    if (btif_hh_cb.status == BTIF_HH_DISABLED) {
1460        BTIF_TRACE_ERROR2("%s: Error, HH status = %d", __FUNCTION__, btif_hh_cb.status);
1461        return BT_STATUS_FAIL;
1462    }
1463
1464    p_dev = btif_hh_find_connected_dev_by_bda(bd_addr);
1465    if (p_dev != NULL) {
1466        BTA_HhGetProtoMode(p_dev->dev_handle);
1467    }
1468    else {
1469        return BT_STATUS_FAIL;
1470    }
1471    return BT_STATUS_SUCCESS;
1472}
1473
1474/*******************************************************************************
1475**
1476** Function         set_protocol
1477**
1478** Description      Set the HID proto mode.
1479**
1480** Returns         bt_status_t
1481**
1482*******************************************************************************/
1483static bt_status_t set_protocol (bt_bdaddr_t *bd_addr, bthh_protocol_mode_t protocolMode)
1484{
1485    CHECK_BTHH_INIT();
1486    btif_hh_device_t *p_dev;
1487    UINT8 proto_mode = protocolMode;
1488    BD_ADDR* bda = (BD_ADDR*) bd_addr;
1489
1490    BTIF_TRACE_DEBUG2("%s:proto_mode = %d", __FUNCTION__,protocolMode);
1491
1492    BTIF_TRACE_DEBUG6("addr = %02X:%02X:%02X:%02X:%02X:%02X",
1493         (*bda)[0], (*bda)[1], (*bda)[2], (*bda)[3], (*bda)[4], (*bda)[5]);
1494
1495    if (btif_hh_cb.status == BTIF_HH_DISABLED) {
1496        BTIF_TRACE_ERROR2("%s: Error, HH status = %d", __FUNCTION__, btif_hh_cb.status);
1497        return BT_STATUS_FAIL;
1498    }
1499
1500    p_dev = btif_hh_find_connected_dev_by_bda(bd_addr);
1501    if (p_dev == NULL) {
1502        BTIF_TRACE_WARNING6(" Error, device %02X:%02X:%02X:%02X:%02X:%02X not opened.",
1503             (*bda)[0], (*bda)[1], (*bda)[2], (*bda)[3], (*bda)[4], (*bda)[5]);
1504        return BT_STATUS_FAIL;
1505    }
1506    else if (protocolMode != BTA_HH_PROTO_RPT_MODE && protocolMode != BTA_HH_PROTO_BOOT_MODE) {
1507        BTIF_TRACE_WARNING2("s: Error, device proto_mode = %d.", __FUNCTION__, proto_mode);
1508        return BT_STATUS_FAIL;
1509    }
1510    else {
1511        BTA_HhSetProtoMode(p_dev->dev_handle, protocolMode);
1512    }
1513
1514
1515    return BT_STATUS_SUCCESS;
1516}
1517
1518/*******************************************************************************
1519**
1520** Function         get_report
1521**
1522** Description      Send a GET_REPORT to HID device.
1523**
1524** Returns         bt_status_t
1525**
1526*******************************************************************************/
1527static bt_status_t get_report (bt_bdaddr_t *bd_addr, bthh_report_type_t reportType, uint8_t reportId, int bufferSize)
1528{
1529    CHECK_BTHH_INIT();
1530    btif_hh_device_t *p_dev;
1531    BD_ADDR* bda = (BD_ADDR*) bd_addr;
1532
1533    BTIF_TRACE_DEBUG4("%s:proto_mode = %dr_type = %d, rpt_id = %d, buf_size = %d", __FUNCTION__,
1534          reportType, reportId, bufferSize);
1535
1536    BTIF_TRACE_DEBUG6("addr = %02X:%02X:%02X:%02X:%02X:%02X",
1537         (*bda)[0], (*bda)[1], (*bda)[2], (*bda)[3], (*bda)[4], (*bda)[5]);
1538
1539    if (btif_hh_cb.status == BTIF_HH_DISABLED) {
1540        BTIF_TRACE_ERROR2("%s: Error, HH status = %d", __FUNCTION__, btif_hh_cb.status);
1541        return BT_STATUS_FAIL;
1542    }
1543
1544
1545    p_dev = btif_hh_find_connected_dev_by_bda(bd_addr);
1546    if (p_dev == NULL) {
1547        BTIF_TRACE_ERROR6("%s: Error, device %02X:%02X:%02X:%02X:%02X:%02X not opened.",
1548             (*bda)[0], (*bda)[1], (*bda)[2], (*bda)[3], (*bda)[4], (*bda)[5]);
1549        return BT_STATUS_FAIL;
1550    }
1551    else if ( ((int) reportType) <= BTA_HH_RPTT_RESRV || ((int) reportType) > BTA_HH_RPTT_FEATURE) {
1552        BTIF_TRACE_ERROR6(" Error, device %02X:%02X:%02X:%02X:%02X:%02X not opened.",
1553             (*bda)[0], (*bda)[1], (*bda)[2], (*bda)[3], (*bda)[4], (*bda)[5]);
1554        return BT_STATUS_FAIL;
1555    }
1556    else {
1557        BTA_HhGetReport(p_dev->dev_handle, reportType,
1558                        reportId, bufferSize);
1559    }
1560
1561    return BT_STATUS_SUCCESS;
1562}
1563
1564/*******************************************************************************
1565**
1566** Function         set_report
1567**
1568** Description      Send a SET_REPORT to HID device.
1569**
1570** Returns         bt_status_t
1571**
1572*******************************************************************************/
1573static bt_status_t set_report (bt_bdaddr_t *bd_addr, bthh_report_type_t reportType, char* report)
1574{
1575    CHECK_BTHH_INIT();
1576    btif_hh_device_t *p_dev;
1577    BD_ADDR* bda = (BD_ADDR*) bd_addr;
1578
1579    BTIF_TRACE_DEBUG2("%s:reportType = %d", __FUNCTION__,reportType);
1580
1581    BTIF_TRACE_DEBUG6("addr = %02X:%02X:%02X:%02X:%02X:%02X",
1582         (*bda)[0], (*bda)[1], (*bda)[2], (*bda)[3], (*bda)[4], (*bda)[5]);
1583
1584
1585    if (btif_hh_cb.status == BTIF_HH_DISABLED) {
1586        BTIF_TRACE_ERROR2("%s: Error, HH status = %d", __FUNCTION__, btif_hh_cb.status);
1587        return BT_STATUS_FAIL;
1588    }
1589
1590    p_dev = btif_hh_find_connected_dev_by_bda(bd_addr);
1591    if (p_dev == NULL) {
1592        BTIF_TRACE_ERROR6("%s: Error, device %02X:%02X:%02X:%02X:%02X:%02X not opened.",
1593             (*bda)[0], (*bda)[1], (*bda)[2], (*bda)[3], (*bda)[4], (*bda)[5]);
1594        return BT_STATUS_FAIL;
1595    }
1596    else if ( ( (int) reportType) <= BTA_HH_RPTT_RESRV || ( (int) reportType) > BTA_HH_RPTT_FEATURE) {
1597        BTIF_TRACE_ERROR6(" Error, device %02X:%02X:%02X:%02X:%02X:%02X not opened.",
1598             (*bda)[0], (*bda)[1], (*bda)[2], (*bda)[3], (*bda)[4], (*bda)[5]);
1599        return BT_STATUS_FAIL;
1600    }
1601    else {
1602        int    hex_bytes_filled;
1603        UINT8  hexbuf[200];
1604        UINT16 len = (strlen(report) + 1) / 2;
1605
1606        if (p_dev->p_buf != NULL) {
1607            GKI_freebuf(p_dev->p_buf);
1608        }
1609        p_dev->p_buf = GKI_getbuf((UINT16) (len + BTA_HH_MIN_OFFSET + sizeof(BT_HDR)));
1610        if (p_dev->p_buf == NULL) {
1611            BTIF_TRACE_ERROR2("%s: Error, failed to allocate RPT buffer, len = %d", __FUNCTION__, len);
1612            return BT_STATUS_FAIL;
1613        }
1614
1615        p_dev->p_buf->len = len;
1616        p_dev->p_buf->offset = BTA_HH_MIN_OFFSET;
1617
1618        /* Build a SetReport data buffer */
1619        memset(hexbuf, 0, 200);
1620        //TODO
1621        hex_bytes_filled = ascii_2_hex(report, len, hexbuf);
1622        ALOGI("Hex bytes filled, hex value: %d", hex_bytes_filled);
1623
1624        if (hex_bytes_filled) {
1625            UINT8* pbuf_data;
1626            pbuf_data = (UINT8*) (p_dev->p_buf + 1) + p_dev->p_buf->offset;
1627            memcpy(pbuf_data, hexbuf, hex_bytes_filled);
1628            BTA_HhSetReport(p_dev->dev_handle, reportType, p_dev->p_buf);
1629        }
1630        return BT_STATUS_SUCCESS;
1631    }
1632
1633
1634}
1635
1636/*******************************************************************************
1637**
1638** Function         send_data
1639**
1640** Description      Send a SEND_DATA to HID device.
1641**
1642** Returns         bt_status_t
1643**
1644*******************************************************************************/
1645static bt_status_t send_data (bt_bdaddr_t *bd_addr, char* data)
1646{
1647    CHECK_BTHH_INIT();
1648    btif_hh_device_t *p_dev;
1649    BD_ADDR* bda = (BD_ADDR*) bd_addr;
1650
1651    BTIF_TRACE_DEBUG1("%s", __FUNCTION__);
1652
1653    BTIF_TRACE_DEBUG6("addr = %02X:%02X:%02X:%02X:%02X:%02X",
1654         (*bda)[0], (*bda)[1], (*bda)[2], (*bda)[3], (*bda)[4], (*bda)[5]);
1655
1656    if (btif_hh_cb.status == BTIF_HH_DISABLED) {
1657        BTIF_TRACE_ERROR2("%s: Error, HH status = %d", __FUNCTION__, btif_hh_cb.status);
1658        return BT_STATUS_FAIL;
1659    }
1660
1661    p_dev = btif_hh_find_connected_dev_by_bda(bd_addr);
1662    if (p_dev == NULL) {
1663        BTIF_TRACE_ERROR6("%s: Error, device %02X:%02X:%02X:%02X:%02X:%02X not opened.",
1664             (*bda)[0], (*bda)[1], (*bda)[2], (*bda)[3], (*bda)[4], (*bda)[5]);
1665        return BT_STATUS_FAIL;
1666    }
1667
1668    else {
1669        int    hex_bytes_filled;
1670        UINT8  hexbuf[200];
1671        UINT16 len = (strlen(data) + 1) / 2;
1672
1673        if (p_dev->p_buf != NULL) {
1674            GKI_freebuf(p_dev->p_buf);
1675        }
1676        p_dev->p_buf = GKI_getbuf((UINT16) (len + BTA_HH_MIN_OFFSET + sizeof(BT_HDR)));
1677        if (p_dev->p_buf == NULL) {
1678            BTIF_TRACE_ERROR2("%s: Error, failed to allocate RPT buffer, len = %d", __FUNCTION__, len);
1679            return BT_STATUS_FAIL;
1680        }
1681
1682        p_dev->p_buf->len = len;
1683        p_dev->p_buf->offset = BTA_HH_MIN_OFFSET;
1684
1685        /* Build a SetReport data buffer */
1686        memset(hexbuf, 0, 200);
1687        hex_bytes_filled = ascii_2_hex(data, len, hexbuf);
1688        BTIF_TRACE_ERROR2("Hex bytes filled, hex value: %d, %d", hex_bytes_filled, len);
1689
1690        if (hex_bytes_filled) {
1691            UINT8* pbuf_data;
1692            pbuf_data = (UINT8*) (p_dev->p_buf + 1) + p_dev->p_buf->offset;
1693            memcpy(pbuf_data, hexbuf, hex_bytes_filled);
1694            p_dev->p_buf->layer_specific = BTA_HH_RPTT_OUTPUT;
1695            BTA_HhSendData(p_dev->dev_handle, *bda, p_dev->p_buf);
1696            return BT_STATUS_SUCCESS;
1697        }
1698
1699    }
1700    return BT_STATUS_FAIL;
1701}
1702
1703
1704/*******************************************************************************
1705**
1706** Function         cleanup
1707**
1708** Description      Closes the HH interface
1709**
1710** Returns          bt_status_t
1711**
1712*******************************************************************************/
1713static void  cleanup( void )
1714{
1715    BTIF_TRACE_EVENT1("%s", __FUNCTION__);
1716    btif_hh_device_t *p_dev;
1717    int i;
1718    if (btif_hh_cb.status == BTIF_HH_DISABLED) {
1719        BTIF_TRACE_WARNING2("%s: HH disabling or disabled already, status = %d", __FUNCTION__, btif_hh_cb.status);
1720        return;
1721    }
1722    btif_hh_cb.status = BTIF_HH_DISABLING;
1723    for (i = 0; i < BTIF_HH_MAX_HID; i++) {
1724         p_dev = &btif_hh_cb.devices[i];
1725         if (p_dev->dev_status != BTHH_CONN_STATE_UNKNOWN && p_dev->fd >= 0) {
1726             BTIF_TRACE_DEBUG2("%s: Closing uhid fd = %d", __FUNCTION__, p_dev->fd);
1727             bta_hh_co_destroy(p_dev->fd);
1728             p_dev->fd = -1;
1729             p_dev->hh_keep_polling = 0;
1730             p_dev->hh_poll_thread_id = -1;
1731         }
1732     }
1733
1734    if (bt_hh_callbacks)
1735    {
1736        btif_disable_service(BTA_HID_SERVICE_ID);
1737        bt_hh_callbacks = NULL;
1738    }
1739
1740}
1741
1742static const bthh_interface_t bthhInterface = {
1743    sizeof(bthhInterface),
1744    init,
1745    connect,
1746    disconnect,
1747    virtual_unplug,
1748    set_info,
1749    get_protocol,
1750    set_protocol,
1751//    get_idle_time,
1752//    set_idle_time,
1753    get_report,
1754    set_report,
1755    send_data,
1756    cleanup,
1757};
1758
1759/*******************************************************************************
1760**
1761** Function         btif_hh_execute_service
1762**
1763** Description      Initializes/Shuts down the service
1764**
1765** Returns          BT_STATUS_SUCCESS on success, BT_STATUS_FAIL otherwise
1766**
1767*******************************************************************************/
1768bt_status_t btif_hh_execute_service(BOOLEAN b_enable)
1769{
1770     if (b_enable)
1771     {
1772          /* Enable and register with BTA-HH */
1773          BTA_HhEnable(BTA_SEC_NONE, bte_hh_evt);
1774     }
1775     else {
1776         /* Disable HH */
1777         BTA_HhDisable();
1778     }
1779     return BT_STATUS_SUCCESS;
1780}
1781
1782/*******************************************************************************
1783**
1784** Function         btif_hh_get_interface
1785**
1786** Description      Get the hh callback interface
1787**
1788** Returns          bthh_interface_t
1789**
1790*******************************************************************************/
1791const bthh_interface_t *btif_hh_get_interface()
1792{
1793    BTIF_TRACE_EVENT1("%s", __FUNCTION__);
1794    return &bthhInterface;
1795}
1796