1 /****************************************************************************** 2 * 3 * Copyright (C) 2005-2012 Broadcom Corporation 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at: 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 * 17 ******************************************************************************/ 18 #include <string.h> 19 20 #include "bt_target.h" 21 #if defined(BTA_HH_INCLUDED) && (BTA_HH_INCLUDED == TRUE) 22 23 24 #include "bta_hh_int.h" 25 26 /* if SSR max latency is not defined by remote device, set the default value 27 as half of the link supervision timeout */ 28 #define BTA_HH_GET_DEF_SSR_MAX_LAT(x) ((x)>> 1) 29 30 /***************************************************************************** 31 ** Constants 32 *****************************************************************************/ 33 #define BTA_HH_KB_CTRL_MASK 0x11 34 #define BTA_HH_KB_SHIFT_MASK 0x22 35 #define BTA_HH_KB_ALT_MASK 0x44 36 #define BTA_HH_KB_GUI_MASK 0x88 37 38 #define BTA_HH_KB_CAPS_LOCK 0x39 /* caps lock */ 39 #define BTA_HH_KB_NUM_LOCK 0x53 /* num lock */ 40 41 42 #define BTA_HH_MAX_RPT_CHARS 8 43 44 static const UINT8 bta_hh_mod_key_mask[BTA_HH_MOD_MAX_KEY] = 45 { 46 BTA_HH_KB_CTRL_MASK, 47 BTA_HH_KB_SHIFT_MASK, 48 BTA_HH_KB_ALT_MASK, 49 BTA_HH_KB_GUI_MASK 50 }; 51 52 53 /******************************************************************************* 54 ** 55 ** Function bta_hh_find_cb 56 ** 57 ** Description Find best available control block according to BD address. 58 ** 59 ** 60 ** Returns void 61 ** 62 *******************************************************************************/ 63 UINT8 bta_hh_find_cb(BD_ADDR bda) 64 { 65 UINT8 xx; 66 67 /* See how many active devices there are. */ 68 for (xx = 0; xx < BTA_HH_MAX_DEVICE; xx++) 69 { 70 /* check if any active/known devices is a match */ 71 if ((!bdcmp (bda, bta_hh_cb.kdev[xx].addr) && 72 bdcmp(bda, bd_addr_null) != 0) ) 73 { 74 #if BTA_HH_DEBUG 75 APPL_TRACE_DEBUG2("found kdev_cb[%d] hid_handle = %d ", xx, 76 bta_hh_cb.kdev[xx].hid_handle) 77 #endif 78 return xx; 79 } 80 #if BTA_HH_DEBUG 81 else 82 APPL_TRACE_DEBUG4("in_use ? [%d] kdev[%d].hid_handle = %d state = [%d]", 83 bta_hh_cb.kdev[xx].in_use, xx, 84 bta_hh_cb.kdev[xx].hid_handle, 85 bta_hh_cb.kdev[xx].state); 86 #endif 87 } 88 89 /* if no active device match, find a spot for it */ 90 for (xx = 0; xx < BTA_HH_MAX_DEVICE; xx++) 91 { 92 if (!bta_hh_cb.kdev[xx].in_use) 93 { 94 bdcpy(bta_hh_cb.kdev[xx].addr, bda); 95 break; 96 } 97 } 98 /* If device list full, report BTA_HH_IDX_INVALID */ 99 #if BTA_HH_DEBUG 100 APPL_TRACE_DEBUG2("bta_hh_find_cb:: index = %d while max = %d", 101 xx, BTA_HH_MAX_DEVICE); 102 #endif 103 104 if (xx == BTA_HH_MAX_DEVICE) 105 xx = BTA_HH_IDX_INVALID; 106 107 return xx; 108 } 109 110 /******************************************************************************* 111 ** 112 ** Function bta_hh_clean_up_kdev 113 ** 114 ** Description Clean up device control block when device is removed from 115 ** manitainace list, and update control block index map. 116 ** 117 ** Returns void 118 ** 119 *******************************************************************************/ 120 void bta_hh_clean_up_kdev(tBTA_HH_DEV_CB *p_cb) 121 { 122 UINT8 index; 123 124 if (p_cb->hid_handle != BTA_HH_INVALID_HANDLE ) 125 { 126 #if BTA_HH_LE_INCLUDED == TRUE 127 if (p_cb->is_le_device) 128 bta_hh_cb.le_cb_index[BTA_HH_GET_LE_CB_IDX(p_cb->hid_handle)] = BTA_HH_IDX_INVALID; 129 else 130 #endif 131 bta_hh_cb.cb_index[p_cb->hid_handle] = BTA_HH_IDX_INVALID; 132 } 133 134 /* reset device control block */ 135 index = p_cb->index; /* Preserve index for this control block */ 136 137 /* Free buffer for report descriptor info */ 138 utl_freebuf((void **)&p_cb->dscp_info.descriptor.dsc_list); 139 140 memset(p_cb, 0, sizeof (tBTA_HH_DEV_CB)); /* Reset control block */ 141 142 p_cb->index = index; /* Restore index for this control block */ 143 p_cb->state = BTA_HH_IDLE_ST; 144 p_cb->hid_handle = BTA_HH_INVALID_HANDLE; 145 146 } 147 /******************************************************************************* 148 ** 149 ** Function bta_hh_update_di_info 150 ** 151 ** Description Maintain a known device list for BTA HH. 152 ** 153 ** Returns void 154 ** 155 *******************************************************************************/ 156 void bta_hh_update_di_info(tBTA_HH_DEV_CB *p_cb, UINT16 vendor_id, UINT16 product_id, 157 UINT16 version, UINT8 flag) 158 { 159 #if BTA_HH_DEBUG 160 APPL_TRACE_DEBUG3("vendor_id = 0x%2x product_id = 0x%2x version = 0x%2x", 161 vendor_id, product_id, version); 162 #endif 163 p_cb->dscp_info.vendor_id = vendor_id; 164 p_cb->dscp_info.product_id = product_id; 165 p_cb->dscp_info.version = version; 166 #if (defined BTA_HH_LE_INCLUDED && BTA_HH_LE_INCLUDED == TRUE) 167 p_cb->dscp_info.flag = flag; 168 #endif 169 } 170 /******************************************************************************* 171 ** 172 ** Function bta_hh_add_device_to_list 173 ** 174 ** Description Maintain a known device list for BTA HH. 175 ** 176 ** Returns void 177 ** 178 *******************************************************************************/ 179 void bta_hh_add_device_to_list(tBTA_HH_DEV_CB *p_cb, UINT8 handle, 180 UINT16 attr_mask, 181 tHID_DEV_DSCP_INFO *p_dscp_info, 182 UINT8 sub_class, 183 UINT16 ssr_max_latency, 184 UINT16 ssr_min_tout, 185 UINT8 app_id) 186 { 187 #if BTA_HH_DEBUG 188 APPL_TRACE_DEBUG1("subclass = 0x%2x", sub_class); 189 #endif 190 191 p_cb->hid_handle = handle; 192 p_cb->in_use = TRUE; 193 p_cb->attr_mask = attr_mask; 194 195 p_cb->sub_class = sub_class; 196 p_cb->app_id = app_id; 197 198 p_cb->dscp_info.ssr_max_latency = ssr_max_latency; 199 p_cb->dscp_info.ssr_min_tout = ssr_min_tout; 200 201 /* store report descriptor info */ 202 if ( p_dscp_info) 203 { 204 utl_freebuf((void **)&p_cb->dscp_info.descriptor.dsc_list); 205 206 if (p_dscp_info->dl_len && 207 (p_cb->dscp_info.descriptor.dsc_list = 208 (UINT8 *)GKI_getbuf(p_dscp_info->dl_len)) != NULL) 209 { 210 p_cb->dscp_info.descriptor.dl_len = p_dscp_info->dl_len; 211 memcpy(p_cb->dscp_info.descriptor.dsc_list, p_dscp_info->dsc_list, 212 p_dscp_info->dl_len); 213 } 214 } 215 return; 216 } 217 218 /******************************************************************************* 219 ** 220 ** Function bta_hh_tod_spt 221 ** 222 ** Description Check to see if this type of device is supported 223 ** 224 ** Returns 225 ** 226 *******************************************************************************/ 227 BOOLEAN bta_hh_tod_spt(tBTA_HH_DEV_CB *p_cb,UINT8 sub_class) 228 { 229 UINT8 xx; 230 UINT8 cod = (sub_class >> 2); /* lower two bits are reserved */ 231 232 for (xx = 0 ; xx < p_bta_hh_cfg->max_devt_spt; xx ++) 233 { 234 if (cod == (UINT8) p_bta_hh_cfg->p_devt_list[xx].tod) 235 { 236 p_cb->app_id = p_bta_hh_cfg->p_devt_list[xx].app_id; 237 #if BTA_HH_DEBUG 238 APPL_TRACE_EVENT1("bta_hh_tod_spt sub_class:0x%x supported", sub_class); 239 #endif 240 return TRUE; 241 } 242 } 243 #if BTA_HH_DEBUG 244 APPL_TRACE_EVENT1("bta_hh_tod_spt sub_class:0x%x NOT supported", sub_class); 245 #endif 246 return FALSE; 247 } 248 249 250 /******************************************************************************* 251 ** 252 ** Function bta_hh_parse_keybd_rpt 253 ** 254 ** Description This utility function parse a boot mode keyboard report. 255 ** 256 ** Returns void 257 ** 258 *******************************************************************************/ 259 void bta_hh_parse_keybd_rpt(tBTA_HH_BOOT_RPT *p_kb_data, UINT8 *p_report, 260 UINT16 report_len) 261 { 262 tBTA_HH_KB_CB *p_kb = &bta_hh_cb.kb_cb; 263 tBTA_HH_KEYBD_RPT *p_data = &p_kb_data->data_rpt.keybd_rpt; 264 265 UINT8 this_char, ctl_shift; 266 UINT16 xx, yy, key_idx = 0; 267 UINT8 this_report[BTA_HH_MAX_RPT_CHARS]; 268 269 #if BTA_HH_DEBUG 270 APPL_TRACE_DEBUG2("bta_hh_parse_keybd_rpt: (report=%p, report_len=%d) called", 271 p_report, report_len); 272 #endif 273 274 if (report_len < 2) 275 return; 276 277 ctl_shift = *p_report++; 278 report_len--; 279 280 if (report_len > BTA_HH_MAX_RPT_CHARS) 281 report_len = BTA_HH_MAX_RPT_CHARS; 282 283 memset (this_report, 0, BTA_HH_MAX_RPT_CHARS); 284 memset (p_data, 0, sizeof(tBTA_HH_KEYBD_RPT)); 285 memcpy (this_report, p_report, report_len); 286 287 /* Take care of shift, control, GUI and alt, modifier keys */ 288 for (xx = 0; xx < BTA_HH_MOD_MAX_KEY; xx ++ ) 289 { 290 if (ctl_shift & bta_hh_mod_key_mask[xx]) 291 { 292 APPL_TRACE_DEBUG1("Mod Key[%02x] pressed", bta_hh_mod_key_mask[xx] ); 293 p_kb->mod_key[xx] = TRUE; 294 } 295 else if (p_kb->mod_key[xx]) 296 { 297 p_kb->mod_key[xx] = FALSE; 298 } 299 /* control key flag is set */ 300 p_data->mod_key[xx] = p_kb->mod_key[xx]; 301 } 302 303 /***************************************************************************/ 304 /* First step is to remove all characters we saw in the last report */ 305 /***************************************************************************/ 306 for (xx = 0; xx < report_len; xx++) 307 { 308 for (yy = 0; yy < BTA_HH_MAX_RPT_CHARS; yy++) 309 { 310 if (this_report[xx] == p_kb->last_report[yy]) 311 { 312 this_report[xx] = 0; 313 } 314 } 315 } 316 /***************************************************************************/ 317 /* Now, process all the characters in the report, up to 6 keycodes */ 318 /***************************************************************************/ 319 for (xx = 0; xx < report_len; xx++) 320 { 321 #if BTA_HH_DEBUG 322 APPL_TRACE_DEBUG1("this_char = %02x", this_report[xx]); 323 #endif 324 if ((this_char = this_report[xx]) == 0) 325 continue; 326 /* take the key code as the report data */ 327 if (this_report[xx] == BTA_HH_KB_CAPS_LOCK) 328 p_kb->caps_lock = p_kb->caps_lock ? FALSE : TRUE; 329 else if (this_report[xx] == BTA_HH_KB_NUM_LOCK) 330 p_kb->num_lock = p_kb->num_lock ? FALSE : TRUE; 331 else 332 p_data->this_char[key_idx ++] = this_char; 333 334 #if BTA_HH_DEBUG 335 APPL_TRACE_DEBUG1("found keycode %02x ", this_report[xx]); 336 #endif 337 p_data->caps_lock = p_kb->caps_lock; 338 p_kb->num_lock = p_kb->num_lock; 339 } 340 341 memset (p_kb->last_report, 0, BTA_HH_MAX_RPT_CHARS); 342 memcpy (p_kb->last_report, p_report, report_len); 343 344 return; 345 } 346 347 /******************************************************************************* 348 ** 349 ** Function bta_hh_parse_mice_rpt 350 ** 351 ** Description This utility function parse a boot mode mouse report. 352 ** 353 ** Returns void 354 ** 355 *******************************************************************************/ 356 void bta_hh_parse_mice_rpt(tBTA_HH_BOOT_RPT *p_mice_data, UINT8 *p_report, 357 UINT16 report_len) 358 { 359 tBTA_HH_MICE_RPT *p_data = &p_mice_data->data_rpt.mice_rpt; 360 #if BTA_HH_DEBUG 361 UINT8 xx; 362 363 APPL_TRACE_DEBUG2("bta_hh_parse_mice_rpt: bta_keybd_rpt_rcvd(report=%p, \ 364 report_len=%d) called", p_report, report_len); 365 #endif 366 367 if (report_len < 3) 368 return; 369 370 if (report_len > BTA_HH_MAX_RPT_CHARS) 371 report_len = BTA_HH_MAX_RPT_CHARS; 372 373 #if BTA_HH_DEBUG 374 for (xx = 0; xx < report_len; xx++) 375 { 376 APPL_TRACE_DEBUG1("this_char = %02x", p_report[xx]); 377 } 378 #endif 379 380 /* only first bytes lower 3 bits valid */ 381 p_data->mouse_button = (p_report[0] & 0x07); 382 383 /* x displacement */ 384 p_data->delta_x = p_report[1]; 385 386 /* y displacement */ 387 p_data->delta_y = p_report[2]; 388 389 #if BTA_HH_DEBUG 390 APPL_TRACE_DEBUG1("mice button: 0x%2x", p_data->mouse_button); 391 APPL_TRACE_DEBUG2("mice move: x = %d y = %d", p_data->delta_x, 392 p_data->delta_y ); 393 #endif 394 395 return; 396 397 } 398 399 /******************************************************************************* 400 ** 401 ** Function bta_hh_read_ssr_param 402 ** 403 ** Description Read the SSR Parameter for the remote device 404 ** 405 ** Returns tBTA_HH_STATUS operation status 406 ** 407 *******************************************************************************/ 408 tBTA_HH_STATUS bta_hh_read_ssr_param(BD_ADDR bd_addr, UINT16 *p_max_ssr_lat, UINT16 *p_min_ssr_tout) 409 { 410 tBTA_HH_STATUS status = BTA_HH_ERR; 411 tBTA_HH_CB *p_cb = &bta_hh_cb; 412 UINT8 i; 413 UINT16 ssr_max_latency; 414 /* lock other GKI task */ 415 GKI_sched_lock(); 416 for (i = 0; i < BTA_HH_MAX_KNOWN; i ++) 417 { 418 if (memcmp(p_cb->kdev[i].addr, bd_addr, BD_ADDR_LEN) == 0) 419 { 420 421 /* if remote device does not have HIDSSRHostMaxLatency attribute in SDP, 422 set SSR max latency default value here. */ 423 if (p_cb->kdev[i].dscp_info.ssr_max_latency == HID_SSR_PARAM_INVALID) 424 { 425 /* The default is calculated as half of link supervision timeout.*/ 426 427 BTM_GetLinkSuperTout(p_cb->kdev[i].addr, &ssr_max_latency) ; 428 ssr_max_latency = BTA_HH_GET_DEF_SSR_MAX_LAT(ssr_max_latency); 429 430 /* per 1.1 spec, if the newly calculated max latency is greater than 431 BTA_HH_SSR_MAX_LATENCY_DEF which is 500ms, use BTA_HH_SSR_MAX_LATENCY_DEF */ 432 if (ssr_max_latency > BTA_HH_SSR_MAX_LATENCY_DEF) 433 ssr_max_latency = BTA_HH_SSR_MAX_LATENCY_DEF; 434 435 * p_max_ssr_lat = ssr_max_latency; 436 } 437 else 438 * p_max_ssr_lat = p_cb->kdev[i].dscp_info.ssr_max_latency; 439 440 if (p_cb->kdev[i].dscp_info.ssr_min_tout == HID_SSR_PARAM_INVALID) 441 * p_min_ssr_tout = BTA_HH_SSR_MIN_TOUT_DEF; 442 else 443 * p_min_ssr_tout = p_cb->kdev[i].dscp_info.ssr_min_tout; 444 445 status = BTA_HH_OK; 446 447 break; 448 } 449 } 450 GKI_sched_unlock(); 451 452 return status; 453 } 454 455 /******************************************************************************* 456 ** 457 ** Function bta_hh_cleanup_disable 458 ** 459 ** Description when disable finished, cleanup control block and send callback 460 ** 461 ** 462 ** Returns void 463 ** 464 *******************************************************************************/ 465 void bta_hh_cleanup_disable(tBTA_HH_STATUS status) 466 { 467 UINT8 xx; 468 /* free buffer in CB holding report descriptors */ 469 for(xx = 0; xx < BTA_HH_MAX_DEVICE; xx ++) 470 { 471 utl_freebuf((void **)&bta_hh_cb.kdev[xx].dscp_info.descriptor.dsc_list); 472 } 473 utl_freebuf((void **)&bta_hh_cb.p_disc_db); 474 475 (* bta_hh_cb.p_cback)(BTA_HH_DISABLE_EVT, (tBTA_HH *)&status); 476 /* all connections are down, no waiting for diconnect */ 477 memset(&bta_hh_cb, 0, sizeof(tBTA_HH_CB)); 478 } 479 480 /******************************************************************************* 481 ** 482 ** Function bta_hh_dev_handle_to_cb_idx 483 ** 484 ** Description convert a HID device handle to the device control block index. 485 ** 486 ** 487 ** Returns UINT8: index of the device control block. 488 ** 489 *******************************************************************************/ 490 UINT8 bta_hh_dev_handle_to_cb_idx(UINT8 dev_handle) 491 { 492 UINT8 index = BTA_HH_IDX_INVALID; 493 494 #if BTA_HH_LE_INCLUDED == TRUE 495 if (BTA_HH_IS_LE_DEV_HDL(dev_handle)) 496 { 497 if (BTA_HH_IS_LE_DEV_HDL_VALID(dev_handle)) 498 index = bta_hh_cb.le_cb_index[BTA_HH_GET_LE_CB_IDX(dev_handle)]; 499 #if BTA_HH_DEBUG == TRUE 500 APPL_TRACE_DEBUG2("bta_hh_dev_handle_to_cb_idx dev_handle = %d index = %d", dev_handle, index); 501 #endif 502 } 503 else 504 #endif 505 /* regular HID device checking */ 506 if (dev_handle < BTA_HH_MAX_KNOWN ) 507 index = bta_hh_cb.cb_index[dev_handle]; 508 509 return index; 510 511 } 512 #if BTA_HH_DEBUG 513 /******************************************************************************* 514 ** 515 ** Function bta_hh_trace_dev_db 516 ** 517 ** Description Check to see if this type of device is supported 518 ** 519 ** Returns 520 ** 521 *******************************************************************************/ 522 void bta_hh_trace_dev_db(void) 523 { 524 UINT8 xx; 525 526 APPL_TRACE_DEBUG0("bta_hh_trace_dev_db:: Device DB list********************"); 527 528 for (xx = 0; xx < BTA_HH_MAX_DEVICE; xx++) 529 { 530 APPL_TRACE_DEBUG3("kdev[%d] in_use[%d] handle[%d] ",xx, 531 bta_hh_cb.kdev[xx].in_use, bta_hh_cb.kdev[xx].hid_handle); 532 533 APPL_TRACE_DEBUG4("\t\t\t attr_mask[%04x] state [%d] sub_class[%02x] index = %d", 534 bta_hh_cb.kdev[xx].attr_mask, bta_hh_cb.kdev[xx].state, 535 bta_hh_cb.kdev[xx].sub_class, bta_hh_cb.kdev[xx].index); 536 } 537 APPL_TRACE_DEBUG0("*********************************************************"); 538 } 539 #endif 540 #endif /* HL_INCLUDED */ 541
