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