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