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