1 /******************************************************************************
2 *
3 * Copyright 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
19 /******************************************************************************
20 *
21 * This file contains the HID HOST API in the subsystem of BTA.
22 *
23 ******************************************************************************/
24
25 #define LOG_TAG "bt_bta_hh"
26
27 #include "bta_hh_api.h"
28
29 #include "bt_target.h"
30
31 #if (BTA_HH_INCLUDED == TRUE)
32
33 #include <stdio.h>
34 #include <stdlib.h>
35 #include <string.h>
36
37 #include "bta_hh_int.h"
38 #include "l2c_api.h"
39 #include "osi/include/log.h"
40 #include "osi/include/osi.h"
41 #include "utl.h"
42
43 /*****************************************************************************
44 * Constants
45 ****************************************************************************/
46
47 static const tBTA_SYS_REG bta_hh_reg = {bta_hh_hdl_event, BTA_HhDisable};
48
49 /*******************************************************************************
50 *
51 * Function BTA_HhEnable
52 *
53 * Description Enable the HID host. This function must be called before
54 * any other functions in the HID host API are called. When the
55 * enable operation is complete the callback function will be
56 * called with BTA_HH_ENABLE_EVT.
57 *
58 *
59 * Returns void
60 *
61 ******************************************************************************/
BTA_HhEnable(tBTA_SEC sec_mask,tBTA_HH_CBACK * p_cback)62 void BTA_HhEnable(tBTA_SEC sec_mask, tBTA_HH_CBACK* p_cback) {
63 tBTA_HH_API_ENABLE* p_buf =
64 (tBTA_HH_API_ENABLE*)osi_calloc(sizeof(tBTA_HH_API_ENABLE));
65
66 LOG_INFO(LOG_TAG, "%s sec_mask:0x%x p_cback:%p", __func__, sec_mask, p_cback);
67
68 /* register with BTA system manager */
69 bta_sys_register(BTA_ID_HH, &bta_hh_reg);
70
71 p_buf->hdr.event = BTA_HH_API_ENABLE_EVT;
72 p_buf->p_cback = p_cback;
73 p_buf->sec_mask = sec_mask;
74
75 bta_sys_sendmsg(p_buf);
76 }
77
78 /*******************************************************************************
79 *
80 * Function BTA_HhDisable
81 *
82 * Description Disable the HID host. If the server is currently
83 * connected, the connection will be closed.
84 *
85 * Returns void
86 *
87 ******************************************************************************/
BTA_HhDisable(void)88 void BTA_HhDisable(void) {
89 BT_HDR* p_buf = (BT_HDR*)osi_malloc(sizeof(BT_HDR));
90
91 bta_sys_deregister(BTA_ID_HH);
92 p_buf->event = BTA_HH_API_DISABLE_EVT;
93
94 bta_sys_sendmsg(p_buf);
95 }
96
97 /*******************************************************************************
98 *
99 * Function BTA_HhClose
100 *
101 * Description Disconnect a connection.
102 *
103 * Returns void
104 *
105 ******************************************************************************/
BTA_HhClose(uint8_t dev_handle)106 void BTA_HhClose(uint8_t dev_handle) {
107 BT_HDR* p_buf = (BT_HDR*)osi_calloc(sizeof(BT_HDR));
108
109 p_buf->event = BTA_HH_API_CLOSE_EVT;
110 p_buf->layer_specific = (uint16_t)dev_handle;
111
112 bta_sys_sendmsg(p_buf);
113 }
114
115 /*******************************************************************************
116 *
117 * Function BTA_HhOpen
118 *
119 * Description Connect to a device of specified BD address in specified
120 * protocol mode and security level.
121 *
122 * Returns void
123 *
124 ******************************************************************************/
BTA_HhOpen(const RawAddress & dev_bda,tBTA_HH_PROTO_MODE mode,tBTA_SEC sec_mask)125 void BTA_HhOpen(const RawAddress& dev_bda, tBTA_HH_PROTO_MODE mode,
126 tBTA_SEC sec_mask) {
127 tBTA_HH_API_CONN* p_buf =
128 (tBTA_HH_API_CONN*)osi_calloc(sizeof(tBTA_HH_API_CONN));
129
130 p_buf->hdr.event = BTA_HH_API_OPEN_EVT;
131 p_buf->hdr.layer_specific = BTA_HH_INVALID_HANDLE;
132 p_buf->sec_mask = sec_mask;
133 p_buf->mode = mode;
134 p_buf->bd_addr = dev_bda;
135
136 bta_sys_sendmsg((void*)p_buf);
137 }
138
139 /*******************************************************************************
140 *
141 * Function bta_hh_snd_write_dev
142 *
143 ******************************************************************************/
bta_hh_snd_write_dev(uint8_t dev_handle,uint8_t t_type,uint8_t param,uint16_t data,uint8_t rpt_id,BT_HDR * p_data)144 static void bta_hh_snd_write_dev(uint8_t dev_handle, uint8_t t_type,
145 uint8_t param, uint16_t data, uint8_t rpt_id,
146 BT_HDR* p_data) {
147 tBTA_HH_CMD_DATA* p_buf =
148 (tBTA_HH_CMD_DATA*)osi_calloc(sizeof(tBTA_HH_CMD_DATA));
149
150 p_buf->hdr.event = BTA_HH_API_WRITE_DEV_EVT;
151 p_buf->hdr.layer_specific = (uint16_t)dev_handle;
152 p_buf->t_type = t_type;
153 p_buf->data = data;
154 p_buf->param = param;
155 p_buf->p_data = p_data;
156 p_buf->rpt_id = rpt_id;
157
158 bta_sys_sendmsg(p_buf);
159 }
160
161 /*******************************************************************************
162 *
163 * Function BTA_HhSetReport
164 *
165 * Description send SET_REPORT to device.
166 *
167 * Parameter dev_handle: device handle
168 * r_type: report type, could be BTA_HH_RPTT_OUTPUT or
169 * BTA_HH_RPTT_FEATURE.
170 * Returns void
171 *
172 ******************************************************************************/
BTA_HhSetReport(uint8_t dev_handle,tBTA_HH_RPT_TYPE r_type,BT_HDR * p_data)173 void BTA_HhSetReport(uint8_t dev_handle, tBTA_HH_RPT_TYPE r_type,
174 BT_HDR* p_data) {
175 /* send feature report on control channel */
176 if (r_type == BTA_HH_RPTT_FEATURE)
177 bta_hh_snd_write_dev(dev_handle, HID_TRANS_SET_REPORT, r_type, 0, 0,
178 p_data);
179 /* send output data report on interrupt channel */
180 else
181 bta_hh_snd_write_dev(dev_handle, HID_TRANS_DATA, r_type, 0, 0, p_data);
182 }
183 /*******************************************************************************
184 *
185 * Function BTA_HhGetReport
186 *
187 * Description Send a GET_REPORT to HID device.
188 *
189 * Returns void
190 *
191 ******************************************************************************/
BTA_HhGetReport(uint8_t dev_handle,tBTA_HH_RPT_TYPE r_type,uint8_t rpt_id,uint16_t buf_size)192 void BTA_HhGetReport(uint8_t dev_handle, tBTA_HH_RPT_TYPE r_type,
193 uint8_t rpt_id, uint16_t buf_size) {
194 uint8_t param = (buf_size) ? (r_type | 0x08) : r_type;
195
196 bta_hh_snd_write_dev(dev_handle, HID_TRANS_GET_REPORT, param, buf_size,
197 rpt_id, NULL);
198 }
199 /*******************************************************************************
200 *
201 * Function BTA_HhSetProtoMode
202 *
203 * Description This function set the protocol mode at specified HID handle
204 *
205 * Returns void
206 *
207 ******************************************************************************/
BTA_HhSetProtoMode(uint8_t dev_handle,tBTA_HH_PROTO_MODE p_type)208 void BTA_HhSetProtoMode(uint8_t dev_handle, tBTA_HH_PROTO_MODE p_type) {
209 bta_hh_snd_write_dev(dev_handle, HID_TRANS_SET_PROTOCOL, (uint8_t)p_type, 0,
210 0, NULL);
211 }
212 /*******************************************************************************
213 *
214 * Function BTA_HhGetProtoMode
215 *
216 * Description This function get protocol mode information.
217 *
218 * Returns void
219 *
220 ******************************************************************************/
BTA_HhGetProtoMode(uint8_t dev_handle)221 void BTA_HhGetProtoMode(uint8_t dev_handle) {
222 bta_hh_snd_write_dev(dev_handle, HID_TRANS_GET_PROTOCOL, 0, 0, 0, NULL);
223 }
224 /*******************************************************************************
225 *
226 * Function BTA_HhSetIdle
227 *
228 * Description send SET_IDLE to device.
229 *
230 * Returns void
231 *
232 ******************************************************************************/
BTA_HhSetIdle(uint8_t dev_handle,uint16_t idle_rate)233 void BTA_HhSetIdle(uint8_t dev_handle, uint16_t idle_rate) {
234 bta_hh_snd_write_dev(dev_handle, HID_TRANS_SET_IDLE, 0, idle_rate, 0, NULL);
235 }
236
237 /*******************************************************************************
238 *
239 * Function BTA_HhGetIdle
240 *
241 * Description Send a GET_IDLE from HID device.
242 *
243 * Returns void
244 *
245 ******************************************************************************/
BTA_HhGetIdle(uint8_t dev_handle)246 void BTA_HhGetIdle(uint8_t dev_handle) {
247 bta_hh_snd_write_dev(dev_handle, HID_TRANS_GET_IDLE, 0, 0, 0, NULL);
248 }
249 /*******************************************************************************
250 *
251 * Function BTA_HhSendCtrl
252 *
253 * Description Send a control command to HID device.
254 *
255 * Returns void
256 *
257 ******************************************************************************/
BTA_HhSendCtrl(uint8_t dev_handle,tBTA_HH_TRANS_CTRL_TYPE c_type)258 void BTA_HhSendCtrl(uint8_t dev_handle, tBTA_HH_TRANS_CTRL_TYPE c_type) {
259 bta_hh_snd_write_dev(dev_handle, HID_TRANS_CONTROL, (uint8_t)c_type, 0, 0,
260 NULL);
261 }
262 /*******************************************************************************
263 *
264 * Function BTA_HhSendData
265 *
266 * Description This function send DATA transaction to HID device.
267 *
268 * Parameter dev_handle: device handle
269 * dev_bda: remote device address
270 * p_data: data to be sent in the DATA transaction; or
271 * the data to be write into the Output Report of a LE
272 * HID device. The report is identified the report ID
273 * which is the value of the byte
274 * (uint8_t *)(p_buf + 1) + *p_buf->offset.
275 * p_data->layer_specific needs to be set to the report
276 * type. It can be OUTPUT report, or FEATURE report.
277 *
278 * Returns void
279 *
280 ******************************************************************************/
BTA_HhSendData(uint8_t dev_handle,UNUSED_ATTR const RawAddress & dev_bda,BT_HDR * p_data)281 void BTA_HhSendData(uint8_t dev_handle, UNUSED_ATTR const RawAddress& dev_bda,
282 BT_HDR* p_data) {
283 #if (BTA_HH_LE_INCLUDED == TRUE)
284 if (p_data->layer_specific != BTA_HH_RPTT_OUTPUT) {
285 APPL_TRACE_ERROR(
286 "ERROR! Wrong report type! Write Command only valid for output "
287 "report!");
288 return;
289 }
290 #endif
291 bta_hh_snd_write_dev(dev_handle, HID_TRANS_DATA,
292 (uint8_t)p_data->layer_specific, 0, 0, p_data);
293 }
294
295 /*******************************************************************************
296 *
297 * Function BTA_HhGetDscpInfo
298 *
299 * Description Get HID device report descriptor
300 *
301 * Returns void
302 *
303 ******************************************************************************/
BTA_HhGetDscpInfo(uint8_t dev_handle)304 void BTA_HhGetDscpInfo(uint8_t dev_handle) {
305 BT_HDR* p_buf = (BT_HDR*)osi_calloc(sizeof(BT_HDR));
306
307 p_buf->event = BTA_HH_API_GET_DSCP_EVT;
308 p_buf->layer_specific = (uint16_t)dev_handle;
309
310 bta_sys_sendmsg(p_buf);
311 }
312
313 /*******************************************************************************
314 *
315 * Function BTA_HhAddDev
316 *
317 * Description Add a virtually cabled device into HID-Host device list
318 * to manage and assign a device handle for future API call,
319 * host applciation call this API at start-up to initialize its
320 * virtually cabled devices.
321 *
322 * Returns void
323 *
324 ******************************************************************************/
BTA_HhAddDev(const RawAddress & bda,tBTA_HH_ATTR_MASK attr_mask,uint8_t sub_class,uint8_t app_id,tBTA_HH_DEV_DSCP_INFO dscp_info)325 void BTA_HhAddDev(const RawAddress& bda, tBTA_HH_ATTR_MASK attr_mask,
326 uint8_t sub_class, uint8_t app_id,
327 tBTA_HH_DEV_DSCP_INFO dscp_info) {
328 size_t len = sizeof(tBTA_HH_MAINT_DEV) + dscp_info.descriptor.dl_len;
329 tBTA_HH_MAINT_DEV* p_buf = (tBTA_HH_MAINT_DEV*)osi_calloc(len);
330
331 p_buf->hdr.event = BTA_HH_API_MAINT_DEV_EVT;
332 p_buf->sub_event = BTA_HH_ADD_DEV_EVT;
333 p_buf->hdr.layer_specific = BTA_HH_INVALID_HANDLE;
334
335 p_buf->attr_mask = (uint16_t)attr_mask;
336 p_buf->sub_class = sub_class;
337 p_buf->app_id = app_id;
338 p_buf->bda = bda;
339
340 memcpy(&p_buf->dscp_info, &dscp_info, sizeof(tBTA_HH_DEV_DSCP_INFO));
341 if (dscp_info.descriptor.dl_len != 0 && dscp_info.descriptor.dsc_list) {
342 p_buf->dscp_info.descriptor.dl_len = dscp_info.descriptor.dl_len;
343 p_buf->dscp_info.descriptor.dsc_list = (uint8_t*)(p_buf + 1);
344 memcpy(p_buf->dscp_info.descriptor.dsc_list, dscp_info.descriptor.dsc_list,
345 dscp_info.descriptor.dl_len);
346 } else {
347 p_buf->dscp_info.descriptor.dsc_list = NULL;
348 p_buf->dscp_info.descriptor.dl_len = 0;
349 }
350
351 bta_sys_sendmsg(p_buf);
352 }
353
354 /*******************************************************************************
355 *
356 * Function BTA_HhRemoveDev
357 *
358 * Description Remove a device from the HID host devices list.
359 *
360 * Returns void
361 *
362 ******************************************************************************/
BTA_HhRemoveDev(uint8_t dev_handle)363 void BTA_HhRemoveDev(uint8_t dev_handle) {
364 tBTA_HH_MAINT_DEV* p_buf =
365 (tBTA_HH_MAINT_DEV*)osi_calloc(sizeof(tBTA_HH_MAINT_DEV));
366
367 p_buf->hdr.event = BTA_HH_API_MAINT_DEV_EVT;
368 p_buf->sub_event = BTA_HH_RMV_DEV_EVT;
369 p_buf->hdr.layer_specific = (uint16_t)dev_handle;
370
371 bta_sys_sendmsg(p_buf);
372 }
373
374 /******************************************************************************/
375 /* Utility Function */
376 /******************************************************************************/
377
378 /*******************************************************************************
379 *
380 * Function BTA_HhParseBootRpt
381 *
382 * Description This utility function parse a boot mode report.
383 * For keyboard report, report data will carry the keycode max
384 * up to 6 key press in one report. Application need to convert
385 * the keycode into keypress character according to keyboard
386 * language.
387 *
388 * Returns void
389 *
390 ******************************************************************************/
BTA_HhParseBootRpt(tBTA_HH_BOOT_RPT * p_data,uint8_t * p_report,uint16_t report_len)391 void BTA_HhParseBootRpt(tBTA_HH_BOOT_RPT* p_data, uint8_t* p_report,
392 uint16_t report_len) {
393 p_data->dev_type = BTA_HH_DEVT_UNKNOWN;
394
395 if (p_report) {
396 /* first byte is report ID */
397 switch (p_report[0]) {
398 case BTA_HH_KEYBD_RPT_ID: /* key board report ID */
399 p_data->dev_type = p_report[0];
400 bta_hh_parse_keybd_rpt(p_data, p_report + 1,
401 (uint16_t)(report_len - 1));
402 break;
403
404 case BTA_HH_MOUSE_RPT_ID: /* mouse report ID */
405 p_data->dev_type = p_report[0];
406 bta_hh_parse_mice_rpt(p_data, p_report + 1, (uint16_t)(report_len - 1));
407 break;
408
409 default:
410 APPL_TRACE_DEBUG("Unknown boot report: %d", p_report[0]);
411 ;
412 break;
413 }
414 }
415
416 return;
417 }
418
419 #endif /* BTA_HH_INCLUDED */
420