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 *******************************************************************************/
bta_hh_find_cb(BD_ADDR bda)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 *******************************************************************************/
bta_hh_clean_up_kdev(tBTA_HH_DEV_CB * p_cb)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 *******************************************************************************/
bta_hh_update_di_info(tBTA_HH_DEV_CB * p_cb,UINT16 vendor_id,UINT16 product_id,UINT16 version,UINT8 flag)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 *******************************************************************************/
bta_hh_add_device_to_list(tBTA_HH_DEV_CB * p_cb,UINT8 handle,UINT16 attr_mask,tHID_DEV_DSCP_INFO * p_dscp_info,UINT8 sub_class,UINT16 ssr_max_latency,UINT16 ssr_min_tout,UINT8 app_id)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 *******************************************************************************/
bta_hh_tod_spt(tBTA_HH_DEV_CB * p_cb,UINT8 sub_class)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 *******************************************************************************/
bta_hh_parse_keybd_rpt(tBTA_HH_BOOT_RPT * p_kb_data,UINT8 * p_report,UINT16 report_len)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 *******************************************************************************/
bta_hh_parse_mice_rpt(tBTA_HH_BOOT_RPT * p_mice_data,UINT8 * p_report,UINT16 report_len)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 *******************************************************************************/
bta_hh_read_ssr_param(BD_ADDR bd_addr,UINT16 * p_max_ssr_lat,UINT16 * p_min_ssr_tout)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 *******************************************************************************/
bta_hh_cleanup_disable(tBTA_HH_STATUS status)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 *******************************************************************************/
bta_hh_dev_handle_to_cb_idx(UINT8 dev_handle)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 *******************************************************************************/
bta_hh_trace_dev_db(void)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