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 *******************************************************************************/
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     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 *******************************************************************************/
HID_HostSetTraceLevel(UINT8 new_level)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 *******************************************************************************/
HID_HostRegister(tHID_HOST_DEV_CALLBACK * dev_cback)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 *******************************************************************************/
HID_HostDeregister(void)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 *******************************************************************************/
HID_HostAddDev(BD_ADDR addr,UINT16 attr_mask,UINT8 * handle)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 *******************************************************************************/
HID_HostRemoveDev(UINT8 dev_handle)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 *******************************************************************************/
HID_HostOpenDev(UINT8 dev_handle)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 *******************************************************************************/
HID_HostWriteDev(UINT8 dev_handle,UINT8 t_type,UINT8 param,UINT16 data,UINT8 report_id,BT_HDR * pbuf)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         osi_free(pbuf);
471     else
472         status = hidh_conn_snd_data(dev_handle, t_type, param, data, report_id, pbuf);
473 
474     return status;
475 }
476 
477 /*******************************************************************************
478 **
479 ** Function         HID_HostCloseDev
480 **
481 ** Description      This function disconnects the device.
482 **
483 ** Returns          void
484 **
485 *******************************************************************************/
HID_HostCloseDev(UINT8 dev_handle)486 tHID_STATUS HID_HostCloseDev( UINT8 dev_handle )
487 {
488     if( !hh_cb.reg_flag )
489         return (HID_ERR_NOT_REGISTERED);
490 
491     if( (dev_handle >= HID_HOST_MAX_DEVICES) || (!hh_cb.devices[dev_handle].in_use) )
492         return HID_ERR_INVALID_PARAM;
493 
494     if( hh_cb.devices[dev_handle].state != HID_DEV_CONNECTED )
495         return HID_ERR_NO_CONNECTION;
496 
497     alarm_cancel(hh_cb.devices[dev_handle].conn.process_repage_timer);
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