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 *******************************************************************************/
HID_HostGetSDPRecord(BD_ADDR addr,tSDP_DISCOVERY_DB * p_db,UINT32 db_len,tHID_HOST_SDP_CALLBACK * sdp_cback)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 
hidh_get_str_attr(tSDP_DISC_REC * p_rec,UINT16 attr_id,UINT16 max_len,char * str)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 
hidh_search_callback(UINT16 sdp_result)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 *******************************************************************************/
HID_HostInit(void)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 *******************************************************************************/
HID_HostSetTraceLevel(UINT8 new_level)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 *******************************************************************************/
HID_HostRegister(tHID_HOST_DEV_CALLBACK * dev_cback)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 *******************************************************************************/
HID_HostDeregister(void)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 *******************************************************************************/
HID_HostAddDev(BD_ADDR addr,UINT16 attr_mask,UINT8 * handle)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 *******************************************************************************/
HID_HostRemoveDev(UINT8 dev_handle)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     hh_cb.devices[dev_handle].attr_mask = 0;
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 *******************************************************************************/
HID_HostOpenDev(UINT8 dev_handle)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 *******************************************************************************/
HID_HostWriteDev(UINT8 dev_handle,UINT8 t_type,UINT8 param,UINT16 data,UINT8 report_id,BT_HDR * pbuf)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_ERROR("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_ERROR("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_ERROR("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 *******************************************************************************/
HID_HostCloseDev(UINT8 dev_handle)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 
HID_HostSetSecurityLevel(char serv_name[],UINT8 sec_lvl)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_ERROR ("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_ERROR ("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_ERROR ("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_ERROR ("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_ERROR ("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_ERROR ("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 *******************************************************************************/
hid_known_hid_device(BD_ADDR bd_addr)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_DEBUG("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_DEBUG("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_DEBUG("hid_known_hid_device:remote is not HID device");
598     return FALSE;
599 }
600