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 l2cap_reserve_packet_buffer(); 751 outgoing_buffer = l2cap_get_outgoing_buffer(); 752 753 switch (device->state){ 754 case HID_DEVICE_W2_GET_REPORT:{ 755 if (device->report_status != HID_HANDSHAKE_PARAM_TYPE_SUCCESSFUL) { 756 outgoing_buffer[0] = (HID_MESSAGE_TYPE_HANDSHAKE << 4) | device->report_status; 757 hid_device_send_prepared_control_message(device, 1); 758 break; 759 } 760 761 pos = 0; 762 outgoing_buffer[pos++] = (HID_MESSAGE_TYPE_DATA << 4) | device->report_type; 763 if (device->report_id != 0){ 764 outgoing_buffer[pos++] = device->report_id; 765 } 766 767 report_size = 0; 768 status = (*hci_device_get_report)(device->cid, device->report_type, device->report_id, &report_size, &outgoing_buffer[pos]); 769 770 switch (status){ 771 case 0: 772 device->report_status = HID_HANDSHAKE_PARAM_TYPE_NOT_READY; 773 break; 774 case 1: 775 if (report_size == 0){ 776 device->report_status = HID_HANDSHAKE_PARAM_TYPE_ERR_UNSUPPORTED_REQUEST; 777 break; 778 } 779 if (device->expected_report_size != report_size){ 780 log_error("Expected report size of %d bytes, received %d", device->expected_report_size, report_size); 781 device->report_status = HID_HANDSHAKE_PARAM_TYPE_ERR_UNSUPPORTED_REQUEST; 782 break; 783 } 784 break; 785 default: 786 device->report_status = HID_HANDSHAKE_PARAM_TYPE_ERR_UNSUPPORTED_REQUEST; 787 break; 788 } 789 if (device->report_status != HID_HANDSHAKE_PARAM_TYPE_SUCCESSFUL){ 790 outgoing_buffer[0] = (HID_MESSAGE_TYPE_HANDSHAKE << 4) | device->report_status; 791 hid_device_send_prepared_control_message(device, 1); 792 } else { 793 hid_device_send_prepared_control_message(device, device->response_size); 794 } 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 } else { 807 outgoing_buffer[0] = (HID_MESSAGE_TYPE_DATA << 4); 808 outgoing_buffer[1] = device->protocol_mode; 809 hid_device_send_prepared_control_message(device, 2); 810 } 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 l2cap_release_packet_buffer(); 818 if (device->user_request_can_send_now){ 819 device->user_request_can_send_now = 0; 820 hid_device_emit_event(device, HID_SUBEVENT_CAN_SEND_NOW); 821 } 822 break; 823 } 824 device->state = HID_DEVICE_IDLE; 825 break; 826 default: 827 break; 828 } 829 break; 830 default: 831 break; 832 } 833 } 834 835 /** 836 * @brief Set up HID Device 837 */ 838 void hid_device_init(bool boot_protocol_mode_supported, uint16_t descriptor_len, const uint8_t * descriptor){ 839 hid_device_boot_protocol_mode_supported = boot_protocol_mode_supported; 840 hid_device_descriptor = descriptor; 841 hid_device_descriptor_len = descriptor_len; 842 hci_device_get_report = dummy_write_report; 843 hci_device_set_report = dummy_set_report; 844 hci_device_report_data = dummy_report_data; 845 846 l2cap_register_service(packet_handler, PSM_HID_INTERRUPT, 100, gap_get_security_level()); 847 l2cap_register_service(packet_handler, PSM_HID_CONTROL, 100, gap_get_security_level()); 848 } 849 850 void hid_device_deinit(void){ 851 hid_device_callback = NULL; 852 hci_device_get_report = NULL; 853 hci_device_set_report = NULL; 854 hci_device_report_data = NULL; 855 856 (void) memset(&hid_device_singleton, 0, sizeof(hid_device_t)); 857 858 hid_device_boot_protocol_mode_supported = false; 859 hid_device_descriptor = NULL; 860 hid_device_descriptor_len = 0; 861 hid_device_cid = 0; 862 } 863 864 /** 865 * @brief Register callback for the HID Device client. 866 * @param callback 867 */ 868 void hid_device_register_packet_handler(btstack_packet_handler_t callback){ 869 hid_device_callback = callback; 870 } 871 872 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)){ 873 if (callback == NULL){ 874 callback = dummy_write_report; 875 } 876 hci_device_get_report = callback; 877 } 878 879 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)){ 880 if (callback == NULL){ 881 callback = dummy_set_report; 882 } 883 hci_device_set_report = callback; 884 } 885 886 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)){ 887 if (callback == NULL){ 888 callback = dummy_report_data; 889 } 890 hci_device_report_data = callback; 891 } 892 893 894 /** 895 * @brief Request can send now event to send HID Report 896 * @param hid_cid 897 */ 898 void hid_device_request_can_send_now_event(uint16_t hid_cid){ 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 hid_device->user_request_can_send_now = 1; 902 l2cap_request_can_send_now_event(hid_device->interrupt_cid); 903 } 904 905 /** 906 * @brief Send HID message on interrupt channel 907 * @param hid_cid 908 */ 909 void hid_device_send_interrupt_message(uint16_t hid_cid, const uint8_t * message, uint16_t message_len){ 910 hid_device_t * hid_device = hid_device_get_instance_for_hid_cid(hid_cid); 911 if (!hid_device || !hid_device->interrupt_cid) return; 912 l2cap_send(hid_device->interrupt_cid, (uint8_t*) message, message_len); 913 if (hid_device->user_request_can_send_now){ 914 l2cap_request_can_send_now_event((hid_device->interrupt_cid)); 915 } 916 } 917 918 /** 919 * @brief Send HID message on control channel 920 * @param hid_cid 921 */ 922 void hid_device_send_control_message(uint16_t hid_cid, const uint8_t * message, uint16_t message_len){ 923 hid_device_t * hid_device = hid_device_get_instance_for_hid_cid(hid_cid); 924 if (!hid_device || !hid_device->control_cid) return; 925 l2cap_send(hid_device->control_cid, (uint8_t*) message, message_len); 926 hid_device_trigger_user_request_if_pending(hid_device); 927 } 928 929 /* 930 * @brief Create HID connection to HID Host 931 * @param addr 932 * @param hid_cid to use for other commands 933 * @result status 934 */ 935 uint8_t hid_device_connect(bd_addr_t addr, uint16_t * hid_cid){ 936 hid_device_t * hid_device = hid_device_create_instance(); 937 if (!hid_device){ 938 log_error("hid_device_connect: could not create a hid device instace"); 939 return BTSTACK_MEMORY_ALLOC_FAILED; 940 } 941 942 // setup instance 943 hid_device_setup_instance(hid_device, addr); 944 *hid_cid = hid_device->cid; 945 946 // create l2cap control using fixed HID L2CAP PSM 947 log_info("Create outgoing HID Control"); 948 uint8_t status = l2cap_create_channel(packet_handler, hid_device->bd_addr, PSM_HID_CONTROL, 48, &hid_device->control_cid); 949 return status; 950 } 951 952 /* 953 * @brief Disconnect from HID Host 954 * @param hid_cid 955 * @result status 956 */ 957 void hid_device_disconnect_interrupt_channel(uint16_t hid_cid){ 958 hid_device_t * hid_device = hid_device_get_instance_for_hid_cid(hid_cid); 959 if (!hid_device){ 960 log_error("hid_device_disconnect_interrupt_channel: could not find hid device instace"); 961 return; 962 } 963 log_info("Disconnect from interrupt channel HID Host"); 964 if (hid_device->interrupt_cid){ 965 l2cap_disconnect(hid_device->interrupt_cid); 966 } 967 } 968 969 void hid_device_disconnect_control_channel(uint16_t hid_cid){ 970 hid_device_t * hid_device = hid_device_get_instance_for_hid_cid(hid_cid); 971 if (!hid_device){ 972 log_error("hid_device_disconnect_control_channel: could not find hid device instace"); 973 return; 974 } 975 log_info("Disconnect from control channel HID Host"); 976 if (hid_device->control_cid){ 977 l2cap_disconnect(hid_device->control_cid); 978 } 979 } 980 981 void hid_device_disconnect(uint16_t hid_cid){ 982 hid_device_t * hid_device = hid_device_get_instance_for_hid_cid(hid_cid); 983 if (!hid_device){ 984 log_error("hid_device_disconnect: could not find hid device instace"); 985 return; 986 } 987 log_info("Disconnect from HID Host"); 988 if (hid_device->interrupt_cid){ 989 l2cap_disconnect(hid_device->interrupt_cid); 990 } 991 if (hid_device->control_cid){ 992 l2cap_disconnect(hid_device->control_cid); 993 } 994 } 995 996 int hid_device_in_boot_protocol_mode(uint16_t hid_cid){ 997 hid_device_t * hid_device = hid_device_get_instance_for_hid_cid(hid_cid); 998 if (!hid_device){ 999 log_error("hid_device_in_boot_protocol_mode: could not find hid device instace"); 1000 return 0; 1001 } 1002 return hid_device->protocol_mode == HID_PROTOCOL_MODE_BOOT; 1003 } 1004