1 /*
2 * Copyright (C) 2014 BlueKitchen GmbH
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 *
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. Neither the name of the copyright holders nor the names of
14 * contributors may be used to endorse or promote products derived
15 * from this software without specific prior written permission.
16 * 4. Any redistribution, use, or modification is done solely for
17 * personal benefit and not for any commercial purpose or for
18 * monetary gain.
19 *
20 * THIS SOFTWARE IS PROVIDED BY BLUEKITCHEN GMBH AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
23 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL BLUEKITCHEN
24 * GMBH OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
25 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
26 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
27 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
28 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
29 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
30 * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * SUCH DAMAGE.
32 *
33 * Please inquire about commercial licensing options at
34 * [email protected]
35 *
36 */
37
38 #define BTSTACK_FILE__ "hid_device.c"
39
40 #include <string.h>
41
42 #include "bluetooth.h"
43 #include "bluetooth_psm.h"
44 #include "bluetooth_sdp.h"
45 #include "btstack_debug.h"
46 #include "btstack_event.h"
47 #include "btstack_hid_parser.h"
48 #include "classic/hid_device.h"
49 #include "classic/sdp_util.h"
50 #include "l2cap.h"
51
52 // prototypes
53 static int dummy_write_report(uint16_t hid_cid, hid_report_type_t report_type, uint16_t report_id, int * out_report_size, uint8_t * out_report);
54 static void dummy_set_report(uint16_t hid_cid, hid_report_type_t report_type, int report_size, uint8_t * report);
55 static void dummy_report_data(uint16_t hid_cid, hid_report_type_t report_type, uint16_t report_id, int report_size, uint8_t * report);
56
57 typedef enum {
58 HID_DEVICE_IDLE,
59 HID_DEVICE_CONNECTED,
60 HID_DEVICE_W2_GET_REPORT,
61 HID_DEVICE_W2_SET_REPORT,
62 HID_DEVICE_W2_GET_PROTOCOL,
63 HID_DEVICE_W2_SET_PROTOCOL,
64 HID_DEVICE_W2_ANSWER_SET_PROTOCOL,
65 HID_DEVICE_W2_SEND_UNSUPPORTED_REQUEST,
66 } hid_device_state_t;
67
68 // hid device state
69 typedef struct hid_device {
70 uint16_t cid;
71 bd_addr_t bd_addr;
72 hci_con_handle_t con_handle;
73 uint16_t control_cid;
74 uint16_t interrupt_cid;
75 uint8_t incoming;
76 uint8_t connected;
77 hid_device_state_t state;
78 hid_report_type_t report_type;
79 uint8_t report_id;
80 uint16_t expected_report_size;
81 uint16_t response_size;
82 uint8_t user_request_can_send_now;
83
84 hid_handshake_param_type_t report_status;
85 hid_protocol_mode_t protocol_mode;
86 } hid_device_t;
87
88 // higher layer callbacks
89 static btstack_packet_handler_t hid_device_callback;
90 static int (*hci_device_get_report) (uint16_t hid_cid, hid_report_type_t report_type, uint16_t report_id, int * out_report_size, uint8_t * out_report) = dummy_write_report;
91 static void (*hci_device_set_report) (uint16_t hid_cid, hid_report_type_t report_type, int report_size, uint8_t * report) = dummy_set_report;
92 static void (*hci_device_report_data) (uint16_t hid_cid, hid_report_type_t report_type, uint16_t report_id, int report_size, uint8_t * report) = dummy_report_data;
93
94 static hid_device_t hid_device_singleton;
95
96 static bool hid_device_boot_protocol_mode_supported;
97 static const uint8_t * hid_device_descriptor;
98 static uint16_t hid_device_descriptor_len;
99
100
101 static uint16_t hid_device_cid = 0;
102
103
dummy_write_report(uint16_t hid_cid,hid_report_type_t report_type,uint16_t report_id,int * out_report_size,uint8_t * out_report)104 static int dummy_write_report(uint16_t hid_cid, hid_report_type_t report_type, uint16_t report_id, int * out_report_size, uint8_t * out_report){
105 UNUSED(hid_cid);
106 UNUSED(report_type);
107 UNUSED(report_id);
108 UNUSED(out_report_size);
109 UNUSED(out_report);
110 return -1;
111 }
112
dummy_set_report(uint16_t hid_cid,hid_report_type_t report_type,int report_size,uint8_t * report)113 static void dummy_set_report(uint16_t hid_cid, hid_report_type_t report_type, int report_size, uint8_t * report){
114 UNUSED(hid_cid);
115 UNUSED(report_type);
116 UNUSED(report_size);
117 UNUSED(report);
118 }
119
dummy_report_data(uint16_t hid_cid,hid_report_type_t report_type,uint16_t report_id,int report_size,uint8_t * report)120 static void dummy_report_data(uint16_t hid_cid, hid_report_type_t report_type, uint16_t report_id, int report_size, uint8_t * report){
121 UNUSED(hid_cid);
122 UNUSED(report_type);
123 UNUSED(report_id);
124 UNUSED(report_size);
125 UNUSED(report);
126 }
127
hid_device_get_next_cid(void)128 static uint16_t hid_device_get_next_cid(void){
129 hid_device_cid++;
130 if (!hid_device_cid){
131 hid_device_cid = 1;
132 }
133 return hid_device_cid;
134 }
135
136 // TODO: store hid device connection into list
hid_device_get_instance_for_l2cap_cid(uint16_t cid)137 static hid_device_t * hid_device_get_instance_for_l2cap_cid(uint16_t cid){
138 if ((hid_device_singleton.control_cid == cid) || (hid_device_singleton.interrupt_cid == cid)){
139 return &hid_device_singleton;
140 }
141 return NULL;
142 }
143
hid_device_get_instance_for_hid_cid(uint16_t hid_cid)144 static hid_device_t * hid_device_get_instance_for_hid_cid(uint16_t hid_cid){
145 if (hid_device_singleton.cid == hid_cid){
146 return &hid_device_singleton;
147 }
148 return NULL;
149 }
150
hid_device_setup_instance(hid_device_t * hid_device,const uint8_t * bd_addr)151 static void hid_device_setup_instance(hid_device_t *hid_device, const uint8_t *bd_addr) {
152 (void)memcpy(hid_device->bd_addr, bd_addr, 6);
153 hid_device->cid = hid_device_get_next_cid();
154 // reset state
155 hid_device->protocol_mode = HID_PROTOCOL_MODE_REPORT;
156 hid_device->con_handle = HCI_CON_HANDLE_INVALID;
157 hid_device->incoming = 0;
158 hid_device->connected = 0;
159 hid_device->control_cid = 0;
160 hid_device->interrupt_cid = 0;
161 }
162
hid_device_provide_instance_for_bd_addr(bd_addr_t bd_addr)163 static hid_device_t * hid_device_provide_instance_for_bd_addr(bd_addr_t bd_addr){
164 if (!hid_device_singleton.cid){
165 hid_device_setup_instance(&hid_device_singleton, bd_addr);
166 }
167 return &hid_device_singleton;
168 }
169
hid_device_create_instance(void)170 static hid_device_t * hid_device_create_instance(void){
171
172 return &hid_device_singleton;
173 }
174
hid_create_sdp_record(uint8_t * service,uint32_t service_record_handle,const hid_sdp_record_t * params)175 void hid_create_sdp_record(uint8_t *service, uint32_t service_record_handle, const hid_sdp_record_t * params){
176 uint8_t * attribute;
177 de_create_sequence(service);
178
179 de_add_number(service, DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_SERVICE_RECORD_HANDLE);
180 de_add_number(service, DE_UINT, DE_SIZE_32, service_record_handle);
181
182 de_add_number(service, DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_SERVICE_CLASS_ID_LIST);
183 attribute = de_push_sequence(service);
184 {
185 de_add_number(attribute, DE_UUID, DE_SIZE_16, BLUETOOTH_SERVICE_CLASS_HUMAN_INTERFACE_DEVICE_SERVICE);
186 }
187 de_pop_sequence(service, attribute);
188
189 de_add_number(service, DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_PROTOCOL_DESCRIPTOR_LIST);
190 attribute = de_push_sequence(service);
191 {
192 uint8_t * l2cpProtocol = de_push_sequence(attribute);
193 {
194 de_add_number(l2cpProtocol, DE_UUID, DE_SIZE_16, BLUETOOTH_PROTOCOL_L2CAP);
195 de_add_number(l2cpProtocol, DE_UINT, DE_SIZE_16, BLUETOOTH_PSM_HID_CONTROL);
196 }
197 de_pop_sequence(attribute, l2cpProtocol);
198
199 uint8_t * hidProtocol = de_push_sequence(attribute);
200 {
201 de_add_number(hidProtocol, DE_UUID, DE_SIZE_16, BLUETOOTH_PROTOCOL_HIDP);
202 }
203 de_pop_sequence(attribute, hidProtocol);
204 }
205 de_pop_sequence(service, attribute);
206
207 // TODO?
208 de_add_number(service, DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_LANGUAGE_BASE_ATTRIBUTE_ID_LIST);
209 attribute = de_push_sequence(service);
210 {
211 de_add_number(attribute, DE_UINT, DE_SIZE_16, 0x656e);
212 de_add_number(attribute, DE_UINT, DE_SIZE_16, 0x006a);
213 de_add_number(attribute, DE_UINT, DE_SIZE_16, 0x0100);
214 }
215 de_pop_sequence(service, attribute);
216
217 de_add_number(service, DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_ADDITIONAL_PROTOCOL_DESCRIPTOR_LISTS);
218 attribute = de_push_sequence(service);
219 {
220 uint8_t * additionalDescriptorAttribute = de_push_sequence(attribute);
221 {
222 uint8_t * l2cpProtocol = de_push_sequence(additionalDescriptorAttribute);
223 {
224 de_add_number(l2cpProtocol, DE_UUID, DE_SIZE_16, BLUETOOTH_PROTOCOL_L2CAP);
225 de_add_number(l2cpProtocol, DE_UINT, DE_SIZE_16, BLUETOOTH_PSM_HID_INTERRUPT);
226 }
227 de_pop_sequence(additionalDescriptorAttribute, l2cpProtocol);
228
229 uint8_t * hidProtocol = de_push_sequence(additionalDescriptorAttribute);
230 {
231 de_add_number(hidProtocol, DE_UUID, DE_SIZE_16, BLUETOOTH_PROTOCOL_HIDP);
232 }
233 de_pop_sequence(additionalDescriptorAttribute, hidProtocol);
234 }
235 de_pop_sequence(attribute, additionalDescriptorAttribute);
236 }
237 de_pop_sequence(service, attribute);
238
239 // 0x0100 "ServiceName"
240 de_add_number(service, DE_UINT, DE_SIZE_16, 0x0100);
241 de_add_data(service, DE_STRING, (uint16_t) strlen(params->device_name), (uint8_t *) params->device_name);
242
243 de_add_number(service, DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_BLUETOOTH_PROFILE_DESCRIPTOR_LIST);
244 attribute = de_push_sequence(service);
245 {
246 uint8_t * hidProfile = de_push_sequence(attribute);
247 {
248 de_add_number(hidProfile, DE_UUID, DE_SIZE_16, BLUETOOTH_SERVICE_CLASS_HUMAN_INTERFACE_DEVICE_SERVICE);
249 de_add_number(hidProfile, DE_UINT, DE_SIZE_16, 0x0101); // Version 1.1
250 }
251 de_pop_sequence(attribute, hidProfile);
252 }
253 de_pop_sequence(service, attribute);
254
255 // Deprecated in v1.1.1
256 // de_add_number(service, DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_HID_DEVICE_RELEASE_NUMBER);
257 // de_add_number(service, DE_UINT, DE_SIZE_16, 0x0101);
258
259 de_add_number(service, DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_HID_PARSER_VERSION);
260 de_add_number(service, DE_UINT, DE_SIZE_16, 0x0111); // v1.1.1
261
262 de_add_number(service, DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_HID_DEVICE_SUBCLASS);
263 de_add_number(service, DE_UINT, DE_SIZE_8, params->hid_device_subclass);
264
265 de_add_number(service, DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_HID_COUNTRY_CODE);
266 de_add_number(service, DE_UINT, DE_SIZE_8, params->hid_country_code);
267
268 de_add_number(service, DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_HID_VIRTUAL_CABLE);
269 de_add_number(service, DE_BOOL, DE_SIZE_8, params->hid_virtual_cable);
270
271 de_add_number(service, DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_HID_RECONNECT_INITIATE);
272 de_add_number(service, DE_BOOL, DE_SIZE_8, params->hid_reconnect_initiate);
273
274 de_add_number(service, DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_HID_DESCRIPTOR_LIST);
275 attribute = de_push_sequence(service);
276 {
277 uint8_t* hidDescriptor = de_push_sequence(attribute);
278 {
279 de_add_number(hidDescriptor, DE_UINT, DE_SIZE_8, 0x22); // Report Descriptor
280 de_add_data(hidDescriptor, DE_STRING, params->hid_descriptor_size, (uint8_t *) params->hid_descriptor);
281 }
282 de_pop_sequence(attribute, hidDescriptor);
283 }
284 de_pop_sequence(service, attribute);
285
286 de_add_number(service, DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_HIDLANGID_BASE_LIST);
287 attribute = de_push_sequence(service);
288 {
289 uint8_t* hig_lang_base = de_push_sequence(attribute);
290 {
291 // see: http://www.usb.org/developers/docs/USB_LANGIDs.pdf
292 de_add_number(hig_lang_base, DE_UINT, DE_SIZE_16, 0x0409); // HIDLANGID = English (US)
293 de_add_number(hig_lang_base, DE_UINT, DE_SIZE_16, 0x0100); // HIDLanguageBase = 0x0100 default
294 }
295 de_pop_sequence(attribute, hig_lang_base);
296 }
297 de_pop_sequence(service, attribute);
298
299 // battery power
300
301 de_add_number(service, DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_HID_REMOTE_WAKE);
302 de_add_number(service, DE_BOOL, DE_SIZE_8, params->hid_remote_wake ? 1 : 0);
303
304 // supervision timeout
305 de_add_number(service, DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_HID_SUPERVISION_TIMEOUT);
306 de_add_number(service, DE_UINT, DE_SIZE_16, params->hid_supervision_timeout);
307
308 de_add_number(service, DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_HID_NORMALLY_CONNECTABLE);
309 de_add_number(service, DE_BOOL, DE_SIZE_8, params->hid_normally_connectable);
310
311 de_add_number(service, DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_HID_BOOT_DEVICE);
312 de_add_number(service, DE_BOOL, DE_SIZE_8, params->hid_boot_device ? 1 : 0);
313
314 de_add_number(service, DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_HIDSSR_HOST_MAX_LATENCY);
315 de_add_number(service, DE_UINT, DE_SIZE_16, params->hid_ssr_host_max_latency);
316
317 de_add_number(service, DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_HIDSSR_HOST_MIN_TIMEOUT);
318 de_add_number(service, DE_UINT, DE_SIZE_16, params->hid_ssr_host_min_timeout);
319 }
320
hid_device_emit_connected_event(hid_device_t * context,uint8_t status)321 static inline void hid_device_emit_connected_event(hid_device_t * context, uint8_t status){
322 uint8_t event[15];
323 int pos = 0;
324 event[pos++] = HCI_EVENT_HID_META;
325 pos++; // skip len
326 event[pos++] = HID_SUBEVENT_CONNECTION_OPENED;
327 little_endian_store_16(event,pos,context->cid);
328 pos+=2;
329 event[pos++] = status;
330 reverse_bd_addr(context->bd_addr, &event[pos]);
331 pos += 6;
332 little_endian_store_16(event,pos,context->con_handle);
333 pos += 2;
334 event[pos++] = context->incoming;
335 event[1] = pos - 2;
336 hid_device_callback(HCI_EVENT_PACKET, context->cid, &event[0], pos);
337 }
338
hid_device_emit_event(hid_device_t * context,uint8_t subevent_type)339 static inline void hid_device_emit_event(hid_device_t * context, uint8_t subevent_type){
340 uint8_t event[5];
341 int pos = 0;
342 event[pos++] = HCI_EVENT_HID_META;
343 pos++; // skip len
344 event[pos++] = subevent_type;
345 little_endian_store_16(event,pos,context->cid);
346 pos+=2;
347 event[1] = pos - 2;
348 hid_device_callback(HCI_EVENT_PACKET, context->cid, &event[0], pos);
349 }
350
hid_device_trigger_user_request_if_pending(const hid_device_t * hid_device)351 static void hid_device_trigger_user_request_if_pending(const hid_device_t *hid_device) {// request user can send now if pending
352 if (hid_device->user_request_can_send_now){
353 l2cap_request_can_send_now_event((hid_device->control_cid));
354 }
355 }
356
hid_device_send_prepared_control_message(hid_device_t * hid_device,uint16_t message_len)357 static void hid_device_send_prepared_control_message(hid_device_t * hid_device, uint16_t message_len){
358 l2cap_send_prepared(hid_device->control_cid, message_len);
359 hid_device_trigger_user_request_if_pending(hid_device);
360 }
361
hid_report_size_valid(uint16_t cid,int report_id,hid_report_type_t report_type,int report_size)362 static int hid_report_size_valid(uint16_t cid, int report_id, hid_report_type_t report_type, int report_size){
363 if (!report_size) return 0;
364 if (hid_device_in_boot_protocol_mode(cid)){
365 switch (report_id){
366 case HID_BOOT_MODE_KEYBOARD_ID:
367 if (report_size < 8) return 0;
368 break;
369 case HID_BOOT_MODE_MOUSE_ID:
370 if (report_size < 1) return 0;
371 break;
372 default:
373 return 0;
374 }
375 } else {
376 int size = btstack_hid_get_report_size_for_id(report_id, report_type, hid_device_descriptor, hid_device_descriptor_len);
377 if ((size == 0) || (size != report_size)) return 0;
378 }
379 return 1;
380 }
381
hid_get_report_size_for_id(uint16_t cid,int report_id,hid_report_type_t report_type,uint16_t descriptor_len,const uint8_t * descriptor)382 static int hid_get_report_size_for_id(uint16_t cid, int report_id, hid_report_type_t report_type, uint16_t descriptor_len, const uint8_t * descriptor){
383 if (hid_device_in_boot_protocol_mode(cid)){
384 switch (report_id){
385 case HID_BOOT_MODE_KEYBOARD_ID:
386 return 8;
387 case HID_BOOT_MODE_MOUSE_ID:
388 return 3;
389 default:
390 return 0;
391 }
392 } else {
393 return btstack_hid_get_report_size_for_id(report_id, report_type, descriptor, descriptor_len);
394 }
395 }
396
hid_report_id_status(uint16_t cid,uint16_t report_id)397 static hid_report_id_status_t hid_report_id_status(uint16_t cid, uint16_t report_id){
398 if (hid_device_in_boot_protocol_mode(cid)){
399 switch (report_id){
400 case HID_BOOT_MODE_KEYBOARD_ID:
401 case HID_BOOT_MODE_MOUSE_ID:
402 return HID_REPORT_ID_VALID;
403 default:
404 return HID_REPORT_ID_INVALID;
405 }
406 } else {
407 return btstack_hid_report_id_valid(report_id, hid_device_descriptor, hid_device_descriptor_len);
408 }
409 }
410
hid_device_set_report_cmd_is_valid(uint16_t cid,hid_report_type_t report_type,int report_size,uint8_t * report)411 static hid_handshake_param_type_t hid_device_set_report_cmd_is_valid(uint16_t cid, hid_report_type_t report_type, int report_size, uint8_t * report){
412 int pos = 0;
413 int report_id = 0;
414
415 if (btstack_hid_report_id_declared(hid_device_descriptor, hid_device_descriptor_len)){
416 report_id = report[pos++];
417 hid_report_id_status_t report_id_status = hid_report_id_status(cid, report_id);
418 switch (report_id_status){
419 case HID_REPORT_ID_INVALID:
420 return HID_HANDSHAKE_PARAM_TYPE_ERR_INVALID_REPORT_ID;
421 default:
422 break;
423 }
424 }
425
426 if (!hid_report_size_valid(cid, report_id, report_type, report_size-pos)){
427 // TODO clarify DCT/BI-03c
428 return HID_HANDSHAKE_PARAM_TYPE_ERR_INVALID_PARAMETER;
429 }
430 return HID_HANDSHAKE_PARAM_TYPE_SUCCESSFUL;
431 }
432
packet_handler(uint8_t packet_type,uint16_t channel,uint8_t * packet,uint16_t packet_size)433 static void packet_handler(uint8_t packet_type, uint16_t channel, uint8_t * packet, uint16_t packet_size){
434 UNUSED(channel);
435 UNUSED(packet_size);
436 int connected_before;
437 uint16_t psm;
438 uint8_t status;
439 hid_device_t * device = NULL;
440 uint8_t param;
441 bd_addr_t address;
442 uint16_t local_cid;
443 uint16_t pos;
444 int report_size;
445 uint8_t * outgoing_buffer;
446 hid_message_type_t message_type;
447 bool need_report_id;
448 bool need_size;
449 uint16_t response_size;
450
451 switch (packet_type){
452 case L2CAP_DATA_PACKET:
453 device = hid_device_get_instance_for_l2cap_cid(channel);
454 if (!device) {
455 log_error("no device with cid 0x%02x", channel);
456 break;
457 }
458 if (packet_size < 1) break;
459
460 message_type = (hid_message_type_t)(packet[0] >> 4);
461 switch (message_type){
462 case HID_MESSAGE_TYPE_GET_REPORT:
463 pos = 0;
464 device->report_type = (hid_report_type_t)(packet[pos++] & 0x03);
465 device->report_id = 0;
466 device->report_status = HID_HANDSHAKE_PARAM_TYPE_SUCCESSFUL;
467 device->state = HID_DEVICE_W2_GET_REPORT;
468
469 // get and validate report id if needed
470 need_report_id = false;
471 switch (device->protocol_mode){
472 case HID_PROTOCOL_MODE_BOOT:
473 need_report_id = true;
474 break;
475 case HID_PROTOCOL_MODE_REPORT:
476 need_report_id = btstack_hid_report_id_declared(hid_device_descriptor, hid_device_descriptor_len) != 0;
477 break;
478 default:
479 btstack_assert(false);
480 break;
481 }
482 if (need_report_id){
483 if (packet_size >= (pos + 1)){
484 device->report_id = packet[pos++];
485 if (hid_report_id_status(device->cid, device->report_id) == HID_REPORT_ID_INVALID){
486 device->report_status = HID_HANDSHAKE_PARAM_TYPE_ERR_INVALID_REPORT_ID;
487 }
488 } else {
489 device->report_status = HID_HANDSHAKE_PARAM_TYPE_ERR_INVALID_REPORT_ID;
490 }
491 }
492 if (device->report_status != HID_HANDSHAKE_PARAM_TYPE_SUCCESSFUL){
493 l2cap_request_can_send_now_event(device->control_cid);
494 break;
495 }
496
497 // calculate response size
498 device->expected_report_size = hid_get_report_size_for_id(device->cid, device->report_id, device->report_type, hid_device_descriptor_len, hid_device_descriptor);
499 response_size = device->expected_report_size + pos; // DATA [+ ReportID]
500
501 // if size bit is set in header, next two bytes indicate host buffer size
502 need_size = (packet[0] & 0x08) != 0;
503 if (need_size){
504 if (packet_size >= (pos + 2)) {
505 uint16_t host_buffer_size = little_endian_read_16(packet, pos);
506 // host buffer size does not include the DATA header
507 response_size = btstack_min(response_size, host_buffer_size + 1);
508 } else {
509 device->report_status = HID_HANDSHAKE_PARAM_TYPE_ERR_INVALID_PARAMETER;
510 l2cap_request_can_send_now_event(device->control_cid);
511 break;
512 }
513 }
514 device->response_size = response_size;
515
516 l2cap_request_can_send_now_event(device->control_cid);
517 break;
518
519 case HID_MESSAGE_TYPE_SET_REPORT:
520 device->state = HID_DEVICE_W2_SET_REPORT;
521 device->report_type = (hid_report_type_t)(packet[0] & 0x03);
522 if (packet_size < 1){
523 device->report_status = HID_HANDSHAKE_PARAM_TYPE_ERR_INVALID_PARAMETER;
524 break;
525 }
526
527 switch (device->protocol_mode){
528 case HID_PROTOCOL_MODE_BOOT:
529 if (packet_size < 3){
530 device->report_status = HID_HANDSHAKE_PARAM_TYPE_ERR_INVALID_PARAMETER;
531 break;
532 }
533 device->report_id = packet[1];
534 device->report_status = hid_device_set_report_cmd_is_valid(device->cid, device->report_type, packet_size - 1, &packet[1]);
535 if (device->report_status != HID_HANDSHAKE_PARAM_TYPE_SUCCESSFUL) break;
536 (*hci_device_set_report)(device->cid, device->report_type, packet_size-1, &packet[1]);
537 break;
538 case HID_PROTOCOL_MODE_REPORT:
539 device->report_status = hid_device_set_report_cmd_is_valid(device->cid, device->report_type, packet_size - 1, &packet[1]);
540 if (device->report_status != HID_HANDSHAKE_PARAM_TYPE_SUCCESSFUL) break;
541
542 if (packet_size >= 2){
543 (*hci_device_set_report)(device->cid, device->report_type, packet_size-1, &packet[1]);
544 } else {
545 uint8_t payload[] = {0};
546 (*hci_device_set_report)(device->cid, device->report_type, 1, payload);
547 }
548 break;
549 default:
550 btstack_assert(false);
551 break;
552 }
553 device->report_type = (hid_report_type_t)(packet[0] & 0x03);
554 l2cap_request_can_send_now_event(device->control_cid);
555 break;
556 case HID_MESSAGE_TYPE_GET_PROTOCOL:
557 device->state = HID_DEVICE_W2_GET_PROTOCOL;
558 if (packet_size != 1) {
559 device->report_status = HID_HANDSHAKE_PARAM_TYPE_ERR_INVALID_PARAMETER;
560 break;
561 }
562 device->report_status = HID_HANDSHAKE_PARAM_TYPE_SUCCESSFUL;
563 // hid_device_request_can_send_now_event(channel);
564 l2cap_request_can_send_now_event(device->control_cid);
565 break;
566
567 case HID_MESSAGE_TYPE_SET_PROTOCOL:
568 device->state = HID_DEVICE_W2_SET_PROTOCOL;
569 if (packet_size != 1) {
570 device->report_status = HID_HANDSHAKE_PARAM_TYPE_ERR_INVALID_PARAMETER;
571 break;
572 }
573 param = packet[0] & 0x01;
574 if (((hid_protocol_mode_t)param == HID_PROTOCOL_MODE_BOOT) && !hid_device_boot_protocol_mode_supported){
575 device->report_status = HID_HANDSHAKE_PARAM_TYPE_ERR_INVALID_PARAMETER;
576 break;
577 }
578 device->protocol_mode = (hid_protocol_mode_t) param;
579 switch (device->protocol_mode){
580 case HID_PROTOCOL_MODE_BOOT:
581 break;
582 case HID_PROTOCOL_MODE_REPORT:
583 break;
584 default:
585 btstack_assert(false);
586 break;
587 }
588 device->report_status = HID_HANDSHAKE_PARAM_TYPE_SUCCESSFUL;
589 l2cap_request_can_send_now_event(device->control_cid);
590 break;
591
592 case HID_MESSAGE_TYPE_HID_CONTROL:
593 param = packet[0] & 0x0F;
594
595 switch ((hid_control_param_t)param){
596 case HID_CONTROL_PARAM_SUSPEND:
597 hid_device_emit_event(device, HID_SUBEVENT_SUSPEND);
598 break;
599 case HID_CONTROL_PARAM_EXIT_SUSPEND:
600 hid_device_emit_event(device, HID_SUBEVENT_EXIT_SUSPEND);
601 break;
602 case HID_CONTROL_PARAM_VIRTUAL_CABLE_UNPLUG:
603 hid_device_emit_event(device, HID_SUBEVENT_VIRTUAL_CABLE_UNPLUG);
604 break;
605 default:
606 device->state = HID_DEVICE_W2_SEND_UNSUPPORTED_REQUEST;
607 l2cap_request_can_send_now_event(device->control_cid);
608 break;
609 }
610 break;
611
612 case HID_MESSAGE_TYPE_DATA:
613 if (packet_size < 2) {
614 break;
615 }
616 pos = 0;
617 device->report_type = (hid_report_type_t)(packet[pos++] & 0x03);
618 device->report_id = 0;
619 if (btstack_hid_report_id_declared(hid_device_descriptor, hid_device_descriptor_len)){
620 device->report_id = packet[pos++];
621 }
622
623 if (hid_report_id_status(device->cid, device->report_id) == HID_REPORT_ID_INVALID){
624 log_info("Ignore invalid report data packet");
625 break;
626 }
627 if (!hid_report_size_valid(device->cid, device->report_id, device->report_type, packet_size - pos)){
628 log_info("Ignore invalid report data packet, invalid size");
629 break;
630 }
631 (*hci_device_report_data)(device->cid, device->report_type, device->report_id, packet_size - pos, &packet[pos]);
632 break;
633 default:
634 device->state = HID_DEVICE_W2_SEND_UNSUPPORTED_REQUEST;
635 l2cap_request_can_send_now_event(device->control_cid);
636 break;
637 }
638 break;
639 case HCI_EVENT_PACKET:
640 switch (packet[0]){
641 case L2CAP_EVENT_INCOMING_CONNECTION:
642 switch (l2cap_event_incoming_connection_get_psm(packet)){
643 case PSM_HID_CONTROL:
644 case PSM_HID_INTERRUPT:
645 l2cap_event_incoming_connection_get_address(packet, address);
646 device = hid_device_provide_instance_for_bd_addr(address);
647 if (!device) {
648 log_error("L2CAP_EVENT_INCOMING_CONNECTION, cannot create instance for %s", bd_addr_to_str(address));
649 l2cap_decline_connection(channel);
650 break;
651 }
652 if ((device->con_handle == HCI_CON_HANDLE_INVALID) || (l2cap_event_incoming_connection_get_handle(packet) == device->con_handle)){
653 device->con_handle = l2cap_event_incoming_connection_get_handle(packet);
654 device->incoming = 1;
655 l2cap_event_incoming_connection_get_address(packet, device->bd_addr);
656 psm = l2cap_event_incoming_connection_get_psm(packet);
657 switch (psm){
658 case PSM_HID_CONTROL:
659 device->control_cid = l2cap_event_incoming_connection_get_local_cid(packet);
660 break;
661 case PSM_HID_INTERRUPT:
662 device->interrupt_cid = l2cap_event_incoming_connection_get_local_cid(packet);
663 break;
664 default:
665 break;
666 }
667
668 l2cap_accept_connection(channel);
669 } else {
670 l2cap_decline_connection(channel);
671 log_info("L2CAP_EVENT_INCOMING_CONNECTION, decline connection for %s", bd_addr_to_str(address));
672 }
673 break;
674 default:
675 l2cap_decline_connection(channel);
676 break;
677 }
678 break;
679 case L2CAP_EVENT_CHANNEL_OPENED:
680 device = hid_device_get_instance_for_l2cap_cid(l2cap_event_channel_opened_get_local_cid(packet));
681 if (!device) {
682 log_error("L2CAP_EVENT_CHANNEL_OPENED, no hid device for local cid 0x%02x", l2cap_event_channel_opened_get_local_cid(packet));
683 return;
684 }
685 status = l2cap_event_channel_opened_get_status(packet);
686 if (status) {
687 if (device->incoming == 0){
688 // report error for outgoing connection
689 hid_device_emit_connected_event(device, status);
690 }
691 return;
692 }
693
694 // store con_handle
695 if (device->con_handle == HCI_CON_HANDLE_INVALID){
696 device->con_handle = l2cap_event_channel_opened_get_handle(packet);
697 }
698
699 // store l2cap cid
700 psm = l2cap_event_channel_opened_get_psm(packet);
701 switch (psm){
702 case PSM_HID_CONTROL:
703 device->control_cid = l2cap_event_channel_opened_get_local_cid(packet);
704 break;
705 case PSM_HID_INTERRUPT:
706 device->interrupt_cid = l2cap_event_channel_opened_get_local_cid(packet);
707 break;
708 default:
709 break;
710 }
711
712 // connect HID Interrupt for outgoing
713 if ((device->incoming == 0) && (psm == PSM_HID_CONTROL)){
714 status = l2cap_create_channel(packet_handler, device->bd_addr, PSM_HID_INTERRUPT, l2cap_max_mtu(), &device->interrupt_cid);
715 break;
716 }
717
718 // emit connected if both channels are open
719 connected_before = device->connected;
720 if (!connected_before && device->control_cid && device->interrupt_cid){
721 device->connected = 1;
722 hid_device_emit_connected_event(device, 0);
723 }
724 break;
725 case L2CAP_EVENT_CHANNEL_CLOSED:
726 device = hid_device_get_instance_for_l2cap_cid(l2cap_event_channel_closed_get_local_cid(packet));
727 if (!device) return;
728
729 // connected_before = device->connected;
730 device->incoming = 0;
731 if (l2cap_event_channel_closed_get_local_cid(packet) == device->interrupt_cid){
732 device->interrupt_cid = 0;
733 }
734 if (l2cap_event_channel_closed_get_local_cid(packet) == device->control_cid){
735 device->control_cid = 0;
736 }
737 if (!device->interrupt_cid && !device->control_cid){
738 device->connected = 0;
739 device->con_handle = HCI_CON_HANDLE_INVALID;
740 device->cid = 0;
741 hid_device_emit_event(device, HID_SUBEVENT_CONNECTION_CLOSED);
742 }
743 break;
744
745 case L2CAP_EVENT_CAN_SEND_NOW:
746 local_cid = l2cap_event_can_send_now_get_local_cid(packet);
747 device = hid_device_get_instance_for_l2cap_cid(local_cid);
748 if (!device) return;
749
750 l2cap_reserve_packet_buffer();
751 outgoing_buffer = l2cap_get_outgoing_buffer();
752
753 switch (device->state){
754 case HID_DEVICE_W2_GET_REPORT:{
755 if (device->report_status != HID_HANDSHAKE_PARAM_TYPE_SUCCESSFUL) {
756 outgoing_buffer[0] = (HID_MESSAGE_TYPE_HANDSHAKE << 4) | device->report_status;
757 hid_device_send_prepared_control_message(device, 1);
758 break;
759 }
760
761 pos = 0;
762 outgoing_buffer[pos++] = (HID_MESSAGE_TYPE_DATA << 4) | device->report_type;
763 if (device->report_id != 0){
764 outgoing_buffer[pos++] = device->report_id;
765 }
766
767 report_size = 0;
768 status = (*hci_device_get_report)(device->cid, device->report_type, device->report_id, &report_size, &outgoing_buffer[pos]);
769
770 switch (status){
771 case 0:
772 device->report_status = HID_HANDSHAKE_PARAM_TYPE_NOT_READY;
773 break;
774 case 1:
775 if (report_size == 0){
776 device->report_status = HID_HANDSHAKE_PARAM_TYPE_ERR_UNSUPPORTED_REQUEST;
777 break;
778 }
779 if (device->expected_report_size != report_size){
780 log_error("Expected report size of %d bytes, received %d", device->expected_report_size, report_size);
781 device->report_status = HID_HANDSHAKE_PARAM_TYPE_ERR_UNSUPPORTED_REQUEST;
782 break;
783 }
784 break;
785 default:
786 device->report_status = HID_HANDSHAKE_PARAM_TYPE_ERR_UNSUPPORTED_REQUEST;
787 break;
788 }
789 if (device->report_status != HID_HANDSHAKE_PARAM_TYPE_SUCCESSFUL){
790 outgoing_buffer[0] = (HID_MESSAGE_TYPE_HANDSHAKE << 4) | device->report_status;
791 hid_device_send_prepared_control_message(device, 1);
792 } else {
793 hid_device_send_prepared_control_message(device, device->response_size);
794 }
795 break;
796 }
797 case HID_DEVICE_W2_SET_REPORT:
798 case HID_DEVICE_W2_SET_PROTOCOL:
799 outgoing_buffer[0] = (HID_MESSAGE_TYPE_HANDSHAKE << 4) | device->report_status;
800 hid_device_send_prepared_control_message(device, 1);
801 break;
802 case HID_DEVICE_W2_GET_PROTOCOL:
803 if (device->report_status != HID_HANDSHAKE_PARAM_TYPE_SUCCESSFUL){
804 outgoing_buffer[0] = (HID_MESSAGE_TYPE_HANDSHAKE << 4) | device->report_status;
805 hid_device_send_prepared_control_message(device, 1);
806 } else {
807 outgoing_buffer[0] = (HID_MESSAGE_TYPE_DATA << 4);
808 outgoing_buffer[1] = device->protocol_mode;
809 hid_device_send_prepared_control_message(device, 2);
810 }
811 break;
812 case HID_DEVICE_W2_SEND_UNSUPPORTED_REQUEST:
813 outgoing_buffer[0] = (HID_MESSAGE_TYPE_HANDSHAKE << 4) | HID_HANDSHAKE_PARAM_TYPE_ERR_UNSUPPORTED_REQUEST;
814 hid_device_send_prepared_control_message(device, 1);
815 break;
816 default:
817 l2cap_release_packet_buffer();
818 if (device->user_request_can_send_now){
819 device->user_request_can_send_now = 0;
820 hid_device_emit_event(device, HID_SUBEVENT_CAN_SEND_NOW);
821 }
822 break;
823 }
824 device->state = HID_DEVICE_IDLE;
825 break;
826 default:
827 break;
828 }
829 break;
830 default:
831 break;
832 }
833 }
834
835 /**
836 * @brief Set up HID Device
837 */
hid_device_init(bool boot_protocol_mode_supported,uint16_t descriptor_len,const uint8_t * descriptor)838 void hid_device_init(bool boot_protocol_mode_supported, uint16_t descriptor_len, const uint8_t * descriptor){
839 hid_device_boot_protocol_mode_supported = boot_protocol_mode_supported;
840 hid_device_descriptor = descriptor;
841 hid_device_descriptor_len = descriptor_len;
842 hci_device_get_report = dummy_write_report;
843 hci_device_set_report = dummy_set_report;
844 hci_device_report_data = dummy_report_data;
845
846 l2cap_register_service(packet_handler, PSM_HID_INTERRUPT, 100, gap_get_security_level());
847 l2cap_register_service(packet_handler, PSM_HID_CONTROL, 100, gap_get_security_level());
848 }
849
hid_device_deinit(void)850 void hid_device_deinit(void){
851 hid_device_callback = NULL;
852 hci_device_get_report = NULL;
853 hci_device_set_report = NULL;
854 hci_device_report_data = NULL;
855
856 (void) memset(&hid_device_singleton, 0, sizeof(hid_device_t));
857
858 hid_device_boot_protocol_mode_supported = false;
859 hid_device_descriptor = NULL;
860 hid_device_descriptor_len = 0;
861 hid_device_cid = 0;
862 }
863
864 /**
865 * @brief Register callback for the HID Device client.
866 * @param callback
867 */
hid_device_register_packet_handler(btstack_packet_handler_t callback)868 void hid_device_register_packet_handler(btstack_packet_handler_t callback){
869 hid_device_callback = callback;
870 }
871
hid_device_register_report_request_callback(int (* callback)(uint16_t hid_cid,hid_report_type_t report_type,uint16_t report_id,int * out_report_size,uint8_t * out_report))872 void hid_device_register_report_request_callback(int (*callback)(uint16_t hid_cid, hid_report_type_t report_type, uint16_t report_id, int * out_report_size, uint8_t * out_report)){
873 if (callback == NULL){
874 callback = dummy_write_report;
875 }
876 hci_device_get_report = callback;
877 }
878
hid_device_register_set_report_callback(void (* callback)(uint16_t hid_cid,hid_report_type_t report_type,int report_size,uint8_t * report))879 void hid_device_register_set_report_callback(void (*callback)(uint16_t hid_cid, hid_report_type_t report_type, int report_size, uint8_t * report)){
880 if (callback == NULL){
881 callback = dummy_set_report;
882 }
883 hci_device_set_report = callback;
884 }
885
hid_device_register_report_data_callback(void (* callback)(uint16_t cid,hid_report_type_t report_type,uint16_t report_id,int report_size,uint8_t * report))886 void hid_device_register_report_data_callback(void (*callback)(uint16_t cid, hid_report_type_t report_type, uint16_t report_id, int report_size, uint8_t * report)){
887 if (callback == NULL){
888 callback = dummy_report_data;
889 }
890 hci_device_report_data = callback;
891 }
892
893
894 /**
895 * @brief Request can send now event to send HID Report
896 * @param hid_cid
897 */
hid_device_request_can_send_now_event(uint16_t hid_cid)898 void hid_device_request_can_send_now_event(uint16_t hid_cid){
899 hid_device_t * hid_device = hid_device_get_instance_for_hid_cid(hid_cid);
900 if (!hid_device || !hid_device->interrupt_cid) return;
901 hid_device->user_request_can_send_now = 1;
902 l2cap_request_can_send_now_event(hid_device->interrupt_cid);
903 }
904
905 /**
906 * @brief Send HID message on interrupt channel
907 * @param hid_cid
908 */
hid_device_send_interrupt_message(uint16_t hid_cid,const uint8_t * message,uint16_t message_len)909 void hid_device_send_interrupt_message(uint16_t hid_cid, const uint8_t * message, uint16_t message_len){
910 hid_device_t * hid_device = hid_device_get_instance_for_hid_cid(hid_cid);
911 if (!hid_device || !hid_device->interrupt_cid) return;
912 l2cap_send(hid_device->interrupt_cid, (uint8_t*) message, message_len);
913 if (hid_device->user_request_can_send_now){
914 l2cap_request_can_send_now_event((hid_device->interrupt_cid));
915 }
916 }
917
918 /**
919 * @brief Send HID message on control channel
920 * @param hid_cid
921 */
hid_device_send_control_message(uint16_t hid_cid,const uint8_t * message,uint16_t message_len)922 void hid_device_send_control_message(uint16_t hid_cid, const uint8_t * message, uint16_t message_len){
923 hid_device_t * hid_device = hid_device_get_instance_for_hid_cid(hid_cid);
924 if (!hid_device || !hid_device->control_cid) return;
925 l2cap_send(hid_device->control_cid, (uint8_t*) message, message_len);
926 hid_device_trigger_user_request_if_pending(hid_device);
927 }
928
929 /*
930 * @brief Create HID connection to HID Host
931 * @param addr
932 * @param hid_cid to use for other commands
933 * @result status
934 */
hid_device_connect(bd_addr_t addr,uint16_t * hid_cid)935 uint8_t hid_device_connect(bd_addr_t addr, uint16_t * hid_cid){
936 hid_device_t * hid_device = hid_device_create_instance();
937 if (!hid_device){
938 log_error("hid_device_connect: could not create a hid device instace");
939 return BTSTACK_MEMORY_ALLOC_FAILED;
940 }
941
942 // setup instance
943 hid_device_setup_instance(hid_device, addr);
944 *hid_cid = hid_device->cid;
945
946 // create l2cap control using fixed HID L2CAP PSM
947 log_info("Create outgoing HID Control");
948 uint8_t status = l2cap_create_channel(packet_handler, hid_device->bd_addr, PSM_HID_CONTROL, l2cap_max_mtu(), &hid_device->control_cid);
949 return status;
950 }
951
952 /*
953 * @brief Disconnect from HID Host
954 * @param hid_cid
955 * @result status
956 */
hid_device_disconnect_interrupt_channel(uint16_t hid_cid)957 void hid_device_disconnect_interrupt_channel(uint16_t hid_cid){
958 hid_device_t * hid_device = hid_device_get_instance_for_hid_cid(hid_cid);
959 if (!hid_device){
960 log_error("hid_device_disconnect_interrupt_channel: could not find hid device instace");
961 return;
962 }
963 log_info("Disconnect from interrupt channel HID Host");
964 if (hid_device->interrupt_cid){
965 l2cap_disconnect(hid_device->interrupt_cid);
966 }
967 }
968
hid_device_disconnect_control_channel(uint16_t hid_cid)969 void hid_device_disconnect_control_channel(uint16_t hid_cid){
970 hid_device_t * hid_device = hid_device_get_instance_for_hid_cid(hid_cid);
971 if (!hid_device){
972 log_error("hid_device_disconnect_control_channel: could not find hid device instace");
973 return;
974 }
975 log_info("Disconnect from control channel HID Host");
976 if (hid_device->control_cid){
977 l2cap_disconnect(hid_device->control_cid);
978 }
979 }
980
hid_device_disconnect(uint16_t hid_cid)981 void hid_device_disconnect(uint16_t hid_cid){
982 hid_device_t * hid_device = hid_device_get_instance_for_hid_cid(hid_cid);
983 if (!hid_device){
984 log_error("hid_device_disconnect: could not find hid device instace");
985 return;
986 }
987 log_info("Disconnect from HID Host");
988 if (hid_device->interrupt_cid){
989 l2cap_disconnect(hid_device->interrupt_cid);
990 }
991 if (hid_device->control_cid){
992 l2cap_disconnect(hid_device->control_cid);
993 }
994 }
995
hid_device_in_boot_protocol_mode(uint16_t hid_cid)996 int hid_device_in_boot_protocol_mode(uint16_t hid_cid){
997 hid_device_t * hid_device = hid_device_get_instance_for_hid_cid(hid_cid);
998 if (!hid_device){
999 log_error("hid_device_in_boot_protocol_mode: could not find hid device instace");
1000 return 0;
1001 }
1002 return hid_device->protocol_mode == HID_PROTOCOL_MODE_BOOT;
1003 }
1004