Home | History | Annotate | Download | only in hh
      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 *******************************************************************************/
     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 *******************************************************************************/
    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 *******************************************************************************/
    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     return;
    174 #endif
    175 
    176     bta_hh_cleanup_disable(status);
    177 }
    178 
    179 /*******************************************************************************
    180 **
    181 ** Function         bta_hh_sdp_cback
    182 **
    183 ** Description      SDP callback function.
    184 **
    185 ** Returns          void
    186 **
    187 *******************************************************************************/
    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;
    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 *******************************************************************************/
    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 *******************************************************************************/
    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 *******************************************************************************/
    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 *******************************************************************************/
    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 *******************************************************************************/
    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 *******************************************************************************/
    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 *******************************************************************************/
    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 *******************************************************************************/
    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 *******************************************************************************/
    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 *******************************************************************************/
    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 *******************************************************************************/
    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 *******************************************************************************/
    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 *******************************************************************************/
    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 *******************************************************************************/
   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 *******************************************************************************/
   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 *******************************************************************************/
   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)
   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 
   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