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