1 /****************************************************************************** 2 * 3 * Copyright (C) 2002-2012 Broadcom Corporation 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at: 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 * 17 ******************************************************************************/ 18 19 /****************************************************************************** 20 * 21 * This file contains the HID HOST API entry points 22 * 23 ******************************************************************************/ 24 25 #include <stdlib.h> 26 #include <string.h> 27 #include <stdio.h> 28 29 #include "gki.h" 30 #include "bt_types.h" 31 #include "hiddefs.h" 32 #include "hidh_api.h" 33 #include "hidh_int.h" 34 #include "btm_api.h" 35 #include "btu.h" 36 #include "btm_int.h" 37 38 #if HID_DYNAMIC_MEMORY == FALSE 39 tHID_HOST_CTB hh_cb; 40 #endif 41 42 static void hidh_search_callback (UINT16 sdp_result); 43 44 /******************************************************************************* 45 ** 46 ** Function HID_HostGetSDPRecord 47 ** 48 ** Description This function reads the device SDP record 49 ** 50 ** Returns tHID_STATUS 51 ** 52 *******************************************************************************/ 53 tHID_STATUS HID_HostGetSDPRecord ( BD_ADDR addr, tSDP_DISCOVERY_DB *p_db, UINT32 db_len, 54 tHID_HOST_SDP_CALLBACK *sdp_cback ) 55 { 56 tSDP_UUID uuid_list; 57 58 if( hh_cb.sdp_busy ) 59 return HID_ERR_SDP_BUSY; 60 61 uuid_list.len = 2; 62 uuid_list.uu.uuid16 = UUID_SERVCLASS_HUMAN_INTERFACE; 63 64 hh_cb.p_sdp_db = p_db; 65 SDP_InitDiscoveryDb (p_db, db_len, 1, &uuid_list, 0, NULL); 66 67 if (SDP_ServiceSearchRequest (addr, p_db, hidh_search_callback)) 68 { 69 hh_cb.sdp_cback = sdp_cback ; 70 hh_cb.sdp_busy = TRUE; 71 return HID_SUCCESS; 72 } 73 else 74 return HID_ERR_NO_RESOURCES; 75 } 76 77 void hidh_get_str_attr( tSDP_DISC_REC *p_rec, UINT16 attr_id, UINT16 max_len, char *str ) 78 { 79 tSDP_DISC_ATTR *p_attr; 80 UINT16 name_len; 81 82 if ((p_attr = SDP_FindAttributeInRec(p_rec, attr_id)) != NULL) 83 { 84 if((name_len = SDP_DISC_ATTR_LEN(p_attr->attr_len_type)) < max_len ) 85 { 86 memcpy( str, (char *) p_attr->attr_value.v.array, name_len ); 87 str[name_len] = '\0'; 88 } 89 else 90 { 91 memcpy( str, (char *) p_attr->attr_value.v.array, max_len-1 ); 92 str[max_len-1] = '\0'; 93 } 94 } 95 else 96 str[0] = '\0'; 97 } 98 99 100 static void hidh_search_callback (UINT16 sdp_result) 101 { 102 tSDP_DISCOVERY_DB *p_db = hh_cb.p_sdp_db; 103 tSDP_DISC_REC *p_rec; 104 tSDP_DISC_ATTR *p_attr, *p_subattr1, *p_subattr2, *p_repdesc; 105 tBT_UUID hid_uuid; 106 tHID_DEV_SDP_INFO *p_nvi = &hh_cb.sdp_rec; 107 UINT16 attr_mask = 0; 108 109 hid_uuid.len = LEN_UUID_16; 110 hid_uuid.uu.uuid16 = UUID_SERVCLASS_HUMAN_INTERFACE; 111 112 hh_cb.sdp_busy = FALSE; 113 114 if (sdp_result != SDP_SUCCESS) 115 { 116 hh_cb.sdp_cback(sdp_result, 0, NULL); 117 return; 118 } 119 120 if ((p_rec = SDP_FindServiceUUIDInDb (p_db, &hid_uuid, NULL)) == NULL) 121 { 122 hh_cb.sdp_cback(HID_SDP_NO_SERV_UUID, 0, NULL); 123 return; 124 } 125 126 memset (&hh_cb.sdp_rec, 0, sizeof( tHID_DEV_SDP_INFO )); 127 128 /* First, verify the mandatory fields we care about */ 129 if (((p_attr = SDP_FindAttributeInRec (p_rec, ATTR_ID_HID_DESCRIPTOR_LIST)) == NULL) 130 || (SDP_DISC_ATTR_TYPE(p_attr->attr_len_type) != DATA_ELE_SEQ_DESC_TYPE) 131 || ((p_subattr1 = p_attr->attr_value.v.p_sub_attr) == NULL) 132 || (SDP_DISC_ATTR_TYPE(p_subattr1->attr_len_type) != DATA_ELE_SEQ_DESC_TYPE) 133 || ((p_subattr2 = p_subattr1->attr_value.v.p_sub_attr) == NULL) 134 || ((p_repdesc = p_subattr2->p_next_attr) == NULL) 135 || (SDP_DISC_ATTR_TYPE(p_repdesc->attr_len_type) != TEXT_STR_DESC_TYPE)) 136 { 137 hh_cb.sdp_cback(HID_SDP_MANDATORY_MISSING, 0, NULL); 138 return; 139 } 140 141 if ((p_nvi->dscp_info.dl_len = SDP_DISC_ATTR_LEN(p_repdesc->attr_len_type)) != 0) 142 p_nvi->dscp_info.dsc_list = (UINT8 *) &p_repdesc->attr_value; 143 144 if (((p_attr = SDP_FindAttributeInRec (p_rec, ATTR_ID_HID_VIRTUAL_CABLE)) != NULL) && 145 (p_attr->attr_value.v.u8) ) 146 { 147 attr_mask |= HID_VIRTUAL_CABLE; 148 } 149 150 if (((p_attr = SDP_FindAttributeInRec (p_rec, ATTR_ID_HID_RECONNECT_INITIATE)) != NULL) && 151 (p_attr->attr_value.v.u8) ) 152 { 153 attr_mask |= HID_RECONN_INIT; 154 } 155 156 if (((p_attr = SDP_FindAttributeInRec (p_rec, ATTR_ID_HID_NORMALLY_CONNECTABLE)) != NULL) && 157 (p_attr->attr_value.v.u8) ) 158 { 159 attr_mask |= HID_NORMALLY_CONNECTABLE; 160 } 161 162 if (((p_attr = SDP_FindAttributeInRec (p_rec, ATTR_ID_HID_SDP_DISABLE)) != NULL)&& 163 (p_attr->attr_value.v.u8) ) 164 { 165 attr_mask |= HID_SDP_DISABLE; 166 } 167 168 if (((p_attr = SDP_FindAttributeInRec (p_rec, ATTR_ID_HID_BATTERY_POWER)) != NULL)&& 169 (p_attr->attr_value.v.u8) ) 170 { 171 attr_mask |= HID_BATTERY_POWER; 172 } 173 174 if (((p_attr = SDP_FindAttributeInRec (p_rec, ATTR_ID_HID_REMOTE_WAKE)) != NULL)&& 175 (p_attr->attr_value.v.u8) ) 176 { 177 attr_mask |= HID_REMOTE_WAKE; 178 } 179 180 hidh_get_str_attr( p_rec, ATTR_ID_SERVICE_NAME, HID_MAX_SVC_NAME_LEN, p_nvi->svc_name ); 181 hidh_get_str_attr( p_rec, ATTR_ID_SERVICE_DESCRIPTION, HID_MAX_SVC_DESCR_LEN, p_nvi->svc_descr ); 182 hidh_get_str_attr( p_rec, ATTR_ID_PROVIDER_NAME, HID_MAX_PROV_NAME_LEN, p_nvi->prov_name ); 183 184 if (((p_attr = SDP_FindAttributeInRec (p_rec, ATTR_ID_HID_DEVICE_RELNUM)) != NULL)) 185 { 186 p_nvi->rel_num = p_attr->attr_value.v.u16; 187 } 188 189 if (((p_attr = SDP_FindAttributeInRec (p_rec, ATTR_ID_HID_COUNTRY_CODE)) != NULL)) 190 { 191 p_nvi->ctry_code = p_attr->attr_value.v.u8; 192 } 193 194 if (((p_attr = SDP_FindAttributeInRec (p_rec, ATTR_ID_HID_DEVICE_SUBCLASS)) != NULL)) 195 { 196 p_nvi->sub_class = p_attr->attr_value.v.u8; 197 } 198 199 if (((p_attr = SDP_FindAttributeInRec (p_rec, ATTR_ID_HID_PARSER_VERSION)) != NULL)) 200 { 201 p_nvi->hpars_ver = p_attr->attr_value.v.u16; 202 } 203 204 if (((p_attr = SDP_FindAttributeInRec (p_rec, ATTR_ID_HID_LINK_SUPERVISION_TO)) != NULL)) 205 { 206 attr_mask |= HID_SUP_TOUT_AVLBL; 207 p_nvi->sup_timeout = p_attr->attr_value.v.u16; 208 } 209 210 if (((p_attr = SDP_FindAttributeInRec (p_rec, ATTR_ID_HID_SSR_HOST_MAX_LAT)) != NULL)) 211 { 212 attr_mask |= HID_SSR_MAX_LATENCY; 213 p_nvi->ssr_max_latency = p_attr->attr_value.v.u16; 214 } 215 else 216 p_nvi->ssr_max_latency = HID_SSR_PARAM_INVALID; 217 218 if (((p_attr = SDP_FindAttributeInRec (p_rec, ATTR_ID_HID_SSR_HOST_MIN_TOUT)) != NULL)) 219 { 220 attr_mask |= HID_SSR_MIN_TOUT; 221 p_nvi->ssr_min_tout = p_attr->attr_value.v.u16; 222 } 223 else 224 p_nvi->ssr_min_tout = HID_SSR_PARAM_INVALID; 225 226 hh_cb.sdp_rec.p_sdp_layer_rec = p_rec; 227 hh_cb.sdp_cback(SDP_SUCCESS, attr_mask, &hh_cb.sdp_rec); 228 } 229 230 231 /******************************************************************************* 232 ** 233 ** Function HID_HostInit 234 ** 235 ** Description This function initializes the control block and trace variable 236 ** 237 ** Returns void 238 ** 239 *******************************************************************************/ 240 void HID_HostInit (void) 241 { 242 memset(&hh_cb, 0, sizeof(tHID_HOST_CTB)); 243 244 #if defined(HID_INITIAL_TRACE_LEVEL) 245 hh_cb.trace_level = HID_INITIAL_TRACE_LEVEL; 246 #else 247 hh_cb.trace_level = BT_TRACE_LEVEL_NONE; 248 #endif 249 } 250 251 /******************************************************************************* 252 ** 253 ** Function HID_HostSetTraceLevel 254 ** 255 ** Description This function sets the trace level for HID Host. If called with 256 ** a value of 0xFF, it simply reads the current trace level. 257 ** 258 ** Returns the new (current) trace level 259 ** 260 *******************************************************************************/ 261 UINT8 HID_HostSetTraceLevel (UINT8 new_level) 262 { 263 if (new_level != 0xFF) 264 hh_cb.trace_level = new_level; 265 266 return (hh_cb.trace_level); 267 } 268 269 /******************************************************************************* 270 ** 271 ** Function HID_HostRegister 272 ** 273 ** Description This function registers HID-Host with lower layers 274 ** 275 ** Returns tHID_STATUS 276 ** 277 *******************************************************************************/ 278 tHID_STATUS HID_HostRegister (tHID_HOST_DEV_CALLBACK *dev_cback) 279 { 280 tHID_STATUS st; 281 282 if( hh_cb.reg_flag ) 283 return HID_ERR_ALREADY_REGISTERED; 284 285 if( dev_cback == NULL ) 286 return HID_ERR_INVALID_PARAM; 287 288 /* Register with L2CAP */ 289 if( (st = hidh_conn_reg()) != HID_SUCCESS ) 290 { 291 return st; 292 } 293 294 hh_cb.callback = dev_cback ; 295 hh_cb.reg_flag = TRUE; 296 297 return (HID_SUCCESS); 298 } 299 300 /******************************************************************************* 301 ** 302 ** Function HID_HostDeregister 303 ** 304 ** Description This function is called when the host is about power down. 305 ** 306 ** Returns tHID_STATUS 307 ** 308 *******************************************************************************/ 309 tHID_STATUS HID_HostDeregister(void) 310 { 311 UINT8 i; 312 313 if( !hh_cb.reg_flag ) 314 return (HID_ERR_NOT_REGISTERED); 315 316 for( i=0; i<HID_HOST_MAX_DEVICES; i++ ) 317 { 318 HID_HostRemoveDev( i ) ; 319 } 320 321 hidh_conn_dereg(); 322 hh_cb.reg_flag = FALSE; 323 324 return (HID_SUCCESS) ; 325 } 326 327 /******************************************************************************* 328 ** 329 ** Function HID_HostAddDev 330 ** 331 ** Description This is called so HID-host may manage this device. 332 ** 333 ** Returns tHID_STATUS 334 ** 335 *******************************************************************************/ 336 tHID_STATUS HID_HostAddDev ( BD_ADDR addr, UINT16 attr_mask, UINT8 *handle ) 337 { 338 int i; 339 /* Find an entry for this device in hh_cb.devices array */ 340 if( !hh_cb.reg_flag ) 341 return (HID_ERR_NOT_REGISTERED); 342 343 for( i=0; i<HID_HOST_MAX_DEVICES; i++) 344 { 345 if((hh_cb.devices[i].in_use) && 346 (!memcmp(addr, hh_cb.devices[i].addr, BD_ADDR_LEN))) 347 break; 348 } 349 350 if (i== HID_HOST_MAX_DEVICES ) 351 { 352 for( i=0; i<HID_HOST_MAX_DEVICES; i++) 353 { 354 if( !hh_cb.devices[i].in_use) 355 break; 356 } 357 } 358 359 if( i==HID_HOST_MAX_DEVICES ) 360 return HID_ERR_NO_RESOURCES; 361 362 if (!hh_cb.devices[i].in_use) 363 { 364 hh_cb.devices[i].in_use = TRUE; 365 memcpy( hh_cb.devices[i].addr, addr, sizeof( BD_ADDR ) ) ; 366 hh_cb.devices[i].state = HID_DEV_NO_CONN; 367 hh_cb.devices[i].conn_tries = 0 ; 368 } 369 370 if (attr_mask != HID_ATTR_MASK_IGNORE) 371 hh_cb.devices[i].attr_mask = attr_mask; 372 373 *handle = i; 374 375 return (HID_SUCCESS); 376 } 377 378 379 /******************************************************************************* 380 ** 381 ** Function HID_HostRemoveDev 382 ** 383 ** Description This removes the device from list devices that host has to manage. 384 ** 385 ** Returns tHID_STATUS 386 ** 387 *******************************************************************************/ 388 tHID_STATUS HID_HostRemoveDev ( UINT8 dev_handle ) 389 { 390 if( !hh_cb.reg_flag ) 391 return (HID_ERR_NOT_REGISTERED); 392 393 if( (dev_handle >= HID_HOST_MAX_DEVICES) || (!hh_cb.devices[dev_handle].in_use) ) 394 return HID_ERR_INVALID_PARAM; 395 396 HID_HostCloseDev( dev_handle ) ; 397 hh_cb.devices[dev_handle].in_use = FALSE; 398 hh_cb.devices[dev_handle].conn.conn_state = HID_CONN_STATE_UNUSED; 399 hh_cb.devices[dev_handle].conn.ctrl_cid = hh_cb.devices[dev_handle].conn.intr_cid = 0; 400 401 return HID_SUCCESS; 402 } 403 404 /******************************************************************************* 405 ** 406 ** Function HID_HostOpenDev 407 ** 408 ** Description This function is called when the user wants to initiate a 409 ** connection attempt to a device. 410 ** 411 ** Returns void 412 ** 413 *******************************************************************************/ 414 tHID_STATUS HID_HostOpenDev ( UINT8 dev_handle ) 415 { 416 if( !hh_cb.reg_flag ) 417 return (HID_ERR_NOT_REGISTERED); 418 419 if( (dev_handle >= HID_HOST_MAX_DEVICES) || (!hh_cb.devices[dev_handle].in_use) ) 420 return HID_ERR_INVALID_PARAM; 421 422 if( hh_cb.devices[dev_handle].state != HID_DEV_NO_CONN ) 423 return HID_ERR_ALREADY_CONN; 424 425 hh_cb.devices[dev_handle].conn_tries = 1; 426 return hidh_conn_initiate( dev_handle ); 427 } 428 429 /******************************************************************************* 430 ** 431 ** Function HID_HostWriteDev 432 ** 433 ** Description This function is called when the host has a report to send. 434 ** 435 ** report_id: is only used on GET_REPORT transaction if is specified. 436 ** only valid when it's a non-zero value. 437 ** 438 ** Returns void 439 ** 440 *******************************************************************************/ 441 tHID_STATUS HID_HostWriteDev( UINT8 dev_handle, UINT8 t_type, 442 UINT8 param, UINT16 data, UINT8 report_id, BT_HDR *pbuf ) 443 { 444 tHID_STATUS status = HID_SUCCESS; 445 446 if( !hh_cb.reg_flag ) 447 { 448 HIDH_TRACE_ERROR0("HID_ERR_NOT_REGISTERED"); 449 status = HID_ERR_NOT_REGISTERED; 450 } 451 452 if( (dev_handle >= HID_HOST_MAX_DEVICES) || (!hh_cb.devices[dev_handle].in_use) ) 453 { 454 HIDH_TRACE_ERROR0("HID_ERR_INVALID_PARAM"); 455 status = HID_ERR_INVALID_PARAM; 456 } 457 458 else if( hh_cb.devices[dev_handle].state != HID_DEV_CONNECTED ) 459 { 460 HIDH_TRACE_ERROR1("HID_ERR_NO_CONNECTION dev_handle %d", dev_handle); 461 status = HID_ERR_NO_CONNECTION; 462 } 463 464 if (status != HID_SUCCESS) 465 { 466 if (pbuf) 467 GKI_freebuf ((void *)pbuf); 468 } 469 else 470 status = hidh_conn_snd_data( dev_handle, t_type, param, data, report_id, pbuf ) ; 471 472 return status; 473 } 474 475 /******************************************************************************* 476 ** 477 ** Function HID_HostCloseDev 478 ** 479 ** Description This function disconnects the device. 480 ** 481 ** Returns void 482 ** 483 *******************************************************************************/ 484 tHID_STATUS HID_HostCloseDev( UINT8 dev_handle ) 485 { 486 if( !hh_cb.reg_flag ) 487 return (HID_ERR_NOT_REGISTERED); 488 489 if( (dev_handle >= HID_HOST_MAX_DEVICES) || (!hh_cb.devices[dev_handle].in_use) ) 490 return HID_ERR_INVALID_PARAM; 491 492 hh_cb.devices[dev_handle].conn_tries = HID_HOST_MAX_CONN_RETRY+1; 493 btu_stop_timer( &(hh_cb.devices[dev_handle].conn.timer_entry) ) ; 494 495 if( hh_cb.devices[dev_handle].state != HID_DEV_CONNECTED ) 496 return HID_ERR_NO_CONNECTION; 497 498 hh_cb.devices[dev_handle].conn_tries = HID_HOST_MAX_CONN_RETRY+1; 499 return hidh_conn_disconnect( dev_handle ); 500 } 501 502 tHID_STATUS HID_HostSetSecurityLevel( char serv_name[], UINT8 sec_lvl ) 503 { 504 if (!BTM_SetSecurityLevel (FALSE, serv_name, BTM_SEC_SERVICE_HIDH_SEC_CTRL, 505 sec_lvl, HID_PSM_CONTROL, BTM_SEC_PROTO_HID, HID_SEC_CHN)) 506 { 507 HIDH_TRACE_ERROR0 ("Security Registration 1 failed"); 508 return (HID_ERR_NO_RESOURCES); 509 } 510 511 if (!BTM_SetSecurityLevel (TRUE, serv_name, BTM_SEC_SERVICE_HIDH_SEC_CTRL, 512 sec_lvl, HID_PSM_CONTROL, BTM_SEC_PROTO_HID, HID_SEC_CHN)) 513 { 514 HIDH_TRACE_ERROR0 ("Security Registration 2 failed"); 515 return (HID_ERR_NO_RESOURCES); 516 } 517 518 if (!BTM_SetSecurityLevel (FALSE, serv_name, BTM_SEC_SERVICE_HIDH_NOSEC_CTRL, 519 BTM_SEC_NONE, HID_PSM_CONTROL, BTM_SEC_PROTO_HID, HID_NOSEC_CHN)) 520 { 521 HIDH_TRACE_ERROR0 ("Security Registration 3 failed"); 522 return (HID_ERR_NO_RESOURCES); 523 } 524 525 if (!BTM_SetSecurityLevel (TRUE, serv_name, BTM_SEC_SERVICE_HIDH_NOSEC_CTRL, 526 BTM_SEC_NONE, HID_PSM_CONTROL, BTM_SEC_PROTO_HID, HID_NOSEC_CHN)) 527 { 528 HIDH_TRACE_ERROR0 ("Security Registration 4 failed"); 529 return (HID_ERR_NO_RESOURCES); 530 } 531 532 if (!BTM_SetSecurityLevel (TRUE, serv_name, BTM_SEC_SERVICE_HIDH_INTR, 533 BTM_SEC_NONE, HID_PSM_INTERRUPT, BTM_SEC_PROTO_HID, 0)) 534 { 535 HIDH_TRACE_ERROR0 ("Security Registration 5 failed"); 536 return (HID_ERR_NO_RESOURCES); 537 } 538 539 if (!BTM_SetSecurityLevel (FALSE, serv_name, BTM_SEC_SERVICE_HIDH_INTR, 540 BTM_SEC_NONE, HID_PSM_INTERRUPT, BTM_SEC_PROTO_HID, 0)) 541 { 542 HIDH_TRACE_ERROR0 ("Security Registration 6 failed"); 543 return (HID_ERR_NO_RESOURCES); 544 } 545 546 return( HID_SUCCESS ); 547 } 548 549 /****************************************************************************** 550 ** 551 ** Function hid_known_hid_device 552 ** 553 ** Description check if this device is of type HID Device 554 ** 555 ** Returns TRUE if device is HID Device else FALSE 556 ** 557 *******************************************************************************/ 558 BOOLEAN hid_known_hid_device (BD_ADDR bd_addr) 559 { 560 UINT8 i; 561 tBTM_INQ_INFO *p_inq_info = BTM_InqDbRead(bd_addr); 562 563 if ( !hh_cb.reg_flag ) 564 return FALSE; 565 566 /* First check for class of device , if Inq DB has information about this device*/ 567 if (p_inq_info != NULL) 568 { 569 /* Check if remote major device class is of type BTM_COD_MAJOR_PERIPHERAL */ 570 if ((p_inq_info->results.dev_class[1] & BTM_COD_MAJOR_CLASS_MASK) 571 == BTM_COD_MAJOR_PERIPHERAL ) 572 { 573 HIDH_TRACE_DEBUG0("hid_known_hid_device:dev found in InqDB & COD matches HID dev"); 574 return TRUE; 575 } 576 } 577 else 578 { 579 /* Look for this device in security device DB */ 580 tBTM_SEC_DEV_REC *p_dev_rec = btm_find_dev (bd_addr); 581 if ((p_dev_rec != NULL) && 582 ((p_dev_rec->dev_class[1] & BTM_COD_MAJOR_CLASS_MASK) == BTM_COD_MAJOR_PERIPHERAL )) 583 { 584 HIDH_TRACE_DEBUG0("hid_known_hid_device:dev found in SecDevDB & COD matches HID dev"); 585 return TRUE; 586 } 587 } 588 589 /* Find an entry for this device in hh_cb.devices array */ 590 for ( i=0; i<HID_HOST_MAX_DEVICES; i++) 591 { 592 if ((hh_cb.devices[i].in_use) && 593 (memcmp(bd_addr, hh_cb.devices[i].addr, BD_ADDR_LEN) == 0)) 594 return TRUE; 595 } 596 /* Check if this device is marked as HID Device in IOP Dev */ 597 HIDH_TRACE_DEBUG0("hid_known_hid_device:remote is not HID device"); 598 return FALSE; 599 } 600
