stack/hid/hidh_api.c

   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 "bt_common.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     for (size_t i = 0; i < HID_HOST_MAX_DEVICES; i++) {
 245         hh_cb.devices[i].conn.process_repage_timer =
 246           alarm_new("hid_devices_conn.process_repage_timer");
 247     }
 248
 249 #if defined(HID_INITIAL_TRACE_LEVEL)
 250     hh_cb.trace_level = HID_INITIAL_TRACE_LEVEL;
 251 #else
 252     hh_cb.trace_level = BT_TRACE_LEVEL_NONE;
 253 #endif
 254 }
 255
 256 /*******************************************************************************
 257 **
 258 ** Function         HID_HostSetTraceLevel
 259 **
 260 ** Description      This function sets the trace level for HID Host. If called with
 261 **                  a value of 0xFF, it simply reads the current trace level.
 262 **
 263 ** Returns          the new (current) trace level
 264 **
 265 *******************************************************************************/
 266 UINT8 HID_HostSetTraceLevel (UINT8 new_level)
 267 {
 268     if (new_level != 0xFF)
 269         hh_cb.trace_level = new_level;
 270
 271     return (hh_cb.trace_level);
 272 }
 273
 274 /*******************************************************************************
 275 **
 276 ** Function         HID_HostRegister
 277 **
 278 ** Description      This function registers HID-Host with lower layers
 279 **
 280 ** Returns          tHID_STATUS
 281 **
 282 *******************************************************************************/
 283 tHID_STATUS HID_HostRegister (tHID_HOST_DEV_CALLBACK *dev_cback)
 284 {
 285     tHID_STATUS st;
 286
 287     if( hh_cb.reg_flag )
 288         return HID_ERR_ALREADY_REGISTERED;
 289
 290     if( dev_cback == NULL )
 291         return HID_ERR_INVALID_PARAM;
 292
 293     /* Register with L2CAP */
 294     if( (st = hidh_conn_reg()) != HID_SUCCESS )
 295     {
 296         return st;
 297     }
 298
 299     hh_cb.callback = dev_cback ;
 300     hh_cb.reg_flag = TRUE;
 301
 302     return (HID_SUCCESS);
 303 }
 304
 305 /*******************************************************************************
 306 **
 307 ** Function         HID_HostDeregister
 308 **
 309 ** Description      This function is called when the host is about power down.
 310 **
 311 ** Returns          tHID_STATUS
 312 **
 313 *******************************************************************************/
 314 tHID_STATUS HID_HostDeregister(void)
 315 {
 316     UINT8 i;
 317
 318     if( !hh_cb.reg_flag )
 319         return (HID_ERR_NOT_REGISTERED);
 320
 321     for( i=0; i<HID_HOST_MAX_DEVICES; i++ )
 322     {
 323         HID_HostRemoveDev( i ) ;
 324     }
 325
 326     hidh_conn_dereg();
 327     hh_cb.reg_flag = FALSE;
 328
 329     return (HID_SUCCESS) ;
 330 }
 331
 332 /*******************************************************************************
 333 **
 334 ** Function         HID_HostAddDev
 335 **
 336 ** Description      This is called so HID-host may manage this device.
 337 **
 338 ** Returns          tHID_STATUS
 339 **
 340 *******************************************************************************/
 341 tHID_STATUS HID_HostAddDev ( BD_ADDR addr, UINT16 attr_mask, UINT8 *handle )
 342 {
 343     int i;
 344     /* Find an entry for this device in hh_cb.devices array */
 345     if( !hh_cb.reg_flag )
 346         return (HID_ERR_NOT_REGISTERED);
 347
 348     for( i=0; i<HID_HOST_MAX_DEVICES; i++)
 349     {
 350         if((hh_cb.devices[i].in_use) &&
 351            (!memcmp(addr, hh_cb.devices[i].addr, BD_ADDR_LEN)))
 352             break;
 353     }
 354
 355     if (i== HID_HOST_MAX_DEVICES )
 356     {
 357         for( i=0; i<HID_HOST_MAX_DEVICES; i++)
 358         {
 359             if( !hh_cb.devices[i].in_use)
 360                 break;
 361         }
 362     }
 363
 364     if( i==HID_HOST_MAX_DEVICES )
 365         return HID_ERR_NO_RESOURCES;
 366
 367     if (!hh_cb.devices[i].in_use)
 368     {
 369         hh_cb.devices[i].in_use = TRUE;
 370         memcpy( hh_cb.devices[i].addr, addr, sizeof( BD_ADDR ) ) ;
 371         hh_cb.devices[i].state = HID_DEV_NO_CONN;
 372         hh_cb.devices[i].conn_tries = 0 ;
 373     }
 374
 375     if (attr_mask != HID_ATTR_MASK_IGNORE)
 376         hh_cb.devices[i].attr_mask = attr_mask;
 377
 378     *handle = i;
 379
 380     return (HID_SUCCESS);
 381 }
 382
 383
 384 /*******************************************************************************
 385 **
 386 ** Function         HID_HostRemoveDev
 387 **
 388 ** Description      This removes the device from list devices that host has to manage.
 389 **
 390 ** Returns          tHID_STATUS
 391 **
 392 *******************************************************************************/
 393 tHID_STATUS HID_HostRemoveDev ( UINT8 dev_handle )
 394 {
 395     if( !hh_cb.reg_flag )
 396         return (HID_ERR_NOT_REGISTERED);
 397
 398     if( (dev_handle >= HID_HOST_MAX_DEVICES) || (!hh_cb.devices[dev_handle].in_use) )
 399         return HID_ERR_INVALID_PARAM;
 400
 401     HID_HostCloseDev( dev_handle ) ;
 402     hh_cb.devices[dev_handle].in_use = FALSE;
 403     hh_cb.devices[dev_handle].conn.conn_state = HID_CONN_STATE_UNUSED;
 404     hh_cb.devices[dev_handle].conn.ctrl_cid = hh_cb.devices[dev_handle].conn.intr_cid = 0;
 405     hh_cb.devices[dev_handle].attr_mask = 0;
 406     return HID_SUCCESS;
 407 }
 408
 409 /*******************************************************************************
 410 **
 411 ** Function         HID_HostOpenDev
 412 **
 413 ** Description      This function is called when the user wants to initiate a
 414 **                  connection attempt to a device.
 415 **
 416 ** Returns          void
 417 **
 418 *******************************************************************************/
 419 tHID_STATUS HID_HostOpenDev ( UINT8 dev_handle )
 420 {
 421     if( !hh_cb.reg_flag )
 422         return (HID_ERR_NOT_REGISTERED);
 423
 424     if( (dev_handle >= HID_HOST_MAX_DEVICES) || (!hh_cb.devices[dev_handle].in_use) )
 425         return HID_ERR_INVALID_PARAM;
 426
 427     if( hh_cb.devices[dev_handle].state != HID_DEV_NO_CONN )
 428         return HID_ERR_ALREADY_CONN;
 429
 430     hh_cb.devices[dev_handle].conn_tries = 1;
 431     return hidh_conn_initiate( dev_handle );
 432 }
 433
 434 /*******************************************************************************
 435 **
 436 ** Function         HID_HostWriteDev
 437 **
 438 ** Description      This function is called when the host has a report to send.
 439 **
 440 **                  report_id: is only used on GET_REPORT transaction if is specified.
 441 **                              only valid when it's a non-zero value.
 442 **
 443 ** Returns          void
 444 **
 445 *******************************************************************************/
 446 tHID_STATUS HID_HostWriteDev( UINT8 dev_handle, UINT8 t_type,
 447                               UINT8 param, UINT16 data, UINT8 report_id, BT_HDR *pbuf  )
 448 {
 449     tHID_STATUS status = HID_SUCCESS;
 450
 451     if( !hh_cb.reg_flag )
 452     {
 453         HIDH_TRACE_ERROR("HID_ERR_NOT_REGISTERED");
 454         status = HID_ERR_NOT_REGISTERED;
 455     }
 456
 457     if( (dev_handle >= HID_HOST_MAX_DEVICES) || (!hh_cb.devices[dev_handle].in_use) )
 458     {
 459         HIDH_TRACE_ERROR("HID_ERR_INVALID_PARAM");
 460         status = HID_ERR_INVALID_PARAM;
 461     }
 462
 463     else if( hh_cb.devices[dev_handle].state != HID_DEV_CONNECTED )
 464     {
 465         HIDH_TRACE_ERROR("HID_ERR_NO_CONNECTION dev_handle %d", dev_handle);
 466         status = HID_ERR_NO_CONNECTION;
 467     }
 468
 469     if (status != HID_SUCCESS)
 470     {
 471         if (pbuf)
 472             osi_freebuf ((void *)pbuf);
 473     }
 474     else
 475         status = hidh_conn_snd_data( dev_handle, t_type, param, data, report_id, pbuf ) ;
 476
 477     return status;
 478 }
 479
 480 /*******************************************************************************
 481 **
 482 ** Function         HID_HostCloseDev
 483 **
 484 ** Description      This function disconnects the device.
 485 **
 486 ** Returns          void
 487 **
 488 *******************************************************************************/
 489 tHID_STATUS HID_HostCloseDev( UINT8 dev_handle )
 490 {
 491     if( !hh_cb.reg_flag )
 492         return (HID_ERR_NOT_REGISTERED);
 493
 494     if( (dev_handle >= HID_HOST_MAX_DEVICES) || (!hh_cb.devices[dev_handle].in_use) )
 495         return HID_ERR_INVALID_PARAM;
 496
 497     hh_cb.devices[dev_handle].conn_tries = HID_HOST_MAX_CONN_RETRY+1;
 498     alarm_cancel(hh_cb.devices[dev_handle].conn.process_repage_timer);
 499
 500     if( hh_cb.devices[dev_handle].state != HID_DEV_CONNECTED )
 501         return HID_ERR_NO_CONNECTION;
 502
 503     hh_cb.devices[dev_handle].conn_tries = HID_HOST_MAX_CONN_RETRY+1;
 504     return hidh_conn_disconnect( dev_handle );
 505 }
 506
 507 tHID_STATUS HID_HostSetSecurityLevel( char serv_name[], UINT8 sec_lvl )
 508 {
 509     if (!BTM_SetSecurityLevel (FALSE, serv_name, BTM_SEC_SERVICE_HIDH_SEC_CTRL,
 510                                sec_lvl, HID_PSM_CONTROL, BTM_SEC_PROTO_HID, HID_SEC_CHN))
 511     {
 512         HIDH_TRACE_ERROR ("Security Registration 1 failed");
 513         return (HID_ERR_NO_RESOURCES);
 514     }
 515
 516     if (!BTM_SetSecurityLevel (TRUE, serv_name, BTM_SEC_SERVICE_HIDH_SEC_CTRL,
 517                                sec_lvl, HID_PSM_CONTROL, BTM_SEC_PROTO_HID, HID_SEC_CHN))
 518     {
 519         HIDH_TRACE_ERROR ("Security Registration 2 failed");
 520         return (HID_ERR_NO_RESOURCES);
 521     }
 522
 523     if (!BTM_SetSecurityLevel (FALSE, serv_name, BTM_SEC_SERVICE_HIDH_NOSEC_CTRL,
 524                                BTM_SEC_NONE, HID_PSM_CONTROL, BTM_SEC_PROTO_HID, HID_NOSEC_CHN))
 525     {
 526         HIDH_TRACE_ERROR ("Security Registration 3 failed");
 527         return (HID_ERR_NO_RESOURCES);
 528     }
 529
 530     if (!BTM_SetSecurityLevel (TRUE, serv_name, BTM_SEC_SERVICE_HIDH_NOSEC_CTRL,
 531                                BTM_SEC_NONE, HID_PSM_CONTROL, BTM_SEC_PROTO_HID, HID_NOSEC_CHN))
 532     {
 533         HIDH_TRACE_ERROR ("Security Registration 4 failed");
 534         return (HID_ERR_NO_RESOURCES);
 535     }
 536
 537     if (!BTM_SetSecurityLevel (TRUE, serv_name, BTM_SEC_SERVICE_HIDH_INTR,
 538                                BTM_SEC_NONE, HID_PSM_INTERRUPT, BTM_SEC_PROTO_HID, 0))
 539     {
 540         HIDH_TRACE_ERROR ("Security Registration 5 failed");
 541         return (HID_ERR_NO_RESOURCES);
 542     }
 543
 544     if (!BTM_SetSecurityLevel (FALSE, serv_name, BTM_SEC_SERVICE_HIDH_INTR,
 545                                BTM_SEC_NONE, HID_PSM_INTERRUPT, BTM_SEC_PROTO_HID, 0))
 546     {
 547         HIDH_TRACE_ERROR ("Security Registration 6 failed");
 548         return (HID_ERR_NO_RESOURCES);
 549     }
 550
 551     return( HID_SUCCESS );
 552 }
 553
 554 /******************************************************************************
 555 **
 556 ** Function         hid_known_hid_device
 557 **
 558 ** Description      check if this device is  of type HID Device
 559 **
 560 ** Returns          TRUE if device is HID Device else FALSE
 561 **
 562 *******************************************************************************/
 563 BOOLEAN hid_known_hid_device (BD_ADDR bd_addr)
 564 {
 565     UINT8 i;
 566     tBTM_INQ_INFO *p_inq_info = BTM_InqDbRead(bd_addr);
 567
 568      if ( !hh_cb.reg_flag )
 569         return FALSE;
 570
 571     /* First  check for class of device , if Inq DB has information about this device*/
 572     if (p_inq_info != NULL)
 573     {
 574         /* Check if remote major device class is of type BTM_COD_MAJOR_PERIPHERAL */
 575         if ((p_inq_info->results.dev_class[1] & BTM_COD_MAJOR_CLASS_MASK)
 576             == BTM_COD_MAJOR_PERIPHERAL )
 577         {
 578             HIDH_TRACE_DEBUG("hid_known_hid_device:dev found in InqDB & COD matches HID dev");
 579             return TRUE;
 580         }
 581     }
 582     else
 583     {
 584         /* Look for this device in security device DB */
 585         tBTM_SEC_DEV_REC  *p_dev_rec = btm_find_dev (bd_addr);
 586         if ((p_dev_rec != NULL) &&
 587             ((p_dev_rec->dev_class[1] & BTM_COD_MAJOR_CLASS_MASK) == BTM_COD_MAJOR_PERIPHERAL ))
 588         {
 589             HIDH_TRACE_DEBUG("hid_known_hid_device:dev found in SecDevDB & COD matches HID dev");
 590             return TRUE;
 591         }
 592     }
 593
 594     /* Find an entry for this device in hh_cb.devices array */
 595      for ( i=0; i<HID_HOST_MAX_DEVICES; i++)
 596      {
 597          if ((hh_cb.devices[i].in_use) &&
 598             (memcmp(bd_addr, hh_cb.devices[i].addr, BD_ADDR_LEN) == 0))
 599              return TRUE;
 600      }
 601     /* Check if this device is marked as HID Device in IOP Dev */
 602     HIDH_TRACE_DEBUG("hid_known_hid_device:remote is not HID device");
 603     return FALSE;
 604 }