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_DEBUG("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_DEBUG("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_DEBUG("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 osi_free_and_reset((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_DEBUG("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 #else 169 UNUSED(flag); 170 #endif 171 } 172 /******************************************************************************* 173 ** 174 ** Function bta_hh_add_device_to_list 175 ** 176 ** Description Maintain a known device list for BTA HH. 177 ** 178 ** Returns void 179 ** 180 *******************************************************************************/ 181 void bta_hh_add_device_to_list(tBTA_HH_DEV_CB *p_cb, UINT8 handle, 182 UINT16 attr_mask, 183 tHID_DEV_DSCP_INFO *p_dscp_info, 184 UINT8 sub_class, 185 UINT16 ssr_max_latency, 186 UINT16 ssr_min_tout, 187 UINT8 app_id) 188 { 189 #if BTA_HH_DEBUG 190 APPL_TRACE_DEBUG("subclass = 0x%2x", sub_class); 191 #endif 192 193 p_cb->hid_handle = handle; 194 p_cb->in_use = TRUE; 195 p_cb->attr_mask = attr_mask; 196 197 p_cb->sub_class = sub_class; 198 p_cb->app_id = app_id; 199 200 p_cb->dscp_info.ssr_max_latency = ssr_max_latency; 201 p_cb->dscp_info.ssr_min_tout = ssr_min_tout; 202 203 /* store report descriptor info */ 204 if (p_dscp_info) { 205 osi_free_and_reset((void **)&p_cb->dscp_info.descriptor.dsc_list); 206 207 if (p_dscp_info->dl_len) { 208 p_cb->dscp_info.descriptor.dsc_list = 209 (UINT8 *)osi_malloc(p_dscp_info->dl_len); 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 } 216 217 /******************************************************************************* 218 ** 219 ** Function bta_hh_tod_spt 220 ** 221 ** Description Check to see if this type of device is supported 222 ** 223 ** Returns 224 ** 225 *******************************************************************************/ 226 BOOLEAN bta_hh_tod_spt(tBTA_HH_DEV_CB *p_cb,UINT8 sub_class) 227 { 228 UINT8 xx; 229 UINT8 cod = (sub_class >> 2); /* lower two bits are reserved */ 230 231 for (xx = 0 ; xx < p_bta_hh_cfg->max_devt_spt; xx ++) 232 { 233 if (cod == (UINT8) p_bta_hh_cfg->p_devt_list[xx].tod) 234 { 235 p_cb->app_id = p_bta_hh_cfg->p_devt_list[xx].app_id; 236 #if BTA_HH_DEBUG 237 APPL_TRACE_EVENT("bta_hh_tod_spt sub_class:0x%x supported", sub_class); 238 #endif 239 return TRUE; 240 } 241 } 242 #if BTA_HH_DEBUG 243 APPL_TRACE_EVENT("bta_hh_tod_spt sub_class:0x%x NOT supported", sub_class); 244 #endif 245 return FALSE; 246 } 247 248 249 /******************************************************************************* 250 ** 251 ** Function bta_hh_parse_keybd_rpt 252 ** 253 ** Description This utility function parse a boot mode keyboard report. 254 ** 255 ** Returns void 256 ** 257 *******************************************************************************/ 258 void bta_hh_parse_keybd_rpt(tBTA_HH_BOOT_RPT *p_kb_data, UINT8 *p_report, 259 UINT16 report_len) 260 { 261 tBTA_HH_KB_CB *p_kb = &bta_hh_cb.kb_cb; 262 tBTA_HH_KEYBD_RPT *p_data = &p_kb_data->data_rpt.keybd_rpt; 263 264 UINT8 this_char, ctl_shift; 265 UINT16 xx, yy, key_idx = 0; 266 UINT8 this_report[BTA_HH_MAX_RPT_CHARS]; 267 268 #if BTA_HH_DEBUG 269 APPL_TRACE_DEBUG("bta_hh_parse_keybd_rpt: (report=%p, report_len=%d) called", 270 p_report, report_len); 271 #endif 272 273 if (report_len < 2) 274 return; 275 276 ctl_shift = *p_report++; 277 report_len--; 278 279 if (report_len > BTA_HH_MAX_RPT_CHARS) 280 report_len = BTA_HH_MAX_RPT_CHARS; 281 282 memset (this_report, 0, BTA_HH_MAX_RPT_CHARS); 283 memset (p_data, 0, sizeof(tBTA_HH_KEYBD_RPT)); 284 memcpy (this_report, p_report, report_len); 285 286 /* Take care of shift, control, GUI and alt, modifier keys */ 287 for (xx = 0; xx < BTA_HH_MOD_MAX_KEY; xx ++ ) 288 { 289 if (ctl_shift & bta_hh_mod_key_mask[xx]) 290 { 291 APPL_TRACE_DEBUG("Mod Key[%02x] pressed", bta_hh_mod_key_mask[xx] ); 292 p_kb->mod_key[xx] = TRUE; 293 } 294 else if (p_kb->mod_key[xx]) 295 { 296 p_kb->mod_key[xx] = FALSE; 297 } 298 /* control key flag is set */ 299 p_data->mod_key[xx] = p_kb->mod_key[xx]; 300 } 301 302 /***************************************************************************/ 303 /* First step is to remove all characters we saw in the last report */ 304 /***************************************************************************/ 305 for (xx = 0; xx < report_len; xx++) 306 { 307 for (yy = 0; yy < BTA_HH_MAX_RPT_CHARS; yy++) 308 { 309 if (this_report[xx] == p_kb->last_report[yy]) 310 { 311 this_report[xx] = 0; 312 } 313 } 314 } 315 /***************************************************************************/ 316 /* Now, process all the characters in the report, up to 6 keycodes */ 317 /***************************************************************************/ 318 for (xx = 0; xx < report_len; xx++) 319 { 320 #if BTA_HH_DEBUG 321 APPL_TRACE_DEBUG("this_char = %02x", this_report[xx]); 322 #endif 323 if ((this_char = this_report[xx]) == 0) 324 continue; 325 /* take the key code as the report data */ 326 if (this_report[xx] == BTA_HH_KB_CAPS_LOCK) 327 p_kb->caps_lock = p_kb->caps_lock ? FALSE : TRUE; 328 else if (this_report[xx] == BTA_HH_KB_NUM_LOCK) 329 p_kb->num_lock = p_kb->num_lock ? FALSE : TRUE; 330 else 331 p_data->this_char[key_idx ++] = this_char; 332 333 #if BTA_HH_DEBUG 334 APPL_TRACE_DEBUG("found keycode %02x ", this_report[xx]); 335 #endif 336 p_data->caps_lock = p_kb->caps_lock; 337 p_data->num_lock = p_kb->num_lock; 338 } 339 340 memset (p_kb->last_report, 0, BTA_HH_MAX_RPT_CHARS); 341 memcpy (p_kb->last_report, p_report, report_len); 342 343 return; 344 } 345 346 /******************************************************************************* 347 ** 348 ** Function bta_hh_parse_mice_rpt 349 ** 350 ** Description This utility function parse a boot mode mouse report. 351 ** 352 ** Returns void 353 ** 354 *******************************************************************************/ 355 void bta_hh_parse_mice_rpt(tBTA_HH_BOOT_RPT *p_mice_data, UINT8 *p_report, 356 UINT16 report_len) 357 { 358 tBTA_HH_MICE_RPT *p_data = &p_mice_data->data_rpt.mice_rpt; 359 #if BTA_HH_DEBUG 360 UINT8 xx; 361 362 APPL_TRACE_DEBUG("bta_hh_parse_mice_rpt: bta_keybd_rpt_rcvd(report=%p, \ 363 report_len=%d) called", p_report, report_len); 364 #endif 365 366 if (report_len < 3) 367 return; 368 369 if (report_len > BTA_HH_MAX_RPT_CHARS) 370 report_len = BTA_HH_MAX_RPT_CHARS; 371 372 #if BTA_HH_DEBUG 373 for (xx = 0; xx < report_len; xx++) 374 { 375 APPL_TRACE_DEBUG("this_char = %02x", p_report[xx]); 376 } 377 #endif 378 379 /* only first bytes lower 3 bits valid */ 380 p_data->mouse_button = (p_report[0] & 0x07); 381 382 /* x displacement */ 383 p_data->delta_x = p_report[1]; 384 385 /* y displacement */ 386 p_data->delta_y = p_report[2]; 387 388 #if BTA_HH_DEBUG 389 APPL_TRACE_DEBUG("mice button: 0x%2x", p_data->mouse_button); 390 APPL_TRACE_DEBUG("mice move: x = %d y = %d", p_data->delta_x, 391 p_data->delta_y ); 392 #endif 393 394 return; 395 396 } 397 398 /******************************************************************************* 399 ** 400 ** Function bta_hh_read_ssr_param 401 ** 402 ** Description Read the SSR Parameter for the remote device 403 ** 404 ** Returns tBTA_HH_STATUS operation status 405 ** 406 *******************************************************************************/ 407 tBTA_HH_STATUS bta_hh_read_ssr_param(BD_ADDR bd_addr, UINT16 *p_max_ssr_lat, UINT16 *p_min_ssr_tout) 408 { 409 tBTA_HH_STATUS status = BTA_HH_ERR; 410 tBTA_HH_CB *p_cb = &bta_hh_cb; 411 UINT8 i; 412 UINT16 ssr_max_latency; 413 for (i = 0; i < BTA_HH_MAX_KNOWN; i ++) 414 { 415 if (memcmp(p_cb->kdev[i].addr, bd_addr, BD_ADDR_LEN) == 0) 416 { 417 418 /* if remote device does not have HIDSSRHostMaxLatency attribute in SDP, 419 set SSR max latency default value here. */ 420 if (p_cb->kdev[i].dscp_info.ssr_max_latency == HID_SSR_PARAM_INVALID) 421 { 422 /* The default is calculated as half of link supervision timeout.*/ 423 424 BTM_GetLinkSuperTout(p_cb->kdev[i].addr, &ssr_max_latency) ; 425 ssr_max_latency = BTA_HH_GET_DEF_SSR_MAX_LAT(ssr_max_latency); 426 427 /* per 1.1 spec, if the newly calculated max latency is greater than 428 BTA_HH_SSR_MAX_LATENCY_DEF which is 500ms, use BTA_HH_SSR_MAX_LATENCY_DEF */ 429 if (ssr_max_latency > BTA_HH_SSR_MAX_LATENCY_DEF) 430 ssr_max_latency = BTA_HH_SSR_MAX_LATENCY_DEF; 431 432 * p_max_ssr_lat = ssr_max_latency; 433 } 434 else 435 * p_max_ssr_lat = p_cb->kdev[i].dscp_info.ssr_max_latency; 436 437 if (p_cb->kdev[i].dscp_info.ssr_min_tout == HID_SSR_PARAM_INVALID) 438 * p_min_ssr_tout = BTA_HH_SSR_MIN_TOUT_DEF; 439 else 440 * p_min_ssr_tout = p_cb->kdev[i].dscp_info.ssr_min_tout; 441 442 status = BTA_HH_OK; 443 444 break; 445 } 446 } 447 448 return status; 449 } 450 451 /******************************************************************************* 452 ** 453 ** Function bta_hh_cleanup_disable 454 ** 455 ** Description when disable finished, cleanup control block and send callback 456 ** 457 ** 458 ** Returns void 459 ** 460 *******************************************************************************/ 461 void bta_hh_cleanup_disable(tBTA_HH_STATUS status) 462 { 463 UINT8 xx; 464 /* free buffer in CB holding report descriptors */ 465 for (xx = 0; xx < BTA_HH_MAX_DEVICE; xx ++) { 466 osi_free_and_reset((void **)&bta_hh_cb.kdev[xx].dscp_info.descriptor.dsc_list); 467 } 468 osi_free_and_reset((void **)&bta_hh_cb.p_disc_db); 469 470 (* bta_hh_cb.p_cback)(BTA_HH_DISABLE_EVT, (tBTA_HH *)&status); 471 /* all connections are down, no waiting for diconnect */ 472 memset(&bta_hh_cb, 0, sizeof(tBTA_HH_CB)); 473 } 474 475 /******************************************************************************* 476 ** 477 ** Function bta_hh_dev_handle_to_cb_idx 478 ** 479 ** Description convert a HID device handle to the device control block index. 480 ** 481 ** 482 ** Returns UINT8: index of the device control block. 483 ** 484 *******************************************************************************/ 485 UINT8 bta_hh_dev_handle_to_cb_idx(UINT8 dev_handle) 486 { 487 UINT8 index = BTA_HH_IDX_INVALID; 488 489 #if BTA_HH_LE_INCLUDED == TRUE 490 if (BTA_HH_IS_LE_DEV_HDL(dev_handle)) 491 { 492 if (BTA_HH_IS_LE_DEV_HDL_VALID(dev_handle)) 493 index = bta_hh_cb.le_cb_index[BTA_HH_GET_LE_CB_IDX(dev_handle)]; 494 #if BTA_HH_DEBUG == TRUE 495 APPL_TRACE_DEBUG("bta_hh_dev_handle_to_cb_idx dev_handle = %d index = %d", dev_handle, index); 496 #endif 497 } 498 else 499 #endif 500 /* regular HID device checking */ 501 if (dev_handle < BTA_HH_MAX_KNOWN ) 502 index = bta_hh_cb.cb_index[dev_handle]; 503 504 return index; 505 506 } 507 #if BTA_HH_DEBUG 508 /******************************************************************************* 509 ** 510 ** Function bta_hh_trace_dev_db 511 ** 512 ** Description Check to see if this type of device is supported 513 ** 514 ** Returns 515 ** 516 *******************************************************************************/ 517 void bta_hh_trace_dev_db(void) 518 { 519 UINT8 xx; 520 521 APPL_TRACE_DEBUG("bta_hh_trace_dev_db:: Device DB list********************"); 522 523 for (xx = 0; xx < BTA_HH_MAX_DEVICE; xx++) 524 { 525 APPL_TRACE_DEBUG("kdev[%d] in_use[%d] handle[%d] ",xx, 526 bta_hh_cb.kdev[xx].in_use, bta_hh_cb.kdev[xx].hid_handle); 527 528 APPL_TRACE_DEBUG("\t\t\t attr_mask[%04x] state [%d] sub_class[%02x] index = %d", 529 bta_hh_cb.kdev[xx].attr_mask, bta_hh_cb.kdev[xx].state, 530 bta_hh_cb.kdev[xx].sub_class, bta_hh_cb.kdev[xx].index); 531 } 532 APPL_TRACE_DEBUG("*********************************************************"); 533 } 534 #endif 535 #endif /* HL_INCLUDED */ 536
