1 /****************************************************************************** 2 * 3 * Copyright 2005-2012 Broadcom Corporation 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at: 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 * 17 ******************************************************************************/ 18 19 /****************************************************************************** 20 * 21 * This file contains the HID host main functions and state machine. 22 * 23 ******************************************************************************/ 24 25 #include "bt_target.h" 26 27 #if (BTA_HH_INCLUDED == TRUE) 28 29 #include <string.h> 30 31 #include "bt_common.h" 32 #include "bta_hh_api.h" 33 #include "bta_hh_int.h" 34 35 /***************************************************************************** 36 * Constants and types 37 ****************************************************************************/ 38 39 /* state machine action enumeration list */ 40 enum { 41 BTA_HH_API_DISC_ACT, /* HID host process API close action */ 42 BTA_HH_OPEN_ACT, /* HID host process BTA_HH_EVT_OPEN */ 43 BTA_HH_CLOSE_ACT, /* HID host process BTA_HH_EVT_CLOSE */ 44 BTA_HH_DATA_ACT, /* HID host receive data report */ 45 BTA_HH_CTRL_DAT_ACT, 46 BTA_HH_HANDSK_ACT, 47 BTA_HH_START_SDP, /* HID host inquery */ 48 BTA_HH_SDP_CMPL, 49 BTA_HH_WRITE_DEV_ACT, 50 BTA_HH_GET_DSCP_ACT, 51 BTA_HH_MAINT_DEV_ACT, 52 BTA_HH_OPEN_CMPL_ACT, 53 BTA_HH_OPEN_FAILURE, 54 #if (BTA_HH_LE_INCLUDED == TRUE) 55 BTA_HH_GATT_CLOSE, 56 BTA_HH_LE_OPEN_FAIL, 57 BTA_HH_GATT_OPEN, 58 BTA_HH_START_SEC, 59 BTA_HH_SEC_CMPL, 60 BTA_HH_GATT_ENC_CMPL, 61 #endif 62 BTA_HH_NUM_ACTIONS 63 }; 64 65 #define BTA_HH_IGNORE BTA_HH_NUM_ACTIONS 66 67 /* type for action functions */ 68 typedef void (*tBTA_HH_ACTION)(tBTA_HH_DEV_CB* p_cb, tBTA_HH_DATA* p_data); 69 70 /* action functions */ 71 const tBTA_HH_ACTION bta_hh_action[] = { 72 bta_hh_api_disc_act, bta_hh_open_act, bta_hh_close_act, bta_hh_data_act, 73 bta_hh_ctrl_dat_act, bta_hh_handsk_act, bta_hh_start_sdp, bta_hh_sdp_cmpl, 74 bta_hh_write_dev_act, bta_hh_get_dscp_act, bta_hh_maint_dev_act, 75 bta_hh_open_cmpl_act, bta_hh_open_failure 76 #if (BTA_HH_LE_INCLUDED == TRUE) 77 , 78 bta_hh_gatt_close, bta_hh_le_open_fail, bta_hh_gatt_open, 79 bta_hh_start_security, bta_hh_security_cmpl, bta_hh_le_notify_enc_cmpl 80 #endif 81 }; 82 83 /* state table information */ 84 #define BTA_HH_ACTION 0 /* position of action */ 85 #define BTA_HH_NEXT_STATE 1 /* position of next state */ 86 #define BTA_HH_NUM_COLS 2 /* number of columns */ 87 88 /* state table for idle state */ 89 const uint8_t bta_hh_st_idle[][BTA_HH_NUM_COLS] = { 90 /* Event Action Next state */ 91 /* BTA_HH_API_OPEN_EVT */ {BTA_HH_START_SDP, BTA_HH_W4_CONN_ST}, 92 /* BTA_HH_API_CLOSE_EVT */ {BTA_HH_IGNORE, BTA_HH_IDLE_ST}, 93 /* BTA_HH_INT_OPEN_EVT */ {BTA_HH_OPEN_ACT, BTA_HH_W4_CONN_ST}, 94 /* BTA_HH_INT_CLOSE_EVT */ {BTA_HH_CLOSE_ACT, BTA_HH_IDLE_ST}, 95 /* BTA_HH_INT_DATA_EVT */ {BTA_HH_IGNORE, BTA_HH_IDLE_ST}, 96 /* BTA_HH_INT_CTRL_DATA */ {BTA_HH_IGNORE, BTA_HH_IDLE_ST}, 97 /* BTA_HH_INT_HANDSK_EVT */ {BTA_HH_IGNORE, BTA_HH_IDLE_ST}, 98 /* BTA_HH_SDP_CMPL_EVT */ {BTA_HH_IGNORE, BTA_HH_IDLE_ST}, 99 /* BTA_HH_API_WRITE_DEV_EVT */ {BTA_HH_IGNORE, BTA_HH_IDLE_ST}, 100 /* BTA_HH_API_GET_DSCP_EVT */ {BTA_HH_IGNORE, BTA_HH_IDLE_ST}, 101 /* BTA_HH_API_MAINT_DEV_EVT */ {BTA_HH_MAINT_DEV_ACT, BTA_HH_IDLE_ST}, 102 /* BTA_HH_OPEN_CMPL_EVT */ {BTA_HH_OPEN_CMPL_ACT, BTA_HH_CONN_ST} 103 #if (BTA_HH_LE_INCLUDED == TRUE) 104 /* BTA_HH_GATT_CLOSE_EVT */, 105 {BTA_HH_IGNORE, BTA_HH_IDLE_ST} 106 /* BTA_HH_GATT_OPEN_EVT */, 107 {BTA_HH_GATT_OPEN, BTA_HH_W4_CONN_ST} 108 /* BTA_HH_START_ENC_EVT */, 109 {BTA_HH_IGNORE, BTA_HH_IDLE_ST} 110 /* BTA_HH_ENC_CMPL_EVT */, 111 {BTA_HH_IGNORE, BTA_HH_IDLE_ST} 112 /* BTA_HH_GATT_ENC_CMPL_EVT */, 113 {BTA_HH_IGNORE, BTA_HH_IDLE_ST} 114 #endif 115 116 }; 117 118 const uint8_t bta_hh_st_w4_conn[][BTA_HH_NUM_COLS] = { 119 /* Event Action Next state */ 120 /* BTA_HH_API_OPEN_EVT */ {BTA_HH_IGNORE, BTA_HH_W4_CONN_ST}, 121 /* BTA_HH_API_CLOSE_EVT */ {BTA_HH_IGNORE, BTA_HH_IDLE_ST}, 122 /* BTA_HH_INT_OPEN_EVT */ {BTA_HH_OPEN_ACT, BTA_HH_W4_CONN_ST}, 123 /* BTA_HH_INT_CLOSE_EVT */ {BTA_HH_OPEN_FAILURE, BTA_HH_IDLE_ST}, 124 /* BTA_HH_INT_DATA_EVT */ {BTA_HH_IGNORE, BTA_HH_W4_CONN_ST}, 125 /* BTA_HH_INT_CTRL_DATA */ {BTA_HH_IGNORE, BTA_HH_W4_CONN_ST}, 126 /* BTA_HH_INT_HANDSK_EVT */ {BTA_HH_IGNORE, BTA_HH_W4_CONN_ST}, 127 /* BTA_HH_SDP_CMPL_EVT */ {BTA_HH_SDP_CMPL, BTA_HH_W4_CONN_ST}, 128 /* BTA_HH_API_WRITE_DEV_EVT */ {BTA_HH_WRITE_DEV_ACT, BTA_HH_W4_CONN_ST}, 129 /* BTA_HH_API_GET_DSCP_EVT */ {BTA_HH_IGNORE, BTA_HH_W4_CONN_ST}, 130 /* BTA_HH_API_MAINT_DEV_EVT */ {BTA_HH_MAINT_DEV_ACT, BTA_HH_IDLE_ST}, 131 /* BTA_HH_OPEN_CMPL_EVT */ {BTA_HH_OPEN_CMPL_ACT, BTA_HH_CONN_ST} 132 #if (BTA_HH_LE_INCLUDED == TRUE) 133 /* BTA_HH_GATT_CLOSE_EVT */, 134 {BTA_HH_LE_OPEN_FAIL, BTA_HH_IDLE_ST} 135 /* BTA_HH_GATT_OPEN_EVT */, 136 {BTA_HH_GATT_OPEN, BTA_HH_W4_CONN_ST} 137 /* BTA_HH_START_ENC_EVT */, 138 {BTA_HH_START_SEC, BTA_HH_W4_SEC} 139 /* BTA_HH_ENC_CMPL_EVT */, 140 {BTA_HH_IGNORE, BTA_HH_W4_CONN_ST} 141 /* BTA_HH_GATT_ENC_CMPL_EVT */, 142 {BTA_HH_IGNORE, BTA_HH_W4_CONN_ST} 143 #endif 144 }; 145 146 const uint8_t bta_hh_st_connected[][BTA_HH_NUM_COLS] = { 147 /* Event Action Next state */ 148 /* BTA_HH_API_OPEN_EVT */ {BTA_HH_IGNORE, BTA_HH_CONN_ST}, 149 /* BTA_HH_API_CLOSE_EVT */ {BTA_HH_API_DISC_ACT, BTA_HH_CONN_ST}, 150 /* BTA_HH_INT_OPEN_EVT */ {BTA_HH_OPEN_ACT, BTA_HH_CONN_ST}, 151 /* BTA_HH_INT_CLOSE_EVT */ {BTA_HH_CLOSE_ACT, BTA_HH_IDLE_ST}, 152 /* BTA_HH_INT_DATA_EVT */ {BTA_HH_DATA_ACT, BTA_HH_CONN_ST}, 153 /* BTA_HH_INT_CTRL_DATA */ {BTA_HH_CTRL_DAT_ACT, BTA_HH_CONN_ST}, 154 /* BTA_HH_INT_HANDSK_EVT */ {BTA_HH_HANDSK_ACT, BTA_HH_CONN_ST}, 155 /* BTA_HH_SDP_CMPL_EVT */ {BTA_HH_IGNORE, BTA_HH_CONN_ST}, 156 /* BTA_HH_API_WRITE_DEV_EVT */ {BTA_HH_WRITE_DEV_ACT, BTA_HH_CONN_ST}, 157 /* BTA_HH_API_GET_DSCP_EVT */ {BTA_HH_GET_DSCP_ACT, BTA_HH_CONN_ST}, 158 /* BTA_HH_API_MAINT_DEV_EVT */ {BTA_HH_MAINT_DEV_ACT, BTA_HH_CONN_ST}, 159 /* BTA_HH_OPEN_CMPL_EVT */ {BTA_HH_IGNORE, BTA_HH_CONN_ST} 160 #if (BTA_HH_LE_INCLUDED == TRUE) 161 /* BTA_HH_GATT_CLOSE_EVT */, 162 {BTA_HH_GATT_CLOSE, BTA_HH_IDLE_ST} 163 /* BTA_HH_GATT_OPEN_EVT */, 164 {BTA_HH_IGNORE, BTA_HH_CONN_ST} 165 /* BTA_HH_START_ENC_EVT */, 166 {BTA_HH_IGNORE, BTA_HH_CONN_ST} 167 /* BTA_HH_ENC_CMPL_EVT */, 168 {BTA_HH_IGNORE, BTA_HH_CONN_ST} 169 /* BTA_HH_GATT_ENC_CMPL_EVT */, 170 {BTA_HH_IGNORE, BTA_HH_CONN_ST} 171 #endif 172 }; 173 #if (BTA_HH_LE_INCLUDED == TRUE) 174 const uint8_t bta_hh_st_w4_sec[][BTA_HH_NUM_COLS] = { 175 /* Event Action Next state */ 176 /* BTA_HH_API_OPEN_EVT */ {BTA_HH_IGNORE, BTA_HH_W4_SEC}, 177 /* BTA_HH_API_CLOSE_EVT */ {BTA_HH_API_DISC_ACT, BTA_HH_W4_SEC}, 178 /* BTA_HH_INT_OPEN_EVT */ {BTA_HH_IGNORE, BTA_HH_W4_SEC}, 179 /* BTA_HH_INT_CLOSE_EVT */ {BTA_HH_OPEN_FAILURE, BTA_HH_IDLE_ST}, 180 /* BTA_HH_INT_DATA_EVT */ {BTA_HH_IGNORE, BTA_HH_W4_SEC}, 181 /* BTA_HH_INT_CTRL_DATA */ {BTA_HH_IGNORE, BTA_HH_W4_SEC}, 182 /* BTA_HH_INT_HANDSK_EVT */ {BTA_HH_IGNORE, BTA_HH_W4_SEC}, 183 /* BTA_HH_SDP_CMPL_EVT */ {BTA_HH_IGNORE, BTA_HH_W4_SEC}, 184 /* BTA_HH_API_WRITE_DEV_EVT */ {BTA_HH_IGNORE, BTA_HH_W4_SEC}, 185 /* BTA_HH_API_GET_DSCP_EVT */ {BTA_HH_IGNORE, BTA_HH_W4_SEC}, 186 /* BTA_HH_API_MAINT_DEV_EVT */ {BTA_HH_MAINT_DEV_ACT, BTA_HH_W4_SEC}, 187 /* BTA_HH_OPEN_CMPL_EVT */ {BTA_HH_IGNORE, BTA_HH_W4_SEC}, 188 /* BTA_HH_GATT_CLOSE_EVT */ {BTA_HH_LE_OPEN_FAIL, BTA_HH_IDLE_ST}, 189 /* BTA_HH_GATT_OPEN_EVT */ {BTA_HH_IGNORE, BTA_HH_W4_SEC}, 190 /* BTA_HH_START_ENC_EVT */ {BTA_HH_IGNORE, BTA_HH_W4_SEC}, 191 /* BTA_HH_ENC_CMPL_EVT */ {BTA_HH_SEC_CMPL, BTA_HH_W4_CONN_ST}, 192 /* BTA_HH_GATT_ENC_CMPL_EVT */ {BTA_HH_GATT_ENC_CMPL, BTA_HH_W4_SEC}}; 193 #endif 194 195 /* type for state table */ 196 typedef const uint8_t (*tBTA_HH_ST_TBL)[BTA_HH_NUM_COLS]; 197 198 /* state table */ 199 const tBTA_HH_ST_TBL bta_hh_st_tbl[] = {bta_hh_st_idle, bta_hh_st_w4_conn, 200 bta_hh_st_connected 201 #if (BTA_HH_LE_INCLUDED == TRUE) 202 , 203 bta_hh_st_w4_sec 204 #endif 205 }; 206 207 /***************************************************************************** 208 * Global data 209 ****************************************************************************/ 210 tBTA_HH_CB bta_hh_cb; 211 212 /***************************************************************************** 213 * Static functions 214 ****************************************************************************/ 215 #if (BTA_HH_DEBUG == TRUE) 216 static const char* bta_hh_evt_code(tBTA_HH_INT_EVT evt_code); 217 static const char* bta_hh_state_code(tBTA_HH_STATE state_code); 218 #endif 219 220 /******************************************************************************* 221 * 222 * Function bta_hh_sm_execute 223 * 224 * Description State machine event handling function for HID Host 225 * 226 * 227 * Returns void 228 * 229 ******************************************************************************/ 230 void bta_hh_sm_execute(tBTA_HH_DEV_CB* p_cb, uint16_t event, 231 tBTA_HH_DATA* p_data) { 232 tBTA_HH_ST_TBL state_table; 233 uint8_t action; 234 tBTA_HH cback_data; 235 tBTA_HH_EVT cback_event = 0; 236 #if (BTA_HH_DEBUG == TRUE) 237 tBTA_HH_STATE in_state; 238 uint16_t debug_event = event; 239 #endif 240 241 memset(&cback_data, 0, sizeof(tBTA_HH)); 242 243 /* handle exception, no valid control block was found */ 244 if (!p_cb) { 245 /* BTA HH enabled already? otherwise ignore the event although it's bad*/ 246 if (bta_hh_cb.p_cback != NULL) { 247 switch (event) { 248 /* no control block available for new connection */ 249 case BTA_HH_API_OPEN_EVT: 250 cback_event = BTA_HH_OPEN_EVT; 251 /* build cback data */ 252 cback_data.conn.bda = ((tBTA_HH_API_CONN*)p_data)->bd_addr; 253 cback_data.conn.status = BTA_HH_ERR_DB_FULL; 254 cback_data.conn.handle = BTA_HH_INVALID_HANDLE; 255 break; 256 /* DB full, BTA_HhAddDev */ 257 case BTA_HH_API_MAINT_DEV_EVT: 258 cback_event = p_data->api_maintdev.sub_event; 259 260 if (p_data->api_maintdev.sub_event == BTA_HH_ADD_DEV_EVT) { 261 cback_data.dev_info.bda = p_data->api_maintdev.bda; 262 cback_data.dev_info.status = BTA_HH_ERR_DB_FULL; 263 cback_data.dev_info.handle = BTA_HH_INVALID_HANDLE; 264 } else { 265 cback_data.dev_info.status = BTA_HH_ERR_HDL; 266 cback_data.dev_info.handle = 267 (uint8_t)p_data->api_maintdev.hdr.layer_specific; 268 } 269 break; 270 case BTA_HH_API_WRITE_DEV_EVT: 271 cback_event = (p_data->api_sndcmd.t_type - BTA_HH_FST_BTE_TRANS_EVT) + 272 BTA_HH_FST_TRANS_CB_EVT; 273 osi_free_and_reset((void**)&p_data->api_sndcmd.p_data); 274 if (p_data->api_sndcmd.t_type == HID_TRANS_SET_PROTOCOL || 275 p_data->api_sndcmd.t_type == HID_TRANS_SET_REPORT || 276 p_data->api_sndcmd.t_type == HID_TRANS_SET_IDLE) { 277 cback_data.dev_status.status = BTA_HH_ERR_HDL; 278 cback_data.dev_status.handle = 279 (uint8_t)p_data->api_sndcmd.hdr.layer_specific; 280 } else if (p_data->api_sndcmd.t_type != HID_TRANS_DATA && 281 p_data->api_sndcmd.t_type != HID_TRANS_CONTROL) { 282 cback_data.hs_data.handle = 283 (uint8_t)p_data->api_sndcmd.hdr.layer_specific; 284 cback_data.hs_data.status = BTA_HH_ERR_HDL; 285 /* hs_data.rsp_data will be all zero, which is not valid value */ 286 } else if (p_data->api_sndcmd.t_type == HID_TRANS_CONTROL && 287 p_data->api_sndcmd.param == 288 BTA_HH_CTRL_VIRTUAL_CABLE_UNPLUG) { 289 cback_data.status = BTA_HH_ERR_HDL; 290 cback_event = BTA_HH_VC_UNPLUG_EVT; 291 } else 292 cback_event = 0; 293 break; 294 295 case BTA_HH_API_CLOSE_EVT: 296 cback_event = BTA_HH_CLOSE_EVT; 297 298 cback_data.dev_status.status = BTA_HH_ERR_HDL; 299 cback_data.dev_status.handle = 300 (uint8_t)p_data->api_sndcmd.hdr.layer_specific; 301 break; 302 303 default: 304 /* invalid handle, call bad API event */ 305 APPL_TRACE_ERROR("wrong device handle: [%d]", 306 p_data->hdr.layer_specific); 307 /* Free the callback buffer now */ 308 if (p_data != NULL) 309 osi_free_and_reset((void**)&p_data->hid_cback.p_data); 310 break; 311 } 312 if (cback_event) (*bta_hh_cb.p_cback)(cback_event, &cback_data); 313 } 314 } 315 /* corresponding CB is found, go to state machine */ 316 else { 317 #if (BTA_HH_DEBUG == TRUE) 318 in_state = p_cb->state; 319 APPL_TRACE_EVENT("bta_hh_sm_execute: State 0x%02x [%s], Event [%s]", 320 in_state, bta_hh_state_code(in_state), 321 bta_hh_evt_code(debug_event)); 322 #endif 323 324 if ((p_cb->state == BTA_HH_NULL_ST) || (p_cb->state >= BTA_HH_INVALID_ST)) { 325 APPL_TRACE_ERROR( 326 "bta_hh_sm_execute: Invalid state State = 0x%x, Event = %d", 327 p_cb->state, event); 328 return; 329 } 330 state_table = bta_hh_st_tbl[p_cb->state - 1]; 331 332 event &= 0xff; 333 334 p_cb->state = state_table[event][BTA_HH_NEXT_STATE]; 335 336 action = state_table[event][BTA_HH_ACTION]; 337 if (action != BTA_HH_IGNORE) { 338 (*bta_hh_action[action])(p_cb, p_data); 339 } 340 341 #if (BTA_HH_DEBUG == TRUE) 342 if (in_state != p_cb->state) { 343 APPL_TRACE_DEBUG("HH State Change: [%s] -> [%s] after Event [%s]", 344 bta_hh_state_code(in_state), 345 bta_hh_state_code(p_cb->state), 346 bta_hh_evt_code(debug_event)); 347 } 348 #endif 349 } 350 351 return; 352 } 353 /******************************************************************************* 354 * 355 * Function bta_hh_hdl_event 356 * 357 * Description HID host main event handling function. 358 * 359 * 360 * Returns void 361 * 362 ******************************************************************************/ 363 bool bta_hh_hdl_event(BT_HDR* p_msg) { 364 uint8_t index = BTA_HH_IDX_INVALID; 365 tBTA_HH_DEV_CB* p_cb = NULL; 366 367 switch (p_msg->event) { 368 case BTA_HH_API_ENABLE_EVT: 369 bta_hh_api_enable((tBTA_HH_DATA*)p_msg); 370 break; 371 372 case BTA_HH_API_DISABLE_EVT: 373 bta_hh_api_disable(); 374 break; 375 376 case BTA_HH_DISC_CMPL_EVT: /* disable complete */ 377 bta_hh_disc_cmpl(); 378 break; 379 380 default: 381 /* all events processed in state machine need to find corresponding 382 CB before proceed */ 383 if (p_msg->event == BTA_HH_API_OPEN_EVT) { 384 index = bta_hh_find_cb(((tBTA_HH_API_CONN*)p_msg)->bd_addr); 385 } else if (p_msg->event == BTA_HH_API_MAINT_DEV_EVT) { 386 /* if add device */ 387 if (((tBTA_HH_MAINT_DEV*)p_msg)->sub_event == BTA_HH_ADD_DEV_EVT) { 388 index = bta_hh_find_cb(((tBTA_HH_MAINT_DEV*)p_msg)->bda); 389 } else /* else remove device by handle */ 390 { 391 index = bta_hh_dev_handle_to_cb_idx((uint8_t)p_msg->layer_specific); 392 /* If BT disable is done while the HID device is connected and 393 * Link_Key uses unauthenticated combination 394 * then we can get into a situation where remove_bonding is called 395 * with the index set to 0 (without getting 396 * cleaned up). Only when VIRTUAL_UNPLUG is called do we cleanup the 397 * index and make it MAX_KNOWN. 398 * So if REMOVE_DEVICE is called and in_use is false then we should 399 * treat this as a NULL p_cb. Hence we 400 * force the index to be IDX_INVALID 401 */ 402 if ((index != BTA_HH_IDX_INVALID) && 403 (!bta_hh_cb.kdev[index].in_use)) { 404 index = BTA_HH_IDX_INVALID; 405 } 406 } 407 } else if (p_msg->event == BTA_HH_INT_OPEN_EVT) { 408 index = bta_hh_find_cb(((tBTA_HH_CBACK_DATA*)p_msg)->addr); 409 } else 410 index = bta_hh_dev_handle_to_cb_idx((uint8_t)p_msg->layer_specific); 411 412 if (index != BTA_HH_IDX_INVALID) p_cb = &bta_hh_cb.kdev[index]; 413 414 #if (BTA_HH_DEBUG == TRUE) 415 APPL_TRACE_DEBUG("bta_hh_hdl_event:: handle = %d dev_cb[%d] ", 416 p_msg->layer_specific, index); 417 #endif 418 bta_hh_sm_execute(p_cb, p_msg->event, (tBTA_HH_DATA*)p_msg); 419 } 420 return (true); 421 } 422 423 /***************************************************************************** 424 * Debug Functions 425 ****************************************************************************/ 426 #if (BTA_HH_DEBUG == TRUE) 427 /******************************************************************************* 428 * 429 * Function bta_hh_evt_code 430 * 431 * Description 432 * 433 * Returns void 434 * 435 ******************************************************************************/ 436 static const char* bta_hh_evt_code(tBTA_HH_INT_EVT evt_code) { 437 switch (evt_code) { 438 case BTA_HH_API_DISABLE_EVT: 439 return "BTA_HH_API_DISABLE_EVT"; 440 case BTA_HH_API_ENABLE_EVT: 441 return "BTA_HH_API_ENABLE_EVT"; 442 case BTA_HH_API_OPEN_EVT: 443 return "BTA_HH_API_OPEN_EVT"; 444 case BTA_HH_API_CLOSE_EVT: 445 return "BTA_HH_API_CLOSE_EVT"; 446 case BTA_HH_INT_OPEN_EVT: 447 return "BTA_HH_INT_OPEN_EVT"; 448 case BTA_HH_INT_CLOSE_EVT: 449 return "BTA_HH_INT_CLOSE_EVT"; 450 case BTA_HH_INT_HANDSK_EVT: 451 return "BTA_HH_INT_HANDSK_EVT"; 452 case BTA_HH_INT_DATA_EVT: 453 return "BTA_HH_INT_DATA_EVT"; 454 case BTA_HH_INT_CTRL_DATA: 455 return "BTA_HH_INT_CTRL_DATA"; 456 case BTA_HH_API_WRITE_DEV_EVT: 457 return "BTA_HH_API_WRITE_DEV_EVT"; 458 case BTA_HH_SDP_CMPL_EVT: 459 return "BTA_HH_SDP_CMPL_EVT"; 460 case BTA_HH_DISC_CMPL_EVT: 461 return "BTA_HH_DISC_CMPL_EVT"; 462 case BTA_HH_API_MAINT_DEV_EVT: 463 return "BTA_HH_API_MAINT_DEV_EVT"; 464 case BTA_HH_API_GET_DSCP_EVT: 465 return "BTA_HH_API_GET_DSCP_EVT"; 466 case BTA_HH_OPEN_CMPL_EVT: 467 return "BTA_HH_OPEN_CMPL_EVT"; 468 #if (BTA_HH_LE_INCLUDED == TRUE) 469 case BTA_HH_GATT_CLOSE_EVT: 470 return "BTA_HH_GATT_CLOSE_EVT"; 471 case BTA_HH_GATT_OPEN_EVT: 472 return "BTA_HH_GATT_OPEN_EVT"; 473 case BTA_HH_START_ENC_EVT: 474 return "BTA_HH_START_ENC_EVT"; 475 case BTA_HH_ENC_CMPL_EVT: 476 return "BTA_HH_ENC_CMPL_EVT"; 477 #endif 478 default: 479 return "unknown HID Host event code"; 480 } 481 } 482 483 /******************************************************************************* 484 * 485 * Function bta_hh_state_code 486 * 487 * Description get string representation of HID host state code. 488 * 489 * Returns void 490 * 491 ******************************************************************************/ 492 static const char* bta_hh_state_code(tBTA_HH_STATE state_code) { 493 switch (state_code) { 494 case BTA_HH_NULL_ST: 495 return "BTA_HH_NULL_ST"; 496 case BTA_HH_IDLE_ST: 497 return "BTA_HH_IDLE_ST"; 498 case BTA_HH_W4_CONN_ST: 499 return "BTA_HH_W4_CONN_ST"; 500 case BTA_HH_CONN_ST: 501 return "BTA_HH_CONN_ST"; 502 #if (BTA_HH_LE_INCLUDED == TRUE) 503 case BTA_HH_W4_SEC: 504 return "BTA_HH_W4_SEC"; 505 #endif 506 default: 507 return "unknown HID Host state"; 508 } 509 } 510 511 #endif /* Debug Functions */ 512 513 #endif /* BTA_HH_INCLUDED */ 514
