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