btif_hh.c revision 5738f83aeb59361a0a2eda2460113f6dc9194271
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 68extern const int BT_UID; 69extern const int BT_GID; 70static int btif_hh_prev_keyevents=0; //The previous key events 71static 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 */ 86typedef 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 105typedef 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************************************************************************************/ 115btif_hh_cb_t btif_hh_cb; 116 117static 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.*/ 122static 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************************************************************************************/ 149extern void bta_hh_co_destroy(int fd); 150extern void bta_hh_co_write(int fd, UINT8* rpt, UINT16 len); 151extern bt_status_t btif_dm_remove_bond(const bt_bdaddr_t *bd_addr); 152extern 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); 155extern BOOLEAN check_cod(const bt_bdaddr_t *remote_bdaddr, uint32_t cod); 156extern void btif_dm_cb_remove_bond(bt_bdaddr_t *bd_addr); 157extern int scru_ascii_2_hex(char *p_ascii, int len, UINT8 *p_hex); 158 159/***************************************************************************** 160** Local Function prototypes 161*****************************************************************************/ 162static void set_keylockstate(int keymask, BOOLEAN isSet); 163static void toggle_os_keylockstates(int fd, int changedkeystates); 164static 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 172static int get_keylockstates() 173{ 174 return btif_hh_keylockstates; 175} 176 177static 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 198static 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*******************************************************************************/ 251static 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*******************************************************************************/ 289static 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*******************************************************************************/ 326static 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*******************************************************************************/ 349btif_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*******************************************************************************/ 370static 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*******************************************************************************/ 391static 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*******************************************************************************/ 412BOOLEAN 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 *******************************************************************************/ 451void 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 498BOOLEAN 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 531bt_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 564bt_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 638void 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*******************************************************************************/ 671static 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 964static 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 1004static 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*******************************************************************************/ 1056static 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*******************************************************************************/ 1080static 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*******************************************************************************/ 1101static 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*******************************************************************************/ 1133static 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*******************************************************************************/ 1167static 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*******************************************************************************/ 1220static 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*******************************************************************************/ 1253static 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*******************************************************************************/ 1288static 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*******************************************************************************/ 1321static 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*******************************************************************************/ 1365static 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*******************************************************************************/ 1411static 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*******************************************************************************/ 1483static 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*******************************************************************************/ 1550static 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 1577static 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*******************************************************************************/ 1603bt_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*******************************************************************************/ 1626const bthh_interface_t *btif_hh_get_interface() 1627{ 1628 BTIF_TRACE_EVENT1("%s", __FUNCTION__); 1629 return &bthhInterface; 1630} 1631