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