/* * Copyright (C) 2017 BlueKitchen GmbH * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the copyright holders nor the names of * contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * 4. Any redistribution, use, or modification is done solely for * personal benefit and not for any commercial purpose or for * monetary gain. * * THIS SOFTWARE IS PROVIDED BY BLUEKITCHEN GMBH AND CONTRIBUTORS * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL MATTHIAS * RINGWALD OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * Please inquire about commercial licensing options at * contact@bluekitchen-gmbh.com * */ #define __BTSTACK_FILE__ "hid_host_tast.c" /* * hid_host_tast.c */ /* EXAMPLE_START(hid_host_tast): HID Host Demo * * @text This example implements an HID Host. For now, it connnects to a fixed device, queries the HID SDP * record and opens the HID Control + Interrupt channels */ #include #include #include "btstack_config.h" #include "btstack.h" #define MAX_ATTRIBUTE_VALUE_SIZE 300 // SDP static uint8_t hid_descriptor[MAX_ATTRIBUTE_VALUE_SIZE]; static uint16_t hid_descriptor_len; static uint16_t hid_control_psm; static uint16_t hid_interrupt_psm; static uint8_t attribute_value[MAX_ATTRIBUTE_VALUE_SIZE]; static const unsigned int attribute_value_buffer_size = MAX_ATTRIBUTE_VALUE_SIZE; // PTS static const char * remote_addr_string = "00:1B:DC:08:E2:5C"; static bd_addr_t remote_addr; static btstack_packet_callback_registration_t hci_event_callback_registration; // Needed for queries typedef enum { HID_HOST_IDLE, HID_HOST_CONTROL_CONNECTION_ESTABLISHED, HID_HOST_W4_SET_BOOT_MODE, HID_HOST_W4_INTERRUPT_CONNECTION_ESTABLISHED, HID_HOST_CONNECTION_ESTABLISHED, HID_HOST_W2_SEND_GET_REPORT, HID_HOST_W4_GET_REPORT_RESPONSE, HID_HOST_W2_SEND_SET_REPORT, HID_HOST_W4_SET_REPORT_RESPONSE, HID_HOST_W2_SEND_GET_PROTOCOL, HID_HOST_W4_GET_PROTOCOL_RESPONSE, HID_HOST_W2_SEND_SET_PROTOCOL, HID_HOST_W4_SET_PROTOCOL_RESPONSE, HID_HOST_W2_SEND_REPORT, HID_HOST_W4_SEND_REPORT_RESPONSE } hid_host_state_t; // Simplified US Keyboard with Shift modifier #define CHAR_ILLEGAL 0xff #define CHAR_RETURN '\n' #define CHAR_ESCAPE 27 #define CHAR_TAB '\t' #define CHAR_BACKSPACE 0x7f /** * English (US) */ static const uint8_t keytable_us_none [] = { CHAR_ILLEGAL, CHAR_ILLEGAL, CHAR_ILLEGAL, CHAR_ILLEGAL, /* 0-3 */ 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', /* 4-13 */ 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', /* 14-23 */ 'u', 'v', 'w', 'x', 'y', 'z', /* 24-29 */ '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', /* 30-39 */ CHAR_RETURN, CHAR_ESCAPE, CHAR_BACKSPACE, CHAR_TAB, ' ', /* 40-44 */ '-', '=', '[', ']', '\\', CHAR_ILLEGAL, ';', '\'', 0x60, ',', /* 45-54 */ '.', '/', CHAR_ILLEGAL, CHAR_ILLEGAL, CHAR_ILLEGAL, CHAR_ILLEGAL, /* 55-60 */ CHAR_ILLEGAL, CHAR_ILLEGAL, CHAR_ILLEGAL, CHAR_ILLEGAL, /* 61-64 */ CHAR_ILLEGAL, CHAR_ILLEGAL, CHAR_ILLEGAL, CHAR_ILLEGAL, /* 65-68 */ CHAR_ILLEGAL, CHAR_ILLEGAL, CHAR_ILLEGAL, CHAR_ILLEGAL, /* 69-72 */ CHAR_ILLEGAL, CHAR_ILLEGAL, CHAR_ILLEGAL, CHAR_ILLEGAL, /* 73-76 */ CHAR_ILLEGAL, CHAR_ILLEGAL, CHAR_ILLEGAL, CHAR_ILLEGAL, /* 77-80 */ CHAR_ILLEGAL, CHAR_ILLEGAL, CHAR_ILLEGAL, CHAR_ILLEGAL, /* 81-84 */ '*', '-', '+', '\n', '1', '2', '3', '4', '5', /* 85-97 */ '6', '7', '8', '9', '0', '.', 0xa7, /* 97-100 */ }; static const uint8_t keytable_us_shift[] = { CHAR_ILLEGAL, CHAR_ILLEGAL, CHAR_ILLEGAL, CHAR_ILLEGAL, /* 0-3 */ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', /* 4-13 */ 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', /* 14-23 */ 'U', 'V', 'W', 'X', 'Y', 'Z', /* 24-29 */ '!', '@', '#', '$', '%', '^', '&', '*', '(', ')', /* 30-39 */ CHAR_RETURN, CHAR_ESCAPE, CHAR_BACKSPACE, CHAR_TAB, ' ', /* 40-44 */ '_', '+', '{', '}', '|', CHAR_ILLEGAL, ':', '"', 0x7E, '<', /* 45-54 */ '>', '?', CHAR_ILLEGAL, CHAR_ILLEGAL, CHAR_ILLEGAL, CHAR_ILLEGAL, /* 55-60 */ CHAR_ILLEGAL, CHAR_ILLEGAL, CHAR_ILLEGAL, CHAR_ILLEGAL, /* 61-64 */ CHAR_ILLEGAL, CHAR_ILLEGAL, CHAR_ILLEGAL, CHAR_ILLEGAL, /* 65-68 */ CHAR_ILLEGAL, CHAR_ILLEGAL, CHAR_ILLEGAL, CHAR_ILLEGAL, /* 69-72 */ CHAR_ILLEGAL, CHAR_ILLEGAL, CHAR_ILLEGAL, CHAR_ILLEGAL, /* 73-76 */ CHAR_ILLEGAL, CHAR_ILLEGAL, CHAR_ILLEGAL, CHAR_ILLEGAL, /* 77-80 */ CHAR_ILLEGAL, CHAR_ILLEGAL, CHAR_ILLEGAL, CHAR_ILLEGAL, /* 81-84 */ '*', '-', '+', '\n', '1', '2', '3', '4', '5', /* 85-97 */ '6', '7', '8', '9', '0', '.', 0xb1, /* 97-100 */ }; // hid device state typedef struct hid_host { uint16_t cid; bd_addr_t bd_addr; hci_con_handle_t con_handle; uint16_t control_cid; uint16_t interrupt_cid; bool unplugged; // get report hid_report_type_t report_type; uint8_t report_id; // set report uint8_t * report; uint16_t report_len; // set protocol hid_protocol_mode_t protocol_mode; hid_host_state_t state; uint8_t user_request_can_send_now; } hid_host_t; static hid_host_t _hid_host; static uint16_t hid_host_cid = 0; static bool boot_mode = false; static bool send_through_interrupt_channel = false; static uint16_t hid_host_get_next_cid(void){ hid_host_cid++; if (!hid_host_cid){ hid_host_cid = 1; } return hid_host_cid; } static hid_host_t * hid_host_get_instance_for_hid_cid(uint16_t hid_cid){ if (_hid_host.cid == hid_cid){ return &_hid_host; } return NULL; } static uint8_t hid_host_send_get_report(uint16_t hid_cid, hid_report_type_t report_type, uint8_t report_id){ hid_host_t * hid_host = hid_host_get_instance_for_hid_cid(hid_cid); if (!hid_host || !hid_host->control_cid){ return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER; } if (hid_host->state != HID_HOST_CONTROL_CONNECTION_ESTABLISHED){ return ERROR_CODE_COMMAND_DISALLOWED; } hid_host->state = HID_HOST_W2_SEND_GET_REPORT; hid_host->report_type = report_type; hid_host->report_id = report_id; l2cap_request_can_send_now_event(hid_host->control_cid); return ERROR_CODE_SUCCESS; } static uint8_t hid_host_send_get_output_report(uint16_t hid_cid, uint8_t report_id){ return hid_host_send_get_report(hid_cid, HID_REPORT_TYPE_OUTPUT, report_id); } static uint8_t hid_host_send_get_feature_report(uint16_t hid_cid, uint8_t report_id){ return hid_host_send_get_report(hid_cid, HID_REPORT_TYPE_FEATURE, report_id); } static uint8_t hid_host_send_get_input_report(uint16_t hid_cid, uint8_t report_id){ return hid_host_send_get_report(hid_cid, HID_REPORT_TYPE_INPUT, report_id); } static uint8_t hid_host_send_set_report(uint16_t hid_cid, hid_report_type_t report_type, uint8_t report_id, uint8_t * report, uint8_t report_len){ hid_host_t * hid_host = hid_host_get_instance_for_hid_cid(hid_cid); if (!hid_host || !hid_host->control_cid){ return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER; } if (hid_host->state != HID_HOST_CONTROL_CONNECTION_ESTABLISHED){ return ERROR_CODE_COMMAND_DISALLOWED; } hid_host->state = HID_HOST_W2_SEND_SET_REPORT; hid_host->report_type = report_type; hid_host->report_id = report_id; hid_host->report = report; hid_host->report_len = report_len; l2cap_request_can_send_now_event(hid_host->control_cid); return ERROR_CODE_SUCCESS; } static uint8_t hid_host_send_set_output_report(uint16_t hid_cid, uint8_t report_id, uint8_t * report, uint8_t report_len){ return hid_host_send_set_report(hid_cid, HID_REPORT_TYPE_OUTPUT, report_id, report, report_len); } static uint8_t hid_host_send_set_feature_report(uint16_t hid_cid, uint8_t report_id, uint8_t * report, uint8_t report_len){ return hid_host_send_set_report(hid_cid, HID_REPORT_TYPE_FEATURE, report_id, report, report_len); } static uint8_t hid_host_send_set_input_report(uint16_t hid_cid, uint8_t report_id, uint8_t * report, uint8_t report_len){ return hid_host_send_set_report(hid_cid, HID_REPORT_TYPE_INPUT, report_id, report, report_len); } static uint8_t hid_host_send_get_protocol(uint16_t hid_cid){ hid_host_t * hid_host = hid_host_get_instance_for_hid_cid(hid_cid); if (!hid_host || !hid_host->control_cid) return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER; if (hid_host->state != HID_HOST_CONTROL_CONNECTION_ESTABLISHED) return ERROR_CODE_COMMAND_DISALLOWED; hid_host->state = HID_HOST_W2_SEND_GET_PROTOCOL; l2cap_request_can_send_now_event(hid_host->control_cid); return ERROR_CODE_SUCCESS; } static uint8_t hid_host_send_set_protocol_mode(uint16_t hid_cid, hid_protocol_mode_t protocol_mode){ hid_host_t * hid_host = hid_host_get_instance_for_hid_cid(hid_cid); if (!hid_host || !hid_host->control_cid) return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER; if (hid_host->state != HID_HOST_CONTROL_CONNECTION_ESTABLISHED){ return ERROR_CODE_COMMAND_DISALLOWED; } hid_host->state = HID_HOST_W2_SEND_SET_PROTOCOL; hid_host->protocol_mode = protocol_mode; l2cap_request_can_send_now_event(hid_host->control_cid); return ERROR_CODE_SUCCESS; } static uint8_t hid_host_send_report(uint16_t hid_cid, hid_report_type_t report_type, uint8_t report_id, uint8_t * report, uint8_t report_len){ hid_host_t * hid_host = hid_host_get_instance_for_hid_cid(hid_cid); if (!hid_host || !hid_host->control_cid){ return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER; } if (hid_host->state != HID_HOST_CONNECTION_ESTABLISHED){ return ERROR_CODE_COMMAND_DISALLOWED; } hid_host->state = HID_HOST_W2_SEND_REPORT; hid_host->report_type = report_type; hid_host->report_id = report_id; hid_host->report = report; hid_host->report_len = report_len; l2cap_request_can_send_now_event(hid_host->control_cid); return ERROR_CODE_SUCCESS; } static uint8_t hid_host_send_output_report(uint16_t hid_cid, uint8_t report_id, uint8_t * report, uint8_t report_len){ return hid_host_send_report(hid_cid, HID_REPORT_TYPE_OUTPUT, report_id, report, report_len); } static uint8_t hid_host_send_feature_report(uint16_t hid_cid, uint8_t report_id, uint8_t * report, uint8_t report_len){ return hid_host_send_report(hid_cid, HID_REPORT_TYPE_FEATURE, report_id, report, report_len); } static uint8_t hid_host_send_input_report(uint16_t hid_cid, uint8_t report_id, uint8_t * report, uint8_t report_len){ return hid_host_send_report(hid_cid, HID_REPORT_TYPE_INPUT, report_id, report, report_len); } // static void hid_host_connect(bd_addr_t addr, uint16_t * hid_cid){ // } static hid_host_t * hid_host_provide_instance_for_bd_addr(bd_addr_t bd_addr){ if (!_hid_host.cid){ (void)memcpy(_hid_host.bd_addr, bd_addr, 6); _hid_host.cid = hid_host_get_next_cid(); // _hid_host.protocol_mode = HID_PROTOCOL_MODE_REPORT; _hid_host.con_handle = HCI_CON_HANDLE_INVALID; } return &_hid_host; } static hid_host_t * hid_host_get_instance_for_l2cap_cid(uint16_t cid){ if ((_hid_host.control_cid == cid) || (_hid_host.interrupt_cid == cid)){ return &_hid_host; } return NULL; } static void hid_host_send_control_message(uint16_t hid_cid, const uint8_t * message, uint16_t message_len){ hid_host_t * hid_host = hid_host_get_instance_for_hid_cid(hid_cid); if (!hid_host || !hid_host->control_cid) return; l2cap_send(hid_host->control_cid, (uint8_t*) message, message_len); } static uint8_t hid_host_send_suspend(uint16_t hcid){ uint8_t report[] = { (HID_MESSAGE_TYPE_HID_CONTROL << 4) | HID_CONTROL_PARAM_SUSPEND }; hid_host_send_control_message(hcid, &report[0], sizeof(report)); return ERROR_CODE_SUCCESS; } static uint8_t hid_host_send_exit_suspend(uint16_t hcid){ uint8_t report[] = { (HID_MESSAGE_TYPE_HID_CONTROL << 4) | HID_CONTROL_PARAM_EXIT_SUSPEND }; hid_host_send_control_message(hcid, &report[0], sizeof(report)); return ERROR_CODE_SUCCESS; } static uint8_t hid_host_send_virtual_cable_unplug(uint16_t hcid){ uint8_t report[] = { (HID_MESSAGE_TYPE_HID_CONTROL << 4) | HID_CONTROL_PARAM_VIRTUAL_CABLE_UNPLUG }; hid_host_send_control_message(hcid, &report[0], sizeof(report)); return ERROR_CODE_SUCCESS; } static void hid_host_disconnect_interrupt_channel(uint16_t hid_cid){ hid_host_t * hid_host = hid_host_get_instance_for_hid_cid(hid_cid); if (!hid_host){ log_error("hid_host_disconnect_interrupt_channel: could not find hid device instace"); return; } log_info("Disconnect from interrupt channel HID Host"); if (hid_host->interrupt_cid){ l2cap_disconnect(hid_host->interrupt_cid, 0); // reason isn't used } } static void hid_host_disconnect_control_channel(uint16_t hid_cid){ hid_host_t * hid_host = hid_host_get_instance_for_hid_cid(hid_cid); if (!hid_host){ log_error("hid_host_disconnect_control_channel: could not find hid device instace"); return; } log_info("Disconnect from control channel HID Host"); if (hid_host->control_cid){ l2cap_disconnect(hid_host->control_cid, 0); // reason isn't used } } static void hid_host_disconnect(uint16_t hid_cid){ hid_host_t * hid_host = hid_host_get_instance_for_hid_cid(hid_cid); if (!hid_host){ log_error("hid_host_disconnect: could not find hid device instace"); return; } log_info("Disconnect from HID Host"); if (hid_host->interrupt_cid){ l2cap_disconnect(hid_host->interrupt_cid, 0); // reason isn't used } if (hid_host->control_cid){ l2cap_disconnect(hid_host->control_cid, 0); // reason isn't used } } /* @section Main application configuration * * @text In the application configuration, L2CAP is initialized */ /* LISTING_START(PanuSetup): Panu setup */ static void packet_handler (uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size); static void handle_sdp_client_query_result(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size); static void hid_host_setup(void){ // Initialize L2CAP l2cap_init(); // register L2CAP Services for reconnections l2cap_register_service(packet_handler, PSM_HID_INTERRUPT, 0xffff, gap_get_security_level()); l2cap_register_service(packet_handler, PSM_HID_CONTROL, 0xffff, gap_get_security_level()); // Allow sniff mode requests by HID device and support role switch gap_set_default_link_policy_settings(LM_LINK_POLICY_ENABLE_SNIFF_MODE | LM_LINK_POLICY_ENABLE_ROLE_SWITCH); // try to become master on incoming connections hci_set_master_slave_policy(HCI_ROLE_MASTER); // register for HCI events hci_event_callback_registration.callback = &packet_handler; hci_add_event_handler(&hci_event_callback_registration); // Disable stdout buffering setbuf(stdout, NULL); } /* LISTING_END */ /* @section SDP parser callback * * @text The SDP parsers retrieves the BNEP PAN UUID as explained in * Section [on SDP BNEP Query example](#sec:sdpbnepqueryExample}. */ static void handle_sdp_client_query_result(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size) { UNUSED(packet_type); UNUSED(channel); UNUSED(size); des_iterator_t attribute_list_it; des_iterator_t additional_des_it; des_iterator_t prot_it; uint8_t *des_element; uint8_t *element; uint32_t uuid; uint8_t status; switch (hci_event_packet_get_type(packet)){ case SDP_EVENT_QUERY_ATTRIBUTE_VALUE: if (sdp_event_query_attribute_byte_get_attribute_length(packet) <= attribute_value_buffer_size) { attribute_value[sdp_event_query_attribute_byte_get_data_offset(packet)] = sdp_event_query_attribute_byte_get_data(packet); if ((uint16_t)(sdp_event_query_attribute_byte_get_data_offset(packet)+1) == sdp_event_query_attribute_byte_get_attribute_length(packet)) { switch(sdp_event_query_attribute_byte_get_attribute_id(packet)) { case BLUETOOTH_ATTRIBUTE_PROTOCOL_DESCRIPTOR_LIST: for (des_iterator_init(&attribute_list_it, attribute_value); des_iterator_has_more(&attribute_list_it); des_iterator_next(&attribute_list_it)) { if (des_iterator_get_type(&attribute_list_it) != DE_DES) continue; des_element = des_iterator_get_element(&attribute_list_it); des_iterator_init(&prot_it, des_element); element = des_iterator_get_element(&prot_it); if (de_get_element_type(element) != DE_UUID) continue; uuid = de_get_uuid32(element); switch (uuid){ case BLUETOOTH_PROTOCOL_L2CAP: if (!des_iterator_has_more(&prot_it)) continue; des_iterator_next(&prot_it); de_element_get_uint16(des_iterator_get_element(&prot_it), &hid_control_psm); printf("HID Control PSM: 0x%04x\n", (int) hid_control_psm); break; default: break; } } break; case BLUETOOTH_ATTRIBUTE_ADDITIONAL_PROTOCOL_DESCRIPTOR_LISTS: for (des_iterator_init(&attribute_list_it, attribute_value); des_iterator_has_more(&attribute_list_it); des_iterator_next(&attribute_list_it)) { if (des_iterator_get_type(&attribute_list_it) != DE_DES) continue; des_element = des_iterator_get_element(&attribute_list_it); for (des_iterator_init(&additional_des_it, des_element); des_iterator_has_more(&additional_des_it); des_iterator_next(&additional_des_it)) { if (des_iterator_get_type(&additional_des_it) != DE_DES) continue; des_element = des_iterator_get_element(&additional_des_it); des_iterator_init(&prot_it, des_element); element = des_iterator_get_element(&prot_it); if (de_get_element_type(element) != DE_UUID) continue; uuid = de_get_uuid32(element); switch (uuid){ case BLUETOOTH_PROTOCOL_L2CAP: if (!des_iterator_has_more(&prot_it)) continue; des_iterator_next(&prot_it); de_element_get_uint16(des_iterator_get_element(&prot_it), &hid_interrupt_psm); printf("HID Interrupt PSM: 0x%04x\n", (int) hid_interrupt_psm); break; default: break; } } } break; case BLUETOOTH_ATTRIBUTE_HID_DESCRIPTOR_LIST: for (des_iterator_init(&attribute_list_it, attribute_value); des_iterator_has_more(&attribute_list_it); des_iterator_next(&attribute_list_it)) { if (des_iterator_get_type(&attribute_list_it) != DE_DES) continue; des_element = des_iterator_get_element(&attribute_list_it); for (des_iterator_init(&additional_des_it, des_element); des_iterator_has_more(&additional_des_it); des_iterator_next(&additional_des_it)) { if (des_iterator_get_type(&additional_des_it) != DE_STRING) continue; element = des_iterator_get_element(&additional_des_it); const uint8_t * descriptor = de_get_string(element); hid_descriptor_len = de_get_data_size(element); memcpy(hid_descriptor, descriptor, hid_descriptor_len); printf("HID Descriptor:\n"); printf_hexdump(hid_descriptor, hid_descriptor_len); } } break; default: break; } } } else { fprintf(stderr, "SDP attribute value buffer size exceeded: available %d, required %d\n", attribute_value_buffer_size, sdp_event_query_attribute_byte_get_attribute_length(packet)); } break; case SDP_EVENT_QUERY_COMPLETE: if (!hid_control_psm) { printf("HID Control PSM missing\n"); break; } if (!hid_interrupt_psm) { printf("HID Interrupt PSM missing\n"); break; } printf("Setup HID\n"); (void)memcpy(_hid_host.bd_addr, remote_addr, 6); status = l2cap_create_channel(packet_handler, remote_addr, hid_control_psm, 48, &_hid_host.control_cid); if (status){ printf("Connecting to HID Control failed: 0x%02x\n", status); } break; } } /* * @section HID Report Handler * * @text Use BTstack's compact HID Parser to process incoming HID Report * Iterate over all fields and process fields with usage page = 0x07 / Keyboard * Check if SHIFT is down and process first character (don't handle multiple key presses) * */ #define NUM_KEYS 6 static uint8_t last_keys[NUM_KEYS]; static void hid_host_handle_interrupt_report(const uint8_t * report, uint16_t report_len){ // check if HID Input Report if (report_len < 1) return; if (*report != 0xa1) return; report++; report_len--; btstack_hid_parser_t parser; btstack_hid_parser_init(&parser, hid_descriptor, hid_descriptor_len, HID_REPORT_TYPE_INPUT, report, report_len); int shift = 0; uint8_t new_keys[NUM_KEYS]; memset(new_keys, 0, sizeof(new_keys)); int new_keys_count = 0; while (btstack_hid_parser_has_more(&parser)){ uint16_t usage_page; uint16_t usage; int32_t value; btstack_hid_parser_get_field(&parser, &usage_page, &usage, &value); if (usage_page != 0x07) continue; switch (usage){ case 0xe1: case 0xe6: if (value){ shift = 1; } continue; case 0x00: continue; default: break; } if (usage >= sizeof(keytable_us_none)) continue; // store new keys new_keys[new_keys_count++] = usage; // check if usage was used last time (and ignore in that case) int i; for (i=0;iunplugged) { log_info("L2CAP_EVENT_INCOMING_CONNECTION, decline connection for %s, host is unplugged", bd_addr_to_str(address)); l2cap_decline_connection(channel); break; } if ((hid_host->con_handle == HCI_CON_HANDLE_INVALID) || (l2cap_event_incoming_connection_get_handle(packet) == hid_host->con_handle)){ hid_host->con_handle = l2cap_event_incoming_connection_get_handle(packet); // hid_host->incoming = 1; l2cap_event_incoming_connection_get_address(packet, hid_host->bd_addr); switch (l2cap_event_incoming_connection_get_psm(packet)){ case PSM_HID_CONTROL: hid_host->control_cid = l2cap_event_incoming_connection_get_local_cid(packet); break; case PSM_HID_INTERRUPT: hid_host->interrupt_cid = l2cap_event_incoming_connection_get_local_cid(packet); break; default: break; } printf("L2CAP_EVENT_INCOMING_CONNECTION l2cap_accept_connection\n"); l2cap_accept_connection(channel); } else { l2cap_decline_connection(channel); log_info("L2CAP_EVENT_INCOMING_CONNECTION, decline connection for %s", bd_addr_to_str(address)); } break; default: log_info("L2CAP_EVENT_INCOMING_CONNECTION, decline connection for %s", bd_addr_to_str(address)); l2cap_decline_connection(channel); break; } break; case L2CAP_EVENT_CHANNEL_OPENED: status = l2cap_event_channel_opened_get_status(packet); if (status){ printf("L2CAP Connection failed: 0x%02x\n", status); break; } l2cap_cid = l2cap_event_channel_opened_get_local_cid(packet); if (!l2cap_cid) break; hid_host = hid_host_get_instance_for_l2cap_cid(l2cap_cid); if (!hid_host) { log_error("L2CAP_EVENT_CHANNEL_OPENED, cannot find instance for %s", bd_addr_to_str(address)); break; } switch (l2cap_event_channel_opened_get_psm(packet)){ case PSM_HID_CONTROL: printf("Control channel opened 0x%2x == 0x%2x\n", l2cap_cid, hid_host->control_cid); if (l2cap_cid == hid_host->control_cid){ hid_host->state = HID_HOST_CONTROL_CONNECTION_ESTABLISHED; if (boot_mode){ // status = hid_host_send_set_protocol_mode(hid_host->cid, HID_PROTOCOL_MODE_BOOT); // if (status){ // printf("Boot mode failed: 0x%02x\n", status); // hid_host->state = HID_HOST_CONTROL_CONNECTION_ESTABLISHED; // break; // } printf("Boot mode L2CAP_EVENT_CHANNEL_OPENED\n"); break; } status = l2cap_create_channel(packet_handler, remote_addr, hid_interrupt_psm, 48, &hid_host->interrupt_cid); if (status){ printf("Connecting to HID Control failed: 0x%02x\n", status); hid_host->state = HID_HOST_CONTROL_CONNECTION_ESTABLISHED; break; } _hid_host.state = HID_HOST_CONTROL_CONNECTION_ESTABLISHED; } break; case PSM_HID_INTERRUPT: printf("Interupt channel opened 0x%2x == 0x%2x\n", l2cap_cid, hid_host->interrupt_cid); if (l2cap_cid == hid_host->interrupt_cid){ // if (hid_host->state == HID_HOST_W4_INTERRUPT_CONNECTION_ESTABLISHED){ hid_host->state = HID_HOST_CONNECTION_ESTABLISHED; printf("HID Connection established\n"); // } } break; default: break; } // disconnect? break; case L2CAP_EVENT_CHANNEL_CLOSED: l2cap_cid = l2cap_event_channel_closed_get_local_cid(packet); hid_host = hid_host_get_instance_for_l2cap_cid(l2cap_cid); if (!hid_host) return; if (l2cap_cid == hid_host->interrupt_cid){ hid_host->interrupt_cid = 0; } if (l2cap_cid == hid_host->control_cid){ hid_host->control_cid = 0; } if (!hid_host->interrupt_cid && !hid_host->control_cid){ // hid_host->connected = 0; hid_host->con_handle = HCI_CON_HANDLE_INVALID; hid_host->cid = 0; // hid_host_emit_event(device, HID_SUBEVENT_CONNECTION_CLOSED); } break; case L2CAP_EVENT_CAN_SEND_NOW: l2cap_cid = l2cap_event_can_send_now_get_local_cid(packet); hid_host = hid_host_get_instance_for_l2cap_cid(l2cap_cid); if (!hid_host) return; printf("L2CAP_EVENT_CAN_SEND_NOW, hid_host.state = %d\n", hid_host->state); switch(hid_host->state){ case HID_HOST_W2_SEND_GET_REPORT:{ uint8_t header = (HID_MESSAGE_TYPE_GET_REPORT << 4) | hid_host->report_type; uint8_t report[] = {header, hid_host->report_id}; // TODO: optional Report ID (1) // TODO: optional Maximum number of bytes to transfer during data phase, little end. (2) hid_host->state = HID_HOST_W4_GET_REPORT_RESPONSE; l2cap_send(hid_host->control_cid, (uint8_t*) report, sizeof(report)); break; } case HID_HOST_W2_SEND_SET_REPORT:{ uint8_t header = (HID_MESSAGE_TYPE_SET_REPORT << 4) | hid_host->report_type; hid_host->state = HID_HOST_W4_SET_REPORT_RESPONSE; l2cap_reserve_packet_buffer(); uint8_t * out_buffer = l2cap_get_outgoing_buffer(); out_buffer[0] = header; out_buffer[1] = hid_host->report_id; (void)memcpy(out_buffer + 2, hid_host->report, hid_host->report_len); if (boot_mode){ l2cap_send_prepared(hid_host->interrupt_cid, hid_host->report_len + 2); } else { l2cap_send_prepared(hid_host->control_cid, hid_host->report_len + 2); } break; } case HID_HOST_W2_SEND_GET_PROTOCOL:{ uint8_t header = (HID_MESSAGE_TYPE_GET_PROTOCOL << 4); uint8_t report[] = {header}; hid_host->state = HID_HOST_W4_GET_PROTOCOL_RESPONSE; l2cap_send(hid_host->control_cid, (uint8_t*) report, sizeof(report)); break; } case HID_HOST_W2_SEND_SET_PROTOCOL:{ uint8_t header = (HID_MESSAGE_TYPE_SET_PROTOCOL << 4) | hid_host->protocol_mode; uint8_t report[] = {header}; hid_host->state = HID_HOST_W4_SET_PROTOCOL_RESPONSE; l2cap_send(hid_host->control_cid, (uint8_t*) report, sizeof(report)); break; } case HID_HOST_W2_SEND_REPORT:{ hid_host->state = HID_HOST_W4_SEND_REPORT_RESPONSE; uint8_t header = (HID_MESSAGE_TYPE_DATA << 4) | hid_host->report_type; l2cap_reserve_packet_buffer(); uint8_t * out_buffer = l2cap_get_outgoing_buffer(); out_buffer[0] = header; out_buffer[1] = hid_host->report_id; (void)memcpy(out_buffer + 2, hid_host->report, hid_host->report_len); l2cap_send_prepared(hid_host->interrupt_cid, hid_host->report_len + 2); } default: break; } default: break; } break; case L2CAP_DATA_PACKET: if (channel == _hid_host.interrupt_cid){ printf("HID Interrupt data: \n"); printf_hexdump(packet, size); hid_host_handle_interrupt_report(packet, size); break; } if (channel != _hid_host.control_cid) break; hid_host = hid_host_get_instance_for_l2cap_cid(channel); if (!hid_host) { log_error("no host with cid 0x%02x", channel); return; } message_type = (hid_message_type_t)(packet[0] >> 4); message_status = (hid_handshake_param_type_t)(packet[0] & 0x0F); printf("HID Control data, message_type 0x%02x, status 0x%02x: \n", message_type, message_status); printf_hexdump(packet, size); // TODO handle handshake message_status switch (message_type){ case HID_MESSAGE_TYPE_DATA: switch (hid_host->state){ case HID_HOST_W4_GET_REPORT_RESPONSE: printf("HID_HOST_W4_GET_REPORT_RESPONSE \n"); break; case HID_HOST_W4_SET_REPORT_RESPONSE: printf("HID_HOST_W4_SET_REPORT_RESPONSE \n"); break; case HID_HOST_W4_GET_PROTOCOL_RESPONSE: printf("HID_HOST_W4_GET_PROTOCOL_RESPONSE \n"); break; case HID_HOST_W4_SEND_REPORT_RESPONSE: printf("HID_HOST_W4_SEND_REPORT_RESPONSE\n"); break; case HID_HOST_W4_SET_PROTOCOL_RESPONSE: printf("HID_HOST_W4_SET_PROTOCOL_RESPONSE \n"); switch (message_status){ case HID_HANDSHAKE_PARAM_TYPE_SUCCESSFUL: switch(hid_host->protocol_mode){ case HID_PROTOCOL_MODE_BOOT:{ status = l2cap_create_channel(packet_handler, remote_addr, hid_interrupt_psm, 48, &hid_host->interrupt_cid); if (status){ printf("Connecting to HID Control failed: 0x%02x\n", status); hid_host->state = HID_HOST_CONTROL_CONNECTION_ESTABLISHED; break; } hid_host->state = HID_HOST_W4_INTERRUPT_CONNECTION_ESTABLISHED; break; } case HID_PROTOCOL_MODE_REPORT: break; default: break; } default: break; } break; default: printf("HID_MESSAGE_TYPE_DATA ???\n"); break; } hid_host->state = HID_HOST_CONTROL_CONNECTION_ESTABLISHED; break; case HID_MESSAGE_TYPE_HID_CONTROL: param = packet[0] & 0x0F; switch ((hid_control_param_t)param){ case HID_CONTROL_PARAM_VIRTUAL_CABLE_UNPLUG: // hid_host_emit_event(device, HID_SUBEVENT_VIRTUAL_CABLE_UNPLUG); hid_host->unplugged = true; break; default: break; } break; default: break; } default: break; } } /* LISTING_END */ static void show_usage(void){ bd_addr_t iut_address; gap_local_bd_addr(iut_address); printf("\n--- Bluetooth HID Host Test Console %s ---\n", bd_addr_to_str(iut_address)); printf("c - start SDP scan and connect"); printf("o - get output report\n"); printf("Ctrl-c - exit\n"); printf("---\n"); } static void stdin_process(char cmd){ uint8_t status = ERROR_CODE_SUCCESS; switch (cmd){ case 'a': printf("Start SDP HID query for remote HID Device.\n"); sdp_client_query_uuid16(&handle_sdp_client_query_result, remote_addr, BLUETOOTH_SERVICE_CLASS_HUMAN_INTERFACE_DEVICE_SERVICE); break; case 'c': if (_hid_host.unplugged){ printf("Cannot reconnect, host is unplugged.\n"); break; } printf("Reconnect, control PSM.\n"); status = l2cap_create_channel(packet_handler, remote_addr, BLUETOOTH_PSM_HID_CONTROL, 48, &_hid_host.control_cid); if (status){ printf("Connecting to HID Control failed: 0x%02x\n", status); } break; case 'i': if (_hid_host.unplugged){ printf("Cannot reconnect, host is unplugged.\n"); break; } printf("Reconnect, interrupt PSM.\n"); status = l2cap_create_channel(packet_handler, remote_addr, BLUETOOTH_PSM_HID_INTERRUPT, 48, &_hid_host.interrupt_cid); if (status){ printf("Connecting to HID Control failed: 0x%02x\n", status); } break; case 'I': printf("Disconnect from interrupt channel %s...\n", bd_addr_to_str(remote_addr)); hid_host_disconnect_interrupt_channel(_hid_host.cid); break; case 'C': printf("Disconnect from control channel %s...\n", bd_addr_to_str(remote_addr)); hid_host_disconnect_control_channel(_hid_host.cid); break; case 's': printf("Send \'Suspend\'\n"); hid_host_send_suspend(_hid_host.cid); break; case 'S': printf("Send \'Exit suspend\'\n"); hid_host_send_exit_suspend(_hid_host.cid); break; case 'u': printf("Send \'Unplug\'\n"); _hid_host.unplugged = true; hid_host_send_virtual_cable_unplug(_hid_host.cid); break; case '1': printf("Get feature report with id 0x03 from %s\n", remote_addr_string); status = hid_host_send_get_feature_report(_hid_host.cid, 0x03); break; case '2': printf("Get output report with id 0x05 from %s\n", remote_addr_string); status = hid_host_send_get_output_report(_hid_host.cid, 0x05); break; case '3': printf("Get input report from with id 0x02 %s\n", remote_addr_string); status = hid_host_send_get_input_report(_hid_host.cid, 0x02); break; case '4':{ uint8_t report[] = {0, 0}; printf("Set output report with id 0x03\n"); status = hid_host_send_set_output_report(_hid_host.cid, 0x03, report, sizeof(report)); break; } case '5':{ uint8_t report[] = {0, 0, 0}; printf("Set feature report with id 0x05\n"); status = hid_host_send_set_feature_report(_hid_host.cid, 0x05, report, sizeof(report)); break; } case '6':{ uint8_t report[] = {0, 0, 0, 0}; printf("Set input report with id 0x02\n"); status = hid_host_send_set_input_report(_hid_host.cid, 0x02, report, sizeof(report)); break; } case '7':{ uint8_t report[] = {0,0,0, 0,0,0, 0,0}; printf("Set output report with id 0x01\n"); status = hid_host_send_set_output_report(_hid_host.cid, 0x01, report, sizeof(report)); break; } case 'p': printf("Get Protocol\n"); status = hid_host_send_get_protocol(_hid_host.cid); break; case 'R': printf("Set Protocol mode\n"); boot_mode = false; status = hid_host_send_set_protocol_mode(_hid_host.cid, HID_PROTOCOL_MODE_REPORT); break; case 'b': printf("Set Boot mode\n"); boot_mode = false; status = hid_host_send_set_protocol_mode(_hid_host.cid, HID_PROTOCOL_MODE_BOOT); break; case 'B': printf("Set Boot mode\n"); boot_mode = true; break; case 'X': printf("Set send through interrupt channel\n"); send_through_interrupt_channel = true; break; case 'x': printf("Set send through control channel\n"); send_through_interrupt_channel = true; break; case '8':{ uint8_t report[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; printf("Send output report with id 0x03\n"); status = hid_host_send_output_report(_hid_host.cid, 0x03, report, sizeof(report)); break; } case '9':{ uint8_t report[] = {0, 0, 0, 0, 0, 0, 0, 0}; printf("Set output report with id 0x01\n"); status = hid_host_send_set_output_report(_hid_host.cid, 0x01, report, sizeof(report)); break; } case '0':{ uint8_t report[] = {0, 0, 0, 0, 0, 0, 0, 0}; printf("Send output report with id 0x01\n"); status = hid_host_send_output_report(_hid_host.cid, 0x01, report, sizeof(report)); break; } case '\n': case '\r': break; default: show_usage(); break; } if (status != ERROR_CODE_SUCCESS){ printf("HID host cmd \'%c\' failed, status 0x%02x\n", cmd, status); } } int btstack_main(int argc, const char * argv[]); int btstack_main(int argc, const char * argv[]){ (void)argc; (void)argv; hid_host_setup(); // parse human readable Bluetooth address sscanf_bd_addr(remote_addr_string, remote_addr); btstack_stdin_setup(stdin_process); // Turn on the device hci_power_control(HCI_POWER_ON); return 0; } /* EXAMPLE_END */