/* * Copyright (c) 2010 Vojtech Horky * Copyright (c) 2011 Lubos Slovak * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - 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. * - The name of the author may not be used to endorse or promote products * derived from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 THE AUTHOR 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. */ /** @addtogroup drvusbhid * @{ */ /** * @file * Main routines of USB HID driver. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "hid.h" #include "descparser.h" #include "descdump.h" #include "conv.h" #include "layout.h" #define BUFFER_SIZE 8 #define NAME "usbhid" #define GUESSED_POLL_ENDPOINT 1 #define BOOTP_REPORT_SIZE 6 /** Keyboard polling endpoint description for boot protocol class. */ static usb_endpoint_description_t poll_endpoint_description = { .transfer_type = USB_TRANSFER_INTERRUPT, .direction = USB_DIRECTION_IN, .interface_class = USB_CLASS_HID, .interface_subclass = USB_HID_SUBCLASS_BOOT, .interface_protocol = USB_HID_PROTOCOL_KEYBOARD, .flags = 0 }; static void default_connection_handler(ddf_fun_t *, ipc_callid_t, ipc_call_t *); static ddf_dev_ops_t keyboard_ops = { .default_handler = default_connection_handler }; static int console_callback_phone = -1; /** Default handler for IPC methods not handled by DDF. * * @param dev Device handling the call. * @param icallid Call id. * @param icall Call data. */ void default_connection_handler(ddf_fun_t *fun, ipc_callid_t icallid, ipc_call_t *icall) { sysarg_t method = IPC_GET_IMETHOD(*icall); if (method == IPC_M_CONNECT_TO_ME) { int callback = IPC_GET_ARG5(*icall); if (console_callback_phone != -1) { async_answer_0(icallid, ELIMIT); return; } console_callback_phone = callback; async_answer_0(icallid, EOK); return; } async_answer_0(icallid, EINVAL); } #if 0 static void send_key(int key, int type, wchar_t c) { async_msg_4(console_callback_phone, KBD_EVENT, type, key, KM_NUM_LOCK, c); } #endif /* * TODO: Move somewhere else */ /* #define BYTES_PER_LINE 12 static void dump_buffer(const char *msg, const uint8_t *buffer, size_t length) { printf("%s\n", msg); size_t i; for (i = 0; i < length; i++) { printf(" 0x%02X", buffer[i]); if (((i > 0) && (((i+1) % BYTES_PER_LINE) == 0)) || (i + 1 == length)) { printf("\n"); } } } */ /* * Copy-paste from srv/hid/kbd/generic/kbd.c */ /** Currently active modifiers. * * TODO: put to device? */ static unsigned mods = KM_NUM_LOCK; /** Currently pressed lock keys. We track these to tackle autorepeat. * * TODO: put to device? */ static unsigned lock_keys; #define NUM_LAYOUTS 3 static layout_op_t *layout[NUM_LAYOUTS] = { &us_qwerty_op, &us_dvorak_op, &cz_op }; static int active_layout = 0; static void kbd_push_ev(int type, unsigned int key) { console_event_t ev; unsigned mod_mask; // TODO: replace by our own parsing?? or are the key codes identical?? switch (key) { case KC_LCTRL: mod_mask = KM_LCTRL; break; case KC_RCTRL: mod_mask = KM_RCTRL; break; case KC_LSHIFT: mod_mask = KM_LSHIFT; break; case KC_RSHIFT: mod_mask = KM_RSHIFT; break; case KC_LALT: mod_mask = KM_LALT; break; case KC_RALT: mod_mask = KM_RALT; break; default: mod_mask = 0; break; } if (mod_mask != 0) { if (type == KEY_PRESS) mods = mods | mod_mask; else mods = mods & ~mod_mask; } switch (key) { case KC_CAPS_LOCK: mod_mask = KM_CAPS_LOCK; break; case KC_NUM_LOCK: mod_mask = KM_NUM_LOCK; break; case KC_SCROLL_LOCK: mod_mask = KM_SCROLL_LOCK; break; default: mod_mask = 0; break; } if (mod_mask != 0) { if (type == KEY_PRESS) { /* * Only change lock state on transition from released * to pressed. This prevents autorepeat from messing * up the lock state. */ mods = mods ^ (mod_mask & ~lock_keys); lock_keys = lock_keys | mod_mask; /* Update keyboard lock indicator lights. */ // TODO //kbd_ctl_set_ind(mods); } else { lock_keys = lock_keys & ~mod_mask; } } /* usb_log_debug2("type: %d\n", type); usb_log_debug2("mods: 0x%x\n", mods); usb_log_debug2("keycode: %u\n", key); */ if (type == KEY_PRESS && (mods & KM_LCTRL) && key == KC_F1) { active_layout = 0; layout[active_layout]->reset(); return; } if (type == KEY_PRESS && (mods & KM_LCTRL) && key == KC_F2) { active_layout = 1; layout[active_layout]->reset(); return; } if (type == KEY_PRESS && (mods & KM_LCTRL) && key == KC_F3) { active_layout = 2; layout[active_layout]->reset(); return; } ev.type = type; ev.key = key; ev.mods = mods; ev.c = layout[active_layout]->parse_ev(&ev); usb_log_debug("Sending key %d to the console\n", ev.key); assert(console_callback_phone != -1); async_msg_4(console_callback_phone, KBD_EVENT, ev.type, ev.key, ev.mods, ev.c); } /* * End of copy-paste */ /* * TODO: * 1) key press / key release - how does the keyboard notify about * release? * 2) layouts (use the already defined), not important now * 3) */ static const keycode_t usb_hid_modifiers_boot_keycodes[5] = { KC_NUM_LOCK, /* USB_HID_MOD_BOOT_NUM_LOCK */ KC_CAPS_LOCK, /* USB_HID_MOD_BOOT_CAPS_LOCK */ KC_SCROLL_LOCK, /* USB_HID_MOD_BOOT_SCROLL_LOCK */ 0, /* USB_HID_MOD_BOOT_COMPOSE */ 0 /* USB_HID_MOD_BOOT_KANA */ }; static void usbkbd_check_modifier_changes(usb_hid_dev_kbd_t *kbd_dev, uint8_t modifiers) { /* * TODO: why the USB keyboard has NUM_, SCROLL_ and CAPS_LOCK * both as modifiers and as keys with their own scancodes??? * * modifiers should be sent as normal keys to usbkbd_parse_scancode()!! * so maybe it would be better if I received it from report parser in * that way */ int i; for (i = 0; i < USB_HID_MOD_BOOT_COUNT; ++i) { if ((modifiers & usb_hid_modifiers_boot_consts[i]) && !(kbd_dev->modifiers & usb_hid_modifiers_boot_consts[i])) { // modifier pressed if (usb_hid_modifiers_boot_keycodes[i] != 0) { kbd_push_ev(KEY_PRESS, usb_hid_modifiers_boot_keycodes[i]); } } else if (!(modifiers & usb_hid_modifiers_boot_consts[i]) && (kbd_dev->modifiers & usb_hid_modifiers_boot_consts[i])) { // modifier released if (usb_hid_modifiers_boot_keycodes[i] != 0) { kbd_push_ev(KEY_RELEASE, usb_hid_modifiers_boot_keycodes[i]); } } // no change } } static void usbkbd_check_key_changes(usb_hid_dev_kbd_t *kbd_dev, const uint8_t *key_codes) { // TODO: phantom state!! unsigned int key; unsigned int i, j; // TODO: quite dummy right now, think of better implementation // key releases for (j = 0; j < kbd_dev->keycode_count; ++j) { // try to find the old key in the new key list i = 0; while (i < kbd_dev->keycode_count && key_codes[i] != kbd_dev->keycodes[j]) { ++j; } if (j == kbd_dev->keycode_count) { // not found, i.e. the key was released key = usbkbd_parse_scancode(kbd_dev->keycodes[j]); kbd_push_ev(KEY_RELEASE, key); } else { // found, nothing happens } } // key presses for (i = 0; i < kbd_dev->keycode_count; ++i) { // try to find the new key in the old key list j = 0; while (j < kbd_dev->keycode_count && kbd_dev->keycodes[j] != key_codes[i]) { ++j; } assert(kbd_dev->keycode_count <= kbd_dev->keycode_count); if (j == kbd_dev->keycode_count) { // not found, i.e. new key pressed key = usbkbd_parse_scancode(key_codes[i]); kbd_push_ev(KEY_PRESS, key); } else { // found, nothing happens } } } /* * Callbacks for parser */ static void usbkbd_process_keycodes(const uint8_t *key_codes, size_t count, uint8_t modifiers, void *arg) { if (arg == NULL) { usb_log_warning("Missing argument in callback " "usbkbd_process_keycodes().\n"); return; } usb_log_debug2("Got keys from parser: "); unsigned i; for (i = 0; i < count; ++i) { usb_log_debug2("%d ", key_codes[i]); } usb_log_debug2("\n"); usb_hid_dev_kbd_t *kbd_dev = (usb_hid_dev_kbd_t *)arg; if (count != kbd_dev->keycode_count) { usb_log_warning("Number of received keycodes (%d) differs from" " expected number (%d).\n", count, kbd_dev->keycode_count); return; } usbkbd_check_modifier_changes(kbd_dev, modifiers); usbkbd_check_key_changes(kbd_dev, key_codes); } /* * Kbd functions */ static int usbkbd_get_report_descriptor(usb_hid_dev_kbd_t *kbd_dev) { // iterate over all configurations and interfaces // TODO: more configurations!! unsigned i; for (i = 0; i < kbd_dev->conf->config_descriptor.interface_count; ++i) { // TODO: endianness uint16_t length = kbd_dev->conf->interfaces[i].hid_desc. report_desc_info.length; size_t actual_size = 0; // allocate space for the report descriptor kbd_dev->conf->interfaces[i].report_desc = (uint8_t *)malloc(length); // get the descriptor from the device int rc = usb_request_get_descriptor(&kbd_dev->ctrl_pipe, USB_REQUEST_TYPE_CLASS, USB_DESCTYPE_HID_REPORT, i, 0, kbd_dev->conf->interfaces[i].report_desc, length, &actual_size); if (rc != EOK) { return rc; } assert(actual_size == length); //dump_hid_class_descriptor(0, USB_DESCTYPE_HID_REPORT, // kbd_dev->conf->interfaces[i].report_desc, length); } return EOK; } static int usbkbd_process_descriptors(usb_hid_dev_kbd_t *kbd_dev) { // get the first configuration descriptor (TODO: parse also other!) usb_standard_configuration_descriptor_t config_desc; int rc; rc = usb_request_get_bare_configuration_descriptor(&kbd_dev->ctrl_pipe, 0, &config_desc); if (rc != EOK) { return rc; } // prepare space for all underlying descriptors uint8_t *descriptors = (uint8_t *)malloc(config_desc.total_length); if (descriptors == NULL) { return ENOMEM; } size_t transferred = 0; // get full configuration descriptor rc = usb_request_get_full_configuration_descriptor(&kbd_dev->ctrl_pipe, 0, descriptors, config_desc.total_length, &transferred); if (rc != EOK) { return rc; } if (transferred != config_desc.total_length) { return ELIMIT; } /* * Initialize the interrupt in endpoint. */ usb_endpoint_mapping_t endpoint_mapping[1] = { { .pipe = &kbd_dev->poll_pipe, .description = &poll_endpoint_description, .interface_no = usb_device_get_assigned_interface(kbd_dev->device) } }; rc = usb_endpoint_pipe_initialize_from_configuration( endpoint_mapping, 1, descriptors, config_desc.total_length, &kbd_dev->wire); if (rc != EOK) { usb_log_error("Failed to initialize poll pipe: %s.\n", str_error(rc)); return rc; } if (!endpoint_mapping[0].present) { usb_log_warning("Not accepting device, " \ "not boot-protocol keyboard.\n"); return EREFUSED; } kbd_dev->conf = (usb_hid_configuration_t *)calloc(1, sizeof(usb_hid_configuration_t)); if (kbd_dev->conf == NULL) { free(descriptors); return ENOMEM; } /*rc = usbkbd_parse_descriptors(descriptors, transferred, kbd_dev->conf); free(descriptors); if (rc != EOK) { usb_log_warning("Problem with parsing standard descriptors.\n"); return rc; } // get and report descriptors*/ rc = usbkbd_get_report_descriptor(kbd_dev); if (rc != EOK) { usb_log_warning("Problem with parsing REPORT descriptor.\n"); return rc; } //usbkbd_print_config(kbd_dev->conf); /* * TODO: * 1) select one configuration (lets say the first) * 2) how many interfaces?? how to select one?? * ("The default setting for an interface is always alternate * setting zero.") * 3) find endpoint which is IN and INTERRUPT (parse), save its number * as the endpoint for polling */ return EOK; } static usb_hid_dev_kbd_t *usbkbd_init_device(ddf_dev_t *dev) { int rc; usb_hid_dev_kbd_t *kbd_dev = (usb_hid_dev_kbd_t *)calloc(1, sizeof(usb_hid_dev_kbd_t)); if (kbd_dev == NULL) { usb_log_fatal("No memory!\n"); return NULL; } kbd_dev->device = dev; /* * Initialize the backing connection to the host controller. */ rc = usb_device_connection_initialize_from_device(&kbd_dev->wire, dev); if (rc != EOK) { printf("Problem initializing connection to device: %s.\n", str_error(rc)); goto error_leave; } /* * Initialize device pipes. */ rc = usb_endpoint_pipe_initialize_default_control(&kbd_dev->ctrl_pipe, &kbd_dev->wire); if (rc != EOK) { printf("Failed to initialize default control pipe: %s.\n", str_error(rc)); goto error_leave; } /* * will need all descriptors: * 1) choose one configuration from configuration descriptors * (set it to the device) * 2) set endpoints from endpoint descriptors */ // TODO: get descriptors, parse descriptors and save endpoints usb_endpoint_pipe_start_session(&kbd_dev->ctrl_pipe); rc = usbkbd_process_descriptors(kbd_dev); usb_endpoint_pipe_end_session(&kbd_dev->ctrl_pipe); if (rc != EOK) { goto error_leave; } // save the size of the report kbd_dev->keycode_count = BOOTP_REPORT_SIZE; kbd_dev->keycodes = (uint8_t *)calloc( kbd_dev->keycode_count, sizeof(uint8_t)); if (kbd_dev->keycodes == NULL) { usb_log_fatal("No memory!\n"); goto error_leave; } // set configuration to the first one // TODO: handle case with no configurations usb_endpoint_pipe_start_session(&kbd_dev->ctrl_pipe); usb_request_set_configuration(&kbd_dev->ctrl_pipe, kbd_dev->conf->config_descriptor.configuration_number); usb_endpoint_pipe_end_session(&kbd_dev->ctrl_pipe); return kbd_dev; error_leave: free(kbd_dev); return NULL; } static void usbkbd_process_interrupt_in(usb_hid_dev_kbd_t *kbd_dev, uint8_t *buffer, size_t actual_size) { usb_hid_report_in_callbacks_t *callbacks = (usb_hid_report_in_callbacks_t *)malloc( sizeof(usb_hid_report_in_callbacks_t)); callbacks->keyboard = usbkbd_process_keycodes; //usb_hid_parse_report(kbd_dev->parser, buffer, actual_size, callbacks, // NULL); /*usb_log_debug2("Calling usb_hid_boot_keyboard_input_report() with size" " %zu\n", actual_size);*/ //dump_buffer("bufffer: ", buffer, actual_size); int rc = usb_hid_boot_keyboard_input_report(buffer, actual_size, callbacks, kbd_dev); if (rc != EOK) { usb_log_warning("Error in usb_hid_boot_keyboard_input_report():" "%s\n", str_error(rc)); } } static void usbkbd_poll_keyboard(usb_hid_dev_kbd_t *kbd_dev) { int rc, sess_rc; uint8_t buffer[BUFFER_SIZE]; size_t actual_size; usb_log_info("Polling keyboard...\n"); while (true) { async_usleep(1000 * 10); sess_rc = usb_endpoint_pipe_start_session(&kbd_dev->poll_pipe); if (sess_rc != EOK) { usb_log_warning("Failed to start a session: %s.\n", str_error(sess_rc)); continue; } rc = usb_endpoint_pipe_read(&kbd_dev->poll_pipe, buffer, BUFFER_SIZE, &actual_size); sess_rc = usb_endpoint_pipe_end_session(&kbd_dev->poll_pipe); if (rc != EOK) { usb_log_warning("Error polling the keyboard: %s.\n", str_error(rc)); continue; } if (sess_rc != EOK) { usb_log_warning("Error closing session: %s.\n", str_error(sess_rc)); continue; } /* * If the keyboard answered with NAK, it returned no data. * This implies that no change happened since last query. */ if (actual_size == 0) { usb_log_debug("Keyboard returned NAK\n"); continue; } /* * TODO: Process pressed keys. */ usb_log_debug("Calling usbkbd_process_interrupt_in()\n"); usbkbd_process_interrupt_in(kbd_dev, buffer, actual_size); } // not reached assert(0); } static int usbkbd_fibril_device(void *arg) { if (arg == NULL) { usb_log_error("No device!\n"); return -1; } ddf_dev_t *dev = (ddf_dev_t *)arg; // initialize device (get and process descriptors, get address, etc.) usb_hid_dev_kbd_t *kbd_dev = usbkbd_init_device(dev); if (kbd_dev == NULL) { usb_log_error("Error while initializing device.\n"); return -1; } usbkbd_poll_keyboard(kbd_dev); return EOK; } static int usbkbd_add_device(ddf_dev_t *dev) { /* For now, fail immediately. */ //return ENOTSUP; /* * When everything is okay, connect to "our" HC. * * Not supported yet, skip.. */ // int phone = usb_drv_hc_connect_auto(dev, 0); // if (phone < 0) { // /* // * Connecting to HC failed, roll-back and announce // * failure. // */ // return phone; // } // dev->parent_phone = phone; /* * Create default function. */ // FIXME - check for errors ddf_fun_t *kbd_fun = ddf_fun_create(dev, fun_exposed, "keyboard"); assert(kbd_fun != NULL); kbd_fun->ops = &keyboard_ops; int rc = ddf_fun_bind(kbd_fun); assert(rc == EOK); rc = ddf_fun_add_to_class(kbd_fun, "keyboard"); assert(rc == EOK); /* * Create new fibril for handling this keyboard */ fid_t fid = fibril_create(usbkbd_fibril_device, dev); if (fid == 0) { usb_log_error("Failed to start fibril for HID device\n"); return ENOMEM; } fibril_add_ready(fid); //dev->ops = &keyboard_ops; (void)keyboard_ops; //add_device_to_class(dev, "keyboard"); /* * Hurrah, device is initialized. */ return EOK; } static driver_ops_t kbd_driver_ops = { .add_device = usbkbd_add_device, }; static driver_t kbd_driver = { .name = NAME, .driver_ops = &kbd_driver_ops }; int main(int argc, char *argv[]) { usb_log_enable(USB_LOG_LEVEL_MAX, NAME); return ddf_driver_main(&kbd_driver); } /** * @} */