Index: uspace/app/init/init.c =================================================================== --- uspace/app/init/init.c (revision f1cc9dbda70eb91d8c470d5d71e004d6baad302e) +++ uspace/app/init/init.c (revision 27bdfa5c68b9ca4622a6409c5b598b7e63c8becf) @@ -313,5 +313,11 @@ getterm("term/vc5", "/app/bdsh", false); getterm("term/vc6", "/app/klog", false); - + +#ifdef CONFIG_DEVMAN_EARLY_LAUNCH + spawn("/srv/devman"); +#else + getterm("term/vc7", "/srv/devman", false); +#endif + return 0; } Index: uspace/app/klog/klog.c =================================================================== --- uspace/app/klog/klog.c (revision f1cc9dbda70eb91d8c470d5d71e004d6baad302e) +++ uspace/app/klog/klog.c (revision 27bdfa5c68b9ca4622a6409c5b598b7e63c8becf) @@ -44,4 +44,5 @@ #include #include +#include #define NAME "klog" @@ -54,6 +55,12 @@ static FILE *log; +/* Serialize the output a bit. This will not avoid messed-up log completely + but chances for are pretty high (experimentally confirmed). */ +static FIBRIL_MUTEX_INITIALIZE(log_mutex); + static void interrupt_received(ipc_callid_t callid, ipc_call_t *call) { + fibril_mutex_lock(&log_mutex); + size_t klog_start = (size_t) IPC_GET_ARG1(*call); size_t klog_len = (size_t) IPC_GET_ARG2(*call); @@ -74,4 +81,6 @@ fsync(fileno(log)); } + + fibril_mutex_unlock(&log_mutex); } Index: uspace/app/tester/Makefile =================================================================== --- uspace/app/tester/Makefile (revision f1cc9dbda70eb91d8c470d5d71e004d6baad302e) +++ uspace/app/tester/Makefile (revision 27bdfa5c68b9ca4622a6409c5b598b7e63c8becf) @@ -31,6 +31,10 @@ BINARY = tester +LIBS += $(LIBUSB_PREFIX)/libusb.a +EXTRA_CFLAGS += -I$(LIBUSB_PREFIX)/include + SOURCES = \ tester.c \ + adt/usbaddrkeep.c \ thread/thread1.c \ print/print1.c \ @@ -49,4 +53,5 @@ loop/loop1.c \ mm/malloc1.c \ + mm/mapping1.c \ hw/misc/virtchar1.c \ hw/serial/serial1.c Index: uspace/app/tester/adt/usbaddrkeep.c =================================================================== --- uspace/app/tester/adt/usbaddrkeep.c (revision 27bdfa5c68b9ca4622a6409c5b598b7e63c8becf) +++ uspace/app/tester/adt/usbaddrkeep.c (revision 27bdfa5c68b9ca4622a6409c5b598b7e63c8becf) @@ -0,0 +1,66 @@ +/* + * Copyright (c) 2010 Vojtech Horky + * 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. + */ + +#include +#include +#include +#include +#include "../tester.h" + +#define MAX_ADDRESS 5 + + +const char *test_usbaddrkeep(void) +{ + int rc; + usb_address_keeping_t addresses; + + TPRINTF("Initializing addresses keeping structure...\n"); + usb_address_keeping_init(&addresses, MAX_ADDRESS); + + TPRINTF("Requesting address...\n"); + usb_address_t addr = usb_address_keeping_request(&addresses); + TPRINTF("Address assigned: %d\n", (int) addr); + if (addr != 1) { + return "have not received expected address 1"; + } + + TPRINTF("Releasing not assigned address...\n"); + rc = usb_address_keeping_release(&addresses, 2); + if (rc != ENOENT) { + return "have not received expected ENOENT"; + } + + TPRINTF("Releasing acquired address...\n"); + rc = usb_address_keeping_release(&addresses, addr); + if (rc != EOK) { + return "have not received expected EOK"; + } + + return NULL; +} Index: uspace/app/tester/adt/usbaddrkeep.def =================================================================== --- uspace/app/tester/adt/usbaddrkeep.def (revision 27bdfa5c68b9ca4622a6409c5b598b7e63c8becf) +++ uspace/app/tester/adt/usbaddrkeep.def (revision 27bdfa5c68b9ca4622a6409c5b598b7e63c8becf) @@ -0,0 +1,6 @@ +{ + "usbaddrkeep", + "USB address keeping structure", + &test_usbaddrkeep, + true +}, Index: uspace/app/tester/mm/mapping1.c =================================================================== --- uspace/app/tester/mm/mapping1.c (revision 27bdfa5c68b9ca4622a6409c5b598b7e63c8becf) +++ uspace/app/tester/mm/mapping1.c (revision 27bdfa5c68b9ca4622a6409c5b598b7e63c8becf) @@ -0,0 +1,123 @@ +/* + * Copyright (c) 2011 Vojtech Horky + * 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. + */ + +#include +#include +#include +#include +#include +#include +#include "../tester.h" + +#define BUFFER1_PAGES 4 +#define BUFFER2_PAGES 2 + +static void *create_as_area(size_t size) +{ + void *result = as_get_mappable_page(size); + TPRINTF("Creating AS area...\n"); + if (as_area_create(result, size, + AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE) != result) { + return NULL; + } + return result; +} + +static void touch_area(void *area, size_t size) +{ + TPRINTF("Touching (faulting-in) AS area...\n"); + + char *ptr = (char *)area; + + while (size > 0) { + *ptr = 0; + size--; + ptr++; + } +} + +#define VERIFY_MAPPING(area, page_count, expected_rc) \ + verify_mapping((area), (page_count), (expected_rc), #expected_rc) + +static bool verify_mapping(void *area, int page_count, int expected_rc, + const char *expected_rc_str) +{ + TPRINTF("Verifying mapping (expected: %s).\n", expected_rc_str); + int i; + for (i = 0; i < page_count; i++) { + void *page_start = ((char *)area) + PAGE_SIZE * i; + int rc = as_get_physical_mapping(page_start, NULL); + if (rc != expected_rc) { + TPRINTF("as_get_physical_mapping() = %d != %d\n", + rc, expected_rc); + return false; + } + } + return true; +} + +const char *test_mapping1(void) +{ + int rc; + + size_t buffer1_len = BUFFER1_PAGES * PAGE_SIZE; + size_t buffer2_len = BUFFER2_PAGES * PAGE_SIZE; + void *buffer1 = create_as_area(buffer1_len); + void *buffer2 = create_as_area(buffer2_len); + if (!buffer1 || !buffer2) { + return "Cannot allocate memory"; + } + + touch_area(buffer1, buffer1_len); + touch_area(buffer2, buffer2_len); + + /* Now verify that mapping to physical frames exist. */ + if (!VERIFY_MAPPING(buffer1, BUFFER1_PAGES, EOK)) { + return "Failed to find mapping (buffer1)"; + } + if (!VERIFY_MAPPING(buffer2, BUFFER2_PAGES, EOK)) { + return "Failed to find mapping (buffer2)"; + } + + /* Let's destroy the buffer1 area and access it again. */ + rc = as_area_destroy(buffer1); + if (rc != EOK) { + return "Failed to destroy AS area"; + } + if (!VERIFY_MAPPING(buffer1, BUFFER1_PAGES, ENOENT)) { + return "Mapping of destroyed area still exists"; + } + + /* clean-up */ + rc = as_area_destroy(buffer2); + if (rc != EOK) { + return "Failed to destroy AS area"; + } + + return NULL; +} Index: uspace/app/tester/mm/mapping1.def =================================================================== --- uspace/app/tester/mm/mapping1.def (revision 27bdfa5c68b9ca4622a6409c5b598b7e63c8becf) +++ uspace/app/tester/mm/mapping1.def (revision 27bdfa5c68b9ca4622a6409c5b598b7e63c8becf) @@ -0,0 +1,6 @@ +{ + "mapping1", + "Page mapping test", + &test_mapping1, + true +}, Index: uspace/app/tester/tester.c =================================================================== --- uspace/app/tester/tester.c (revision f1cc9dbda70eb91d8c470d5d71e004d6baad302e) +++ uspace/app/tester/tester.c (revision 27bdfa5c68b9ca4622a6409c5b598b7e63c8becf) @@ -62,5 +62,7 @@ #include "loop/loop1.def" #include "mm/malloc1.def" +#include "mm/mapping1.def" #include "hw/serial/serial1.def" +#include "adt/usbaddrkeep.def" #include "hw/misc/virtchar1.def" {NULL, NULL, NULL, false} Index: uspace/app/tester/tester.h =================================================================== --- uspace/app/tester/tester.h (revision f1cc9dbda70eb91d8c470d5d71e004d6baad302e) +++ uspace/app/tester/tester.h (revision 27bdfa5c68b9ca4622a6409c5b598b7e63c8becf) @@ -78,5 +78,7 @@ extern const char *test_loop1(void); extern const char *test_malloc1(void); +extern const char *test_mapping1(void); extern const char *test_serial1(void); +extern const char *test_usbaddrkeep(void); extern const char *test_virtchar1(void); Index: uspace/app/usbinfo/Makefile =================================================================== --- uspace/app/usbinfo/Makefile (revision 27bdfa5c68b9ca4622a6409c5b598b7e63c8becf) +++ uspace/app/usbinfo/Makefile (revision 27bdfa5c68b9ca4622a6409c5b598b7e63c8becf) @@ -0,0 +1,42 @@ +# +# Copyright (c) 2010 Vojtech Horky +# 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. +# + +USPACE_PREFIX = ../.. +BINARY = usbinfo + +LIBS = $(LIBUSB_PREFIX)/libusb.a $(LIBDRV_PREFIX)/libdrv.a +EXTRA_CFLAGS = -I$(LIBUSB_PREFIX)/include -I$(LIBDRV_PREFIX)/include + +SOURCES = \ + desctree.c \ + dev.c \ + dump.c \ + info.c \ + main.c + +include $(USPACE_PREFIX)/Makefile.common Index: uspace/app/usbinfo/desctree.c =================================================================== --- uspace/app/usbinfo/desctree.c (revision 27bdfa5c68b9ca4622a6409c5b598b7e63c8becf) +++ uspace/app/usbinfo/desctree.c (revision 27bdfa5c68b9ca4622a6409c5b598b7e63c8becf) @@ -0,0 +1,87 @@ +/* + * Copyright (c) 2010 Vojtech Horky + * 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 usbinfo + * @{ + */ +/** + * @file + * Descriptor tree dump. + */ + +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include "usbinfo.h" +#include + +static void browse_descriptor_tree_internal(usb_dp_parser_t *parser, + usb_dp_parser_data_t *data, uint8_t *root, size_t depth, + dump_descriptor_in_tree_t callback, void *arg) +{ + if (root == NULL) { + return; + } + callback(root, depth, arg); + uint8_t *child = usb_dp_get_nested_descriptor(parser, data, root); + do { + browse_descriptor_tree_internal(parser, data, child, depth + 1, + callback, arg); + child = usb_dp_get_sibling_descriptor(parser, data, + root, child); + } while (child != NULL); +} + +void browse_descriptor_tree(uint8_t *descriptors, size_t descriptors_size, + usb_dp_descriptor_nesting_t *descriptor_nesting, + dump_descriptor_in_tree_t callback, size_t initial_depth, void *arg) +{ + usb_dp_parser_data_t data = { + .data = descriptors, + .size = descriptors_size, + .arg = NULL + }; + + usb_dp_parser_t parser = { + .nesting = descriptor_nesting + }; + + browse_descriptor_tree_internal(&parser, &data, descriptors, + initial_depth, callback, arg); +} + +/** @} + */ Index: uspace/app/usbinfo/dev.c =================================================================== --- uspace/app/usbinfo/dev.c (revision 27bdfa5c68b9ca4622a6409c5b598b7e63c8becf) +++ uspace/app/usbinfo/dev.c (revision 27bdfa5c68b9ca4622a6409c5b598b7e63c8becf) @@ -0,0 +1,125 @@ +/* + * Copyright (c) 2011 Vojtech Horky + * 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 usbinfo + * @{ + */ +/** + * @file + * Representation of queried device. + */ +#include +#include +#include +#include +#include "usbinfo.h" + +usbinfo_device_t *prepare_device(devman_handle_t hc_handle, + usb_address_t dev_addr) +{ + usbinfo_device_t *dev = malloc(sizeof(usbinfo_device_t)); + if (dev == NULL) { + fprintf(stderr, NAME ": memory allocation failed.\n"); + return NULL; + } + + int rc; + + rc = usb_device_connection_initialize(&dev->wire, hc_handle, dev_addr); + if (rc != EOK) { + fprintf(stderr, + NAME ": failed to create connection to the device: %s.\n", + str_error(rc)); + goto leave; + } + + rc = usb_pipe_initialize_default_control(&dev->ctrl_pipe, + &dev->wire); + if (rc != EOK) { + fprintf(stderr, + NAME ": failed to create default control pipe: %s.\n", + str_error(rc)); + goto leave; + } + + rc = usb_pipe_probe_default_control(&dev->ctrl_pipe); + if (rc != EOK) { + fprintf(stderr, + NAME ": probing default control pipe failed: %s.\n", + str_error(rc)); + goto leave; + } + + rc = usb_pipe_start_session(&dev->ctrl_pipe); + if (rc != EOK) { + fprintf(stderr, + NAME ": failed to start session on control pipe: %s.\n", + str_error(rc)); + goto leave; + } + + rc = usb_request_get_device_descriptor(&dev->ctrl_pipe, + &dev->device_descriptor); + if (rc != EOK) { + fprintf(stderr, + NAME ": failed to retrieve device descriptor: %s.\n", + str_error(rc)); + goto leave; + } + + rc = usb_request_get_full_configuration_descriptor_alloc( + &dev->ctrl_pipe, 0, (void **)&dev->full_configuration_descriptor, + &dev->full_configuration_descriptor_size); + if (rc != EOK) { + fprintf(stderr, + NAME ": failed to retrieve configuration descriptor: %s.\n", + str_error(rc)); + goto leave; + } + + return dev; + + +leave: + if (usb_pipe_is_session_started(&dev->ctrl_pipe)) { + usb_pipe_end_session(&dev->ctrl_pipe); + } + + free(dev); + + return NULL; +} + +void destroy_device(usbinfo_device_t *dev) +{ + usb_pipe_end_session(&dev->ctrl_pipe); + free(dev); +} + +/** @} + */ Index: uspace/app/usbinfo/dump.c =================================================================== --- uspace/app/usbinfo/dump.c (revision 27bdfa5c68b9ca4622a6409c5b598b7e63c8becf) +++ uspace/app/usbinfo/dump.c (revision 27bdfa5c68b9ca4622a6409c5b598b7e63c8becf) @@ -0,0 +1,194 @@ +/* + * Copyright (c) 2010 Vojtech Horky + * 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 usbinfo + * @{ + */ +/** + * @file + * USB querying. + */ + +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include "usbinfo.h" +#include + +#define INDENT " " +#define BYTES_PER_LINE 12 + + +const char *get_indent(size_t level) +{ + static const char *indents[] = { + INDENT, + INDENT INDENT, + INDENT INDENT INDENT, + INDENT INDENT INDENT INDENT, + INDENT INDENT INDENT INDENT INDENT + }; + static size_t indents_count = sizeof(indents)/sizeof(indents[0]); + if (level >= indents_count) { + return indents[indents_count - 1]; + } + return indents[level]; +} + +void dump_buffer(const char *msg, size_t indent, + const uint8_t *buffer, size_t length) +{ + if (msg != NULL) { + printf("%s\n", msg); + } + + size_t i; + if (length > 0) { + printf("%s", get_indent(indent)); + } + 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"); + if (i + 1 < length) { + printf("%s", get_indent(indent)); + } + } else { + printf(" "); + } + } +} + +void dump_usb_descriptor(uint8_t *descriptor, size_t size) +{ + printf("Device descriptor:\n"); + usb_dump_standard_descriptor(stdout, get_indent(0), "\n", + descriptor, size); +} + +void dump_match_ids(match_id_list_t *matches, const char *line_prefix) +{ + link_t *link; + for (link = matches->ids.next; + link != &matches->ids; + link = link->next) { + match_id_t *match = list_get_instance(link, match_id_t, link); + + printf("%s%3d %s\n", line_prefix, match->score, match->id); + } +} + +static void dump_tree_descriptor(uint8_t *descriptor, size_t depth) +{ + if (descriptor == NULL) { + return; + } + int type = (int) *(descriptor + 1); + const char *name = "unknown"; + switch (type) { +#define _TYPE(descriptor_type) \ + case USB_DESCTYPE_##descriptor_type: name = #descriptor_type; break + _TYPE(DEVICE); + _TYPE(CONFIGURATION); + _TYPE(STRING); + _TYPE(INTERFACE); + _TYPE(ENDPOINT); + _TYPE(HID); + _TYPE(HID_REPORT); + _TYPE(HID_PHYSICAL); + _TYPE(HUB); +#undef _TYPE + } + printf("%s%s (0x%02X):\n", get_indent(depth), name, type); + usb_dump_standard_descriptor(stdout, get_indent(depth), "\n", + descriptor, descriptor[0]); +} + +static void dump_tree_internal(usb_dp_parser_t *parser, usb_dp_parser_data_t *data, + uint8_t *root, size_t depth) +{ + if (root == NULL) { + return; + } + dump_tree_descriptor(root, depth); + uint8_t *child = usb_dp_get_nested_descriptor(parser, data, root); + do { + dump_tree_internal(parser, data, child, depth + 1); + child = usb_dp_get_sibling_descriptor(parser, data, root, child); + } while (child != NULL); +} + +static void dump_tree(usb_dp_parser_t *parser, usb_dp_parser_data_t *data) +{ + uint8_t *ptr = data->data; + printf("Descriptor tree:\n"); + dump_tree_internal(parser, data, ptr, 0); +} + +#define NESTING(parentname, childname) \ + { \ + .child = USB_DESCTYPE_##childname, \ + .parent = USB_DESCTYPE_##parentname, \ + } +#define LAST_NESTING { -1, -1 } + +static usb_dp_descriptor_nesting_t descriptor_nesting[] = { + NESTING(CONFIGURATION, INTERFACE), + NESTING(INTERFACE, ENDPOINT), + NESTING(INTERFACE, HUB), + NESTING(INTERFACE, HID), + NESTING(HID, HID_REPORT), + LAST_NESTING +}; + +static usb_dp_parser_t parser = { + .nesting = descriptor_nesting +}; + +void dump_descriptor_tree(uint8_t *descriptors, size_t length) +{ + usb_dp_parser_data_t data = { + .data = descriptors, + .size = length, + .arg = NULL + }; + + dump_tree(&parser, &data); +} + +/** @} + */ Index: uspace/app/usbinfo/info.c =================================================================== --- uspace/app/usbinfo/info.c (revision 27bdfa5c68b9ca4622a6409c5b598b7e63c8becf) +++ uspace/app/usbinfo/info.c (revision 27bdfa5c68b9ca4622a6409c5b598b7e63c8becf) @@ -0,0 +1,342 @@ +/* + * Copyright (c) 2011 Vojtech Horky + * 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 usbinfo + * @{ + */ +/** + * @file + * Dumping of generic device properties. + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "usbinfo.h" + +void dump_short_device_identification(usbinfo_device_t *dev) +{ + printf("%sDevice 0x%04x by vendor 0x%04x\n", get_indent(0), + (int) dev->device_descriptor.product_id, + (int) dev->device_descriptor.vendor_id); +} + +static void dump_match_ids_from_interface(uint8_t *descriptor, size_t depth, + void *arg) +{ + if (depth != 1) { + return; + } + size_t descr_size = descriptor[0]; + if (descr_size < sizeof(usb_standard_interface_descriptor_t)) { + return; + } + int descr_type = descriptor[1]; + if (descr_type != USB_DESCTYPE_INTERFACE) { + return; + } + + usbinfo_device_t *dev = (usbinfo_device_t *) arg; + + usb_standard_interface_descriptor_t *iface + = (usb_standard_interface_descriptor_t *) descriptor; + + printf("%sInterface #%d match ids (%s, 0x%02x, 0x%02x)\n", + get_indent(0), + (int) iface->interface_number, + usb_str_class(iface->interface_class), + (int) iface->interface_subclass, + (int) iface->interface_protocol); + + match_id_list_t matches; + init_match_ids(&matches); + usb_device_create_match_ids_from_interface(&dev->device_descriptor, + iface, &matches); + dump_match_ids(&matches, get_indent(1)); + clean_match_ids(&matches); +} + +void dump_device_match_ids(usbinfo_device_t *dev) +{ + match_id_list_t matches; + init_match_ids(&matches); + usb_device_create_match_ids_from_device_descriptor( + &dev->device_descriptor, &matches); + printf("%sDevice match ids (0x%04x by 0x%04x, %s)\n", get_indent(0), + (int) dev->device_descriptor.product_id, + (int) dev->device_descriptor.vendor_id, + usb_str_class(dev->device_descriptor.device_class)); + dump_match_ids(&matches, get_indent(1)); + clean_match_ids(&matches); + + usb_dp_walk_simple(dev->full_configuration_descriptor, + dev->full_configuration_descriptor_size, + usb_dp_standard_descriptor_nesting, + dump_match_ids_from_interface, + dev); +} + +static void dump_descriptor_tree_brief_device(const char *prefix, + usb_standard_device_descriptor_t *descriptor) +{ + printf("%sDevice (0x%04x by 0x%04x, %s, %zu configurations)\n", prefix, + (int) descriptor->product_id, + (int) descriptor->vendor_id, + usb_str_class(descriptor->device_class), + (size_t) descriptor->configuration_count); +} + +static void dump_descriptor_tree_brief_configuration(const char *prefix, + usb_standard_configuration_descriptor_t *descriptor) +{ + printf("%sConfiguration #%d (%zu interfaces, total %zuB)\n", prefix, + (int) descriptor->configuration_number, + (size_t) descriptor->interface_count, + (size_t) descriptor->total_length); +} + +static void dump_descriptor_tree_brief_interface(const char *prefix, + usb_standard_interface_descriptor_t *descriptor) +{ + printf("%sInterface #%d (%s, 0x%02x, 0x%02x), alternate %d\n", prefix, + (int) descriptor->interface_number, + usb_str_class(descriptor->interface_class), + (int) descriptor->interface_subclass, + (int) descriptor->interface_protocol, + (int) descriptor->alternate_setting); +} + +static void dump_descriptor_tree_brief_endpoint(const char *prefix, + usb_standard_endpoint_descriptor_t *descriptor) +{ + usb_endpoint_t endpoint_no = descriptor->endpoint_address & 0xF; + usb_transfer_type_t transfer = descriptor->attributes & 0x3; + usb_direction_t direction = descriptor->endpoint_address & 0x80 + ? USB_DIRECTION_IN : USB_DIRECTION_OUT; + printf("%sEndpoint #%d (%s %s, %zu)\n", prefix, + endpoint_no, usb_str_transfer_type(transfer), + direction == USB_DIRECTION_IN ? "in" : "out", + (size_t) descriptor->max_packet_size); +} + +static void dump_descriptor_tree_brief_hid(const char *prefix, + usb_standard_hid_descriptor_t *descriptor) +{ + printf("%sHID (country %d, %d descriptors)\n", prefix, + (int) descriptor->country_code, + (int) descriptor->class_desc_count); +} + +static void dump_descriptor_tree_brief_hub(const char *prefix, + usb_hub_descriptor_header_t *descriptor) +{ + printf("%shub (%d ports)\n", prefix, + (int) descriptor->port_count); +} + + +static void dump_descriptor_tree_callback(uint8_t *descriptor, + size_t depth, void *arg) +{ + const char *indent = get_indent(depth + 1); + + int descr_type = -1; + size_t descr_size = descriptor[0]; + if (descr_size > 0) { + descr_type = descriptor[1]; + } + + switch (descr_type) { + +#define _BRANCH(type_enum, descriptor_type, callback) \ + case type_enum: \ + if (descr_size >= sizeof(descriptor_type)) { \ + callback(indent, (descriptor_type *) descriptor); \ + if (arg != NULL) { \ + usb_dump_standard_descriptor(stdout, \ + get_indent(depth +2), "\n", \ + descriptor, descr_size); \ + } \ + } else { \ + descr_type = -1; \ + } \ + break; + + _BRANCH(USB_DESCTYPE_DEVICE, + usb_standard_device_descriptor_t, + dump_descriptor_tree_brief_device); + _BRANCH(USB_DESCTYPE_CONFIGURATION, + usb_standard_configuration_descriptor_t, + dump_descriptor_tree_brief_configuration); + _BRANCH(USB_DESCTYPE_INTERFACE, + usb_standard_interface_descriptor_t, + dump_descriptor_tree_brief_interface); + _BRANCH(USB_DESCTYPE_ENDPOINT, + usb_standard_endpoint_descriptor_t, + dump_descriptor_tree_brief_endpoint); + _BRANCH(USB_DESCTYPE_HID, + usb_standard_hid_descriptor_t, + dump_descriptor_tree_brief_hid); + /* + * Probably useless, hub descriptor shall not be part of + * configuration descriptor. + */ + _BRANCH(USB_DESCTYPE_HUB, + usb_hub_descriptor_header_t, + dump_descriptor_tree_brief_hub); + + default: + break; + } + + if (descr_type == -1) { + printf("%sInvalid descriptor.\n", indent); + } +} + +void dump_descriptor_tree_brief(usbinfo_device_t *dev) +{ + dump_descriptor_tree_callback((uint8_t *)&dev->device_descriptor, + (size_t) -1, NULL); + usb_dp_walk_simple(dev->full_configuration_descriptor, + dev->full_configuration_descriptor_size, + usb_dp_standard_descriptor_nesting, + dump_descriptor_tree_callback, + NULL); +} + +void dump_descriptor_tree_full(usbinfo_device_t *dev) +{ + dump_descriptor_tree_callback((uint8_t *)&dev->device_descriptor, + (size_t) -1, dev); + usb_dp_walk_simple(dev->full_configuration_descriptor, + dev->full_configuration_descriptor_size, + usb_dp_standard_descriptor_nesting, + dump_descriptor_tree_callback, + dev); +} + + +void dump_strings(usbinfo_device_t *dev) +{ + /* Get supported languages. */ + l18_win_locales_t *langs; + size_t langs_count; + int rc = usb_request_get_supported_languages(&dev->ctrl_pipe, + &langs, &langs_count); + if (rc != EOK) { + fprintf(stderr, + NAME ": failed to get list of supported languages: %s.\n", + str_error(rc)); + return; + } + + printf("%sString languages (%zu):", get_indent(0), langs_count); + size_t i; + for (i = 0; i < langs_count; i++) { + printf(" 0x%04x", (int) langs[i]); + } + printf(".\n"); + + /* Get all strings and dump them. */ + for (i = 0; i < langs_count; i++) { + l18_win_locales_t lang = langs[i]; + + printf("%sStrings in %s:\n", get_indent(0), + str_l18_win_locale(lang)); + /* + * Try only the first 15 strings + * (typically, device will not have much more anyway). + */ + size_t idx; + for (idx = 1; idx < 0x0F; idx++) { + char *string; + rc = usb_request_get_string(&dev->ctrl_pipe, idx, lang, + &string); + if (rc != EOK) { + continue; + } + printf("%sString #%zu: \"%s\"\n", get_indent(1), + idx, string); + free(string); + } + } +} + + +void dump_status(usbinfo_device_t *dev) +{ + int rc; + uint16_t device_status = 0; + uint16_t ctrl_pipe_status = 0; + + /* Device status first. */ + rc = usb_request_get_status(&dev->ctrl_pipe, + USB_REQUEST_RECIPIENT_DEVICE, 0, + &device_status); + if (rc != EOK) { + printf("%sFailed to get device status: %s.\n", + get_indent(0), str_error(rc)); + goto try_ctrl_pipe_status; + } + + printf("%sDevice status 0x%04x: power=%s, remote-wakeup=%s.\n", + get_indent(0), + device_status, + device_status & USB_DEVICE_STATUS_SELF_POWERED ? "self" : "bus", + device_status & USB_DEVICE_STATUS_REMOTE_WAKEUP ? "yes" : "no"); + + /* Interface is not interesting, skipping ;-). */ + + /* Control endpoint zero. */ +try_ctrl_pipe_status: + rc = usb_request_get_status(&dev->ctrl_pipe, + USB_REQUEST_RECIPIENT_ENDPOINT, 0, + &ctrl_pipe_status); + if (rc != EOK) { + printf("%sFailed to get control endpoint status: %s.\n", + get_indent(0), str_error(rc)); + goto leave; + } + + printf("%sControl endpoint zero status %04X: halted=%s.\n", + get_indent(0), + ctrl_pipe_status, + ctrl_pipe_status & USB_ENDPOINT_STATUS_HALTED ? "yes" : "no"); + +leave: + return; +} + +/** @} + */ Index: uspace/app/usbinfo/main.c =================================================================== --- uspace/app/usbinfo/main.c (revision 27bdfa5c68b9ca4622a6409c5b598b7e63c8becf) +++ uspace/app/usbinfo/main.c (revision 27bdfa5c68b9ca4622a6409c5b598b7e63c8becf) @@ -0,0 +1,293 @@ +/* + * Copyright (c) 2010-2011 Vojtech Horky + * 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 usbinfo + * @{ + */ +/** + * @file + * USB querying. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "usbinfo.h" + +static bool resolve_hc_handle_and_dev_addr(const char *devpath, + devman_handle_t *out_hc_handle, usb_address_t *out_device_address) +{ + int rc; + + /* Hack for QEMU to save-up on typing ;-). */ + if (str_cmp(devpath, "qemu") == 0) { + devpath = "/hw/pci0/00:01.2/uhci-rh/usb00_a1"; + } + + char *path = str_dup(devpath); + if (path == NULL) { + return ENOMEM; + } + + devman_handle_t hc = 0; + bool hc_found = false; + usb_address_t addr = 0; + bool addr_found = false; + + /* Remove suffixes and hope that we will encounter device node. */ + while (str_length(path) > 0) { + /* Get device handle first. */ + devman_handle_t dev_handle; + rc = devman_device_get_handle(path, &dev_handle, 0); + if (rc != EOK) { + free(path); + return false; + } + + /* Try to find its host controller. */ + if (!hc_found) { + rc = usb_hc_find(dev_handle, &hc); + if (rc == EOK) { + hc_found = true; + } + } + /* Try to get its address. */ + if (!addr_found) { + addr = usb_device_get_assigned_address(dev_handle); + if (addr >= 0) { + addr_found = true; + } + } + + /* Speed-up. */ + if (hc_found && addr_found) { + break; + } + + /* Remove the last suffix. */ + char *slash_pos = str_rchr(path, '/'); + if (slash_pos != NULL) { + *slash_pos = 0; + } + } + + free(path); + + if (hc_found && addr_found) { + if (out_hc_handle != NULL) { + *out_hc_handle = hc; + } + if (out_device_address != NULL) { + *out_device_address = addr; + } + return true; + } else { + return false; + } +} + +static void print_usage(char *app_name) +{ +#define _INDENT " " +#define _OPTION(opt, description) \ + printf(_INDENT opt "\n" _INDENT _INDENT description "\n") + + printf(NAME ": query USB devices for descriptors\n\n"); + printf("Usage: %s [options] device [device [device [ ... ]]]\n", + app_name); + printf(_INDENT "The device is a devman path to the device.\n"); + + _OPTION("-h --help", "Print this help and exit."); + _OPTION("-i --identification", "Brief device identification."); + _OPTION("-m --match-ids", "Print match ids generated for the device."); + _OPTION("-t --descriptor-tree", "Print descriptor tree."); + _OPTION("-T --descriptor-tree-full", "Print detailed descriptor tree"); + _OPTION("-s --strings", "Try to print all string descriptors."); + _OPTION("-S --status", "Get status of the device."); + + printf("\n"); + printf("If no option is specified, `-i' is considered default.\n"); + printf("\n"); + +#undef _OPTION +#undef _INDENT +} + +static struct option long_options[] = { + {"help", no_argument, NULL, 'h'}, + {"identification", no_argument, NULL, 'i'}, + {"match-ids", no_argument, NULL, 'm'}, + {"descriptor-tree", no_argument, NULL, 't'}, + {"descriptor-tree-full", no_argument, NULL, 'T'}, + {"strings", no_argument, NULL, 's'}, + {"status", no_argument, NULL, 'S'}, + {0, 0, NULL, 0} +}; +static const char *short_options = "himtTsS"; + +static usbinfo_action_t actions[] = { + { + .opt = 'i', + .action = dump_short_device_identification, + .active = false + }, + { + .opt = 'm', + .action = dump_device_match_ids, + .active = false + }, + { + .opt = 't', + .action = dump_descriptor_tree_brief, + .active = false + }, + { + .opt = 'T', + .action = dump_descriptor_tree_full, + .active = false + }, + { + .opt = 's', + .action = dump_strings, + .active = false + }, + { + .opt = 'S', + .action = dump_status, + .active = false + }, + { + .opt = 0 + } +}; + +int main(int argc, char *argv[]) +{ + if (argc <= 1) { + print_usage(argv[0]); + return -1; + } + + /* + * Process command-line options. They determine what shall be + * done with the device. + */ + int opt; + do { + opt = getopt_long(argc, argv, + short_options, long_options, NULL); + switch (opt) { + case -1: + break; + case '?': + print_usage(argv[0]); + return 1; + case 'h': + print_usage(argv[0]); + return 0; + default: { + int idx = 0; + while (actions[idx].opt != 0) { + if (actions[idx].opt == opt) { + actions[idx].active = true; + break; + } + idx++; + } + break; + } + } + } while (opt > 0); + + /* Set the default action. */ + int idx = 0; + bool something_active = false; + while (actions[idx].opt != 0) { + if (actions[idx].active) { + something_active = true; + break; + } + idx++; + } + if (!something_active) { + actions[0].active = true; + } + + /* + * Go through all devices given on the command line and run the + * specified actions. + */ + int i; + for (i = optind; i < argc; i++) { + char *devpath = argv[i]; + + /* The initialization is here only to make compiler happy. */ + devman_handle_t hc_handle = 0; + usb_address_t dev_addr = 0; + bool found = resolve_hc_handle_and_dev_addr(devpath, + &hc_handle, &dev_addr); + if (!found) { + fprintf(stderr, NAME ": device `%s' not found " + "or not of USB kind, skipping.\n", + devpath); + continue; + } + + usbinfo_device_t *dev = prepare_device(hc_handle, dev_addr); + if (dev == NULL) { + continue; + } + + /* Run actions the user specified. */ + printf("%s\n", devpath); + + int action = 0; + while (actions[action].opt != 0) { + if (actions[action].active) { + actions[action].action(dev); + } + action++; + } + + /* Destroy the control pipe (close the session etc.). */ + destroy_device(dev); + } + + return 0; +} + + +/** @} + */ Index: uspace/app/usbinfo/usbinfo.h =================================================================== --- uspace/app/usbinfo/usbinfo.h (revision 27bdfa5c68b9ca4622a6409c5b598b7e63c8becf) +++ uspace/app/usbinfo/usbinfo.h (revision 27bdfa5c68b9ca4622a6409c5b598b7e63c8becf) @@ -0,0 +1,92 @@ +/* + * Copyright (c) 2010 Vojtech Horky + * 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 usbinfo + * @{ + */ +/** @file + * Common header for usbinfo application. + */ +#ifndef USBINFO_USBINFO_H_ +#define USBINFO_USBINFO_H_ + +#include +#include +#include +#include +#include +#include + +typedef struct { + usb_pipe_t ctrl_pipe; + usb_device_connection_t wire; + usb_standard_device_descriptor_t device_descriptor; + uint8_t *full_configuration_descriptor; + size_t full_configuration_descriptor_size; +} usbinfo_device_t; + +typedef struct { + int opt; + void (*action)(usbinfo_device_t *dev); + bool active; +} usbinfo_action_t; + + +#define NAME "usbinfo" + +void dump_buffer(const char *, size_t, const uint8_t *, size_t); +const char *get_indent(size_t); +void dump_match_ids(match_id_list_t *, const char *); +void dump_usb_descriptor(uint8_t *, size_t); +void dump_descriptor_tree(uint8_t *, size_t); + +static inline void internal_error(int err) +{ + fprintf(stderr, NAME ": internal error (%s).\n", str_error(err)); +} + +usbinfo_device_t *prepare_device(devman_handle_t, usb_address_t); +void destroy_device(usbinfo_device_t *); + +typedef void (*dump_descriptor_in_tree_t)(uint8_t *, size_t, void *); +void browse_descriptor_tree(uint8_t *, size_t, usb_dp_descriptor_nesting_t *, + dump_descriptor_in_tree_t, size_t, void *); + + +void dump_short_device_identification(usbinfo_device_t *); +void dump_device_match_ids(usbinfo_device_t *); +void dump_descriptor_tree_brief(usbinfo_device_t *); +void dump_descriptor_tree_full(usbinfo_device_t *); +void dump_strings(usbinfo_device_t *); +void dump_status(usbinfo_device_t *); + + +#endif +/** + * @} + */ Index: uspace/app/virtusbhub/Makefile =================================================================== --- uspace/app/virtusbhub/Makefile (revision 27bdfa5c68b9ca4622a6409c5b598b7e63c8becf) +++ uspace/app/virtusbhub/Makefile (revision 27bdfa5c68b9ca4622a6409c5b598b7e63c8becf) @@ -0,0 +1,62 @@ +# +# Copyright (c) 2011 Vojtech Horky +# 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. +# + +USPACE_PREFIX = ../.. +# acronym for virtual USB hub +# (it is really annoying to write long names) +BINARY = vuh + +LIBS = $(LIBUSB_PREFIX)/libusb.a $(LIBUSBVIRT_PREFIX)/libusbvirt.a +EXTRA_CFLAGS = -DSTANDALONE_HUB \ + -DHUB_PORT_COUNT=10 \ + -I$(LIBUSB_PREFIX)/include -I$(LIBUSBVIRT_PREFIX)/include -I$(LIBDRV_PREFIX)/include + +SOURCES = \ + main.c \ + $(STOLEN_VHC_SOURCES) + +STOLEN_VHC_SOURCES = \ + vhc_hub/hub.c \ + vhc_hub/virthub.c \ + vhc_hub/virthubops.c +STOLEN_VHC_HEADERS = \ + vhc_hub/hub.h \ + vhc_hub/virthub.h + +PRE_DEPEND = $(STOLEN_VHC_SOURCES) $(STOLEN_VHC_HEADERS) + +EXTRA_CLEAN = $(STOLEN_VHC_SOURCES) $(STOLEN_VHC_HEADERS) + +HUB_IN_VHC = $(USPACE_PREFIX)/drv/vhc/hub + +include $(USPACE_PREFIX)/Makefile.common + +vhc_hub/%.h: $(HUB_IN_VHC)/%.h + ln -sfn ../$(HUB_IN_VHC)/$*.h $@ +vhc_hub/%.c: $(HUB_IN_VHC)/%.c + ln -sfn ../$(HUB_IN_VHC)/$*.c $@ Index: uspace/app/virtusbhub/main.c =================================================================== --- uspace/app/virtusbhub/main.c (revision 27bdfa5c68b9ca4622a6409c5b598b7e63c8becf) +++ uspace/app/virtusbhub/main.c (revision 27bdfa5c68b9ca4622a6409c5b598b7e63c8becf) @@ -0,0 +1,102 @@ +/* + * Copyright (c) 2011 Vojtech Horky + * 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 usbvirthub + * @{ + */ +/** + * @file + * @brief Virtual USB hub. + */ + +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include "vhc_hub/virthub.h" + +#define NAME "vuh" + +static usbvirt_device_t hub_device; + +#define VERBOSE_SLEEP(sec, msg, ...) \ + do { \ + char _status[HUB_PORT_COUNT + 2]; \ + printf(NAME ": doing nothing for %zu seconds...\n", \ + (size_t) (sec)); \ + fibril_sleep((sec)); \ + virthub_get_status(&hub_device, _status, HUB_PORT_COUNT + 1); \ + printf(NAME ": " msg " [%s]\n" #__VA_ARGS__, _status); \ + } while (0) + +static void fibril_sleep(size_t sec) +{ + while (sec-- > 0) { + async_usleep(1000*1000); + } +} + +static int dev1 = 1; + +int main(int argc, char * argv[]) +{ + int rc; + + printf(NAME ": virtual USB hub.\n"); + + rc = virthub_init(&hub_device); + if (rc != EOK) { + printf(NAME ": Unable to start communication with VHCD (%s).\n", + str_error(rc)); + return rc; + } + + while (true) { + VERBOSE_SLEEP(8, "will pretend device plug-in..."); + virthub_connect_device(&hub_device, &dev1); + + VERBOSE_SLEEP(8, "will pretend device un-plug..."); + virthub_disconnect_device(&hub_device, &dev1); + } + + usbvirt_disconnect(&hub_device); + + return 0; +} + + +/** @} + */ Index: uspace/app/virtusbkbd/Makefile =================================================================== --- uspace/app/virtusbkbd/Makefile (revision 27bdfa5c68b9ca4622a6409c5b598b7e63c8becf) +++ uspace/app/virtusbkbd/Makefile (revision 27bdfa5c68b9ca4622a6409c5b598b7e63c8becf) @@ -0,0 +1,43 @@ +# +# Copyright (c) 2010 Vojtech Horky +# 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. +# + +USPACE_PREFIX = ../.. +# acronym for virtual usb keyboard +# (it is really annoying to write long names) +BINARY = vuk + +LIBS = $(LIBUSB_PREFIX)/libusb.a $(LIBUSBVIRT_PREFIX)/libusbvirt.a +EXTRA_CFLAGS = -I$(LIBUSB_PREFIX)/include -I$(LIBUSBVIRT_PREFIX)/include -I$(LIBDRV_PREFIX)/include + +SOURCES = \ + kbdconfig.c \ + keys.c \ + stdreq.c \ + virtusbkbd.c + +include $(USPACE_PREFIX)/Makefile.common Index: uspace/app/virtusbkbd/descriptor.h =================================================================== --- uspace/app/virtusbkbd/descriptor.h (revision 27bdfa5c68b9ca4622a6409c5b598b7e63c8becf) +++ uspace/app/virtusbkbd/descriptor.h (revision 27bdfa5c68b9ca4622a6409c5b598b7e63c8becf) @@ -0,0 +1,51 @@ +/* + * Copyright (c) 2010 Vojtech Horky + * 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 usbvirtkbd + * @{ + */ +/** @file + * @brief USB keyboard descriptors. + */ +#ifndef VUK_DESCRIPTOR_H_ +#define VUK_DESCRIPTOR_H_ + +typedef struct { + uint8_t length; + uint8_t type; + uint16_t hid_spec_release; + uint8_t country_code; + uint8_t descriptor_count; + uint8_t descriptor1_type; + uint16_t descriptor1_length; +} __attribute__ ((packed)) hid_descriptor_t; + +#endif +/** + * @} + */ Index: uspace/app/virtusbkbd/items.h =================================================================== --- uspace/app/virtusbkbd/items.h (revision 27bdfa5c68b9ca4622a6409c5b598b7e63c8becf) +++ uspace/app/virtusbkbd/items.h (revision 27bdfa5c68b9ca4622a6409c5b598b7e63c8becf) @@ -0,0 +1,113 @@ +/* + * Copyright (c) 2010 Vojtech Horky + * 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 usbvirtkbd + * @{ + */ +/** @file + * @brief HID Item related functions. + */ +#ifndef VUK_ITEM_H_ +#define VUK_ITEM_H_ + +#include + +typedef uint8_t report_descriptor_data_t[]; + +/* Item types. */ +#define ITEM_MAIN 0 +#define ITEM_GLOBAL 1 +#define ITEM_LOCAL 2 + + + +/* Item tags. */ + +/* Main item tags. */ +#define TAG_INPUT 8 +#define TAG_OUTPUT 9 +#define TAG_FEATURE 11 +#define TAG_COLLECTION 10 +#define TAG_END_COLLECTION 12 + +/* Global item tags. */ +#define TAG_USAGE_PAGE 0 +#define TAG_LOGICAL_MINIMUM 1 +#define TAG_LOGICAL_MAXIMUM 2 +#define TAG_REPORT_SIZE 7 +#define TAG_REPORT_COUNT 9 + +/* Local item tags. */ +#define TAG_USAGE 0 +#define TAG_USAGE_MINIMUM 1 +#define TAG_USAGE_MAXIMUM 2 + + +/* Bits for Input, Output and Feature items. */ +#define _IOF(value, shift) ((value) << (shift)) +#define IOF_DATA _IOF(0, 0) +#define IOF_CONSTANT _IOF(1, 0) +#define IOF_ARRAY _IOF(0, 1) +#define IOF_VARIABLE _IOF(1, 1) +#define IOF_ABSOLUTE _IOF(0, 2) +#define IOF_RELATIVE _IOF(1, 2) +/* ... */ + +/* Collection types. */ +#define COLLECTION_PHYSICAL 0x00 +#define COLLECTION_APPLICATION 0x01 + + +/** Creates item prefix. + * @param size Item size. + * @param type Item type. + * @param tag Item tag. + */ +#define BUILD_ITEM_PREFIX(size, type, tag) \ + ((size) | ((type) << 2) | ((tag) << 4)) + +/** Create no-data item. + * @param type Item type. + * @param tag Item tag. + */ +#define ITEM_CREATE0(type, tag) \ + BUILD_ITEM_PREFIX(0, type, tag) + +/** Create item with 1-byte data. + * @param type Item type. + * @param tag Item tag. + * @param data Item data (single byte). + */ +#define ITEM_CREATE1(type, tag, data) \ + BUILD_ITEM_PREFIX(1, type, tag), data + + +#endif +/** + * @} + */ Index: uspace/app/virtusbkbd/kbdconfig.c =================================================================== --- uspace/app/virtusbkbd/kbdconfig.c (revision 27bdfa5c68b9ca4622a6409c5b598b7e63c8becf) +++ uspace/app/virtusbkbd/kbdconfig.c (revision 27bdfa5c68b9ca4622a6409c5b598b7e63c8becf) @@ -0,0 +1,155 @@ +/* + * Copyright (c) 2010 Vojtech Horky + * 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 usbvirtkbd + * @{ + */ +/** + * @file + * @brief Keyboard configuration. + */ +#include "kbdconfig.h" +#include "keys.h" +#include +#include +#include +#include + +/** Standard device descriptor. */ +usb_standard_device_descriptor_t std_device_descriptor = { + .length = sizeof(usb_standard_device_descriptor_t), + .descriptor_type = USB_DESCTYPE_DEVICE, + .usb_spec_version = 0x110, + .device_class = USB_CLASS_USE_INTERFACE, + .device_subclass = 0, + .device_protocol = 0, + .max_packet_size = 64, + .configuration_count = 1 +}; + +/** Standard interface descriptor. */ +usb_standard_interface_descriptor_t std_interface_descriptor = { + .length = sizeof(usb_standard_interface_descriptor_t), + .descriptor_type = USB_DESCTYPE_INTERFACE, + .interface_number = 0, + .alternate_setting = 0, + .endpoint_count = 1, + .interface_class = USB_CLASS_HID, + .interface_subclass = USB_HID_SUBCLASS_BOOT, + .interface_protocol = USB_HID_PROTOCOL_KEYBOARD, + .str_interface = 0 +}; + +/** USB keyboard report descriptor. + * Copied from USB HID 1.11 (section E.6). + */ +report_descriptor_data_t report_descriptor = { + STD_USAGE_PAGE(USB_HIDUT_PAGE_GENERIC_DESKTOP), + USAGE1(USB_HIDUT_USAGE_GENERIC_DESKTOP_KEYBOARD), + START_COLLECTION(COLLECTION_APPLICATION), + STD_USAGE_PAGE(USB_HIDUT_PAGE_KEYBOARD), + USAGE_MINIMUM1(224), + USAGE_MAXIMUM1(231), + LOGICAL_MINIMUM1(0), + LOGICAL_MAXIMUM1(1), + REPORT_SIZE1(1), + REPORT_COUNT1(8), + /* Modifiers */ + INPUT(IOF_DATA | IOF_VARIABLE | IOF_ABSOLUTE), + REPORT_COUNT1(1), + REPORT_SIZE1(8), + /* Reserved */ + INPUT(IOF_CONSTANT), + REPORT_COUNT1(5), + REPORT_SIZE1(1), + STD_USAGE_PAGE(USB_HIDUT_PAGE_LED), + USAGE_MINIMUM1(1), + USAGE_MAXIMUM1(5), + /* LED states */ + OUTPUT(IOF_DATA | IOF_VARIABLE | IOF_ABSOLUTE), + REPORT_COUNT1(1), + REPORT_SIZE1(3), + /* LED states padding */ + OUTPUT(IOF_CONSTANT), + REPORT_COUNT1(KB_MAX_KEYS_AT_ONCE), + REPORT_SIZE1(8), + LOGICAL_MINIMUM1(0), + LOGICAL_MAXIMUM1(101), + STD_USAGE_PAGE(USB_HIDUT_PAGE_KEYBOARD), + USAGE_MINIMUM1(0), + USAGE_MAXIMUM1(101), + /* Key array */ + INPUT(IOF_DATA | IOF_ARRAY), + END_COLLECTION() +}; +size_t report_descriptor_size = sizeof(report_descriptor); + +/** HID descriptor. */ +hid_descriptor_t hid_descriptor = { + .length = sizeof(hid_descriptor_t), + .type = 0x21, // HID descriptor + .hid_spec_release = 0x101, + .country_code = 0, + .descriptor_count = 1, + .descriptor1_type = 0x22, // Report descriptor + .descriptor1_length = sizeof(report_descriptor) +}; + +/** Endpoint descriptor. */ +usb_standard_endpoint_descriptor_t endpoint_descriptor = { + .length = sizeof(usb_standard_endpoint_descriptor_t), + .descriptor_type = USB_DESCTYPE_ENDPOINT, + .endpoint_address = 1 | 128, + .attributes = USB_TRANSFER_INTERRUPT, + .max_packet_size = 8, + .poll_interval = 10 +}; + +/** Standard configuration descriptor. */ +usb_standard_configuration_descriptor_t std_configuration_descriptor = { + .length = sizeof(usb_standard_configuration_descriptor_t), + .descriptor_type = USB_DESCTYPE_CONFIGURATION, + .total_length = + sizeof(usb_standard_configuration_descriptor_t) + + sizeof(std_interface_descriptor) + + sizeof(hid_descriptor) + + sizeof(endpoint_descriptor) + , + .interface_count = 1, + .configuration_number = 1, + .str_configuration = 0, + .attributes = 128, /* denotes bus-powered device */ + .max_power = 50 +}; + + + + + +/** @} + */ Index: uspace/app/virtusbkbd/kbdconfig.h =================================================================== --- uspace/app/virtusbkbd/kbdconfig.h (revision 27bdfa5c68b9ca4622a6409c5b598b7e63c8becf) +++ uspace/app/virtusbkbd/kbdconfig.h (revision 27bdfa5c68b9ca4622a6409c5b598b7e63c8becf) @@ -0,0 +1,60 @@ +/* + * Copyright (c) 2010 Vojtech Horky + * 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 usbvirtkbd + * @{ + */ +/** @file + * @brief USB keyboard configuration. + */ +#ifndef VUK_KBDCONFIG_H_ +#define VUK_KBDCONFIG_H_ + +#include +#include "report.h" +#include "descriptor.h" + +extern usb_standard_device_descriptor_t std_device_descriptor; + +extern usb_standard_configuration_descriptor_t std_configuration_descriptor; + +extern usb_standard_interface_descriptor_t std_interface_descriptor; + +extern usb_standard_endpoint_descriptor_t endpoint_descriptor; + + +extern hid_descriptor_t hid_descriptor; + +extern report_descriptor_data_t report_descriptor; +extern size_t report_descriptor_size; + + +#endif +/** + * @} + */ Index: uspace/app/virtusbkbd/keys.c =================================================================== --- uspace/app/virtusbkbd/keys.c (revision 27bdfa5c68b9ca4622a6409c5b598b7e63c8becf) +++ uspace/app/virtusbkbd/keys.c (revision 27bdfa5c68b9ca4622a6409c5b598b7e63c8becf) @@ -0,0 +1,123 @@ +/* + * Copyright (c) 2010 Vojtech Horky + * 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 usbvirtkbd + * @{ + */ +/** + * @file + * @brief Keyboard keys related structures. + */ +#include "keys.h" + +/** Initializes keyboard status. */ +void kb_init(kb_status_t *status) +{ + status->modifiers = 0; + size_t i; + for (i = 0; i < KB_MAX_KEYS_AT_ONCE; i++) { + status->pressed_keys[i] = 0; + } +} + +/** Change pressed modifiers. */ +void kb_change_modifier(kb_status_t *status, kb_key_action_t action, + kb_modifier_t modifier) +{ + if (action == KB_KEY_DOWN) { + status->modifiers = status->modifiers | modifier; + } else { + status->modifiers = status->modifiers & (~modifier); + } +} + +/** Find index of given key in key code array. + * @retval (size_t)-1 Key not found. + */ +static size_t find_key_index(kb_key_code_t *keys, size_t size, kb_key_code_t key) +{ + size_t i; + for (i = 0; i < size; i++) { + if (keys[i] == key) { + return i; + } + } + return (size_t)-1; +} + +/** Change pressed key. */ +void kb_change_key(kb_status_t *status, kb_key_action_t action, + kb_key_code_t key_code) +{ + size_t pos = find_key_index(status->pressed_keys, KB_MAX_KEYS_AT_ONCE, + key_code); + if (action == KB_KEY_DOWN) { + if (pos != (size_t)-1) { + return; + } + /* + * Find first free item in the array. + */ + size_t i; + for (i = 0; i < KB_MAX_KEYS_AT_ONCE; i++) { + if (status->pressed_keys[i] == 0) { + status->pressed_keys[i] = key_code; + return; + } + } + // TODO - handle buffer overflow + } else { + if (pos == (size_t)-1) { + return; + } + status->pressed_keys[pos] = 0; + } +} + +/** Process list of events. */ +void kb_process_events(kb_status_t *status, + kb_event_t *events, size_t count, + kb_on_status_change on_change) +{ + while (count-- > 0) { + if (events->normal_key) { + kb_change_key(status, events->action, + events->key_change); + } else { + kb_change_modifier(status, events->action, + events->modifier_change); + } + if (on_change) { + on_change(status); + } + events++; + } +} + +/** @} + */ Index: uspace/app/virtusbkbd/keys.h =================================================================== --- uspace/app/virtusbkbd/keys.h (revision 27bdfa5c68b9ca4622a6409c5b598b7e63c8becf) +++ uspace/app/virtusbkbd/keys.h (revision 27bdfa5c68b9ca4622a6409c5b598b7e63c8becf) @@ -0,0 +1,121 @@ +/* + * Copyright (c) 2010 Vojtech Horky + * 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 usbvirtkbd + * @{ + */ +/** @file + * @brief Keyboard keys related structures. + */ +#ifndef VUK_KEYS_H_ +#define VUK_KEYS_H_ + +#include +#include + +/** Maximum number of keys that can be pressed simultaneously. */ +#define KB_MAX_KEYS_AT_ONCE 6 + +/** Key code type. */ +typedef uint8_t kb_key_code_t; + +#define USB_HIDUT_KBD_KEY(name, usage_id, l, lc, l1, l2) \ + KB_KEY_##name = usage_id, +/** USB key code. */ +typedef enum { + #include +} key_code_t; + +/** Modifier type. */ +typedef uint8_t kb_modifier_t; +#define _KB_MOD(shift) (1 << (shift)) +#define KB_MOD_LEFT_CTRL _KB_MOD(0) +#define KB_MOD_LEFT_SHIFT _KB_MOD(1) +#define KB_MOD_LEFT_ALT _KB_MOD(2) +#define KB_MOD_LEFT_GUI _KB_MOD(3) +#define KB_MOD_RIGHT_CTRL _KB_MOD(4) +#define KB_MOD_RIGHT_SHIFT _KB_MOD(5) +#define KB_MOD_RIGHT_ALT _KB_MOD(6) +#define KB_MOD_RIGHT_GUI _KB_MOD(7) + +/** Base key action. */ +typedef enum { + KB_KEY_DOWN, + KB_KEY_UP +} kb_key_action_t; + +/** Keyboard status. */ +typedef struct { + /** Bitmap of pressed modifiers. */ + kb_modifier_t modifiers; + /** Array of currently pressed keys. */ + kb_key_code_t pressed_keys[KB_MAX_KEYS_AT_ONCE]; +} kb_status_t; + +/** Callback type for status change. */ +typedef void (*kb_on_status_change)(kb_status_t *); + + +void kb_init(kb_status_t *); +void kb_change_modifier(kb_status_t *, kb_key_action_t, kb_modifier_t); +void kb_change_key(kb_status_t *, kb_key_action_t, kb_key_code_t); + +/** Keyboard event. + * Use macros M_DOWN, M_UP, K_DOWN, K_UP, K_PRESS to generate list + * of them. + */ +typedef struct { + /** Key action. */ + kb_key_action_t action; + /** Switch whether action is about modifier or normal key. */ + bool normal_key; + /** Modifier change. */ + kb_modifier_t modifier_change; + /** Normal key change. */ + kb_key_code_t key_change; +} kb_event_t; + +#define M_DOWN(mod) \ + { KB_KEY_DOWN, false, (mod), 0 } +#define M_UP(mod) \ + { KB_KEY_UP, false, (mod), 0 } +#define K_DOWN(key) \ + { KB_KEY_DOWN, true, 0, (key) } +#define K_UP(key) \ + { KB_KEY_UP, true, 0, (key) } +#define K_PRESS(key) \ + K_DOWN(key), K_UP(key) + + +void kb_process_events(kb_status_t *, kb_event_t *, size_t, kb_on_status_change); + + +#endif +/** + * @} + */ Index: uspace/app/virtusbkbd/report.h =================================================================== --- uspace/app/virtusbkbd/report.h (revision 27bdfa5c68b9ca4622a6409c5b598b7e63c8becf) +++ uspace/app/virtusbkbd/report.h (revision 27bdfa5c68b9ca4622a6409c5b598b7e63c8becf) @@ -0,0 +1,85 @@ +/* + * Copyright (c) 2010 Vojtech Horky + * 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 usbvirtkbd + * @{ + */ +/** @file + * @brief HID Report Descriptor. + */ +#ifndef VUK_REPORT_H_ +#define VUK_REPORT_H_ + +#include "items.h" + +/** Use standard Usage Page. */ +#define STD_USAGE_PAGE(page) \ + ITEM_CREATE1(ITEM_GLOBAL, TAG_USAGE_PAGE, page) + +/** Usage with one byte usage ID. */ +#define USAGE1(usage_id) \ + ITEM_CREATE1(ITEM_LOCAL, TAG_USAGE, usage_id) + +/** Start a collection. */ +#define START_COLLECTION(collection) \ + ITEM_CREATE1(ITEM_MAIN, TAG_COLLECTION, collection) + +/** End a collection. */ +#define END_COLLECTION() \ + ITEM_CREATE0(ITEM_MAIN, TAG_END_COLLECTION) + + +#define USAGE_MINIMUM1(value) \ + ITEM_CREATE1(ITEM_LOCAL, TAG_USAGE_MINIMUM, value) + +#define USAGE_MAXIMUM1(value) \ + ITEM_CREATE1(ITEM_LOCAL, TAG_USAGE_MAXIMUM, value) + +#define LOGICAL_MINIMUM1(value) \ + ITEM_CREATE1(ITEM_GLOBAL, TAG_LOGICAL_MINIMUM, value) + +#define LOGICAL_MAXIMUM1(value) \ + ITEM_CREATE1(ITEM_GLOBAL, TAG_LOGICAL_MAXIMUM, value) + +#define REPORT_SIZE1(size) \ + ITEM_CREATE1(ITEM_GLOBAL, TAG_REPORT_SIZE, size) + +#define REPORT_COUNT1(count) \ + ITEM_CREATE1(ITEM_GLOBAL, TAG_REPORT_COUNT, count) + +#define INPUT(modifiers) \ + ITEM_CREATE1(ITEM_MAIN, TAG_INPUT, modifiers) + +#define OUTPUT(modifiers) \ + ITEM_CREATE1(ITEM_MAIN, TAG_OUTPUT, modifiers) + + +#endif +/** + * @} + */ Index: uspace/app/virtusbkbd/stdreq.c =================================================================== --- uspace/app/virtusbkbd/stdreq.c (revision 27bdfa5c68b9ca4622a6409c5b598b7e63c8becf) +++ uspace/app/virtusbkbd/stdreq.c (revision 27bdfa5c68b9ca4622a6409c5b598b7e63c8becf) @@ -0,0 +1,62 @@ +/* + * Copyright (c) 2010 Vojtech Horky + * 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 usbvirtkbd + * @{ + */ +/** + * @file + * @brief Keyboard configuration. + */ +#include +#include +#include "stdreq.h" +#include "kbdconfig.h" + +int stdreq_on_get_descriptor(struct usbvirt_device *dev, + usb_device_request_setup_packet_t *request, uint8_t *data) +{ + if (request->value_high == USB_DESCTYPE_HID_REPORT) { + /* + * For simplicity, always return the same + * report descriptor. + */ + int rc = dev->control_transfer_reply(dev, 0, + report_descriptor, report_descriptor_size); + + return rc; + } + + /* Let the framework handle all the rest. */ + return EFORWARD; +} + + + +/** @} + */ Index: uspace/app/virtusbkbd/stdreq.h =================================================================== --- uspace/app/virtusbkbd/stdreq.h (revision 27bdfa5c68b9ca4622a6409c5b598b7e63c8becf) +++ uspace/app/virtusbkbd/stdreq.h (revision 27bdfa5c68b9ca4622a6409c5b598b7e63c8becf) @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2010 Vojtech Horky + * 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 usbvirtkbd + * @{ + */ +/** @file + * @brief Standard device request handlers. + */ +#ifndef VUK_STDREQ_H_ +#define VUK_STDREQ_H_ + +#include + +int stdreq_on_get_descriptor(usbvirt_device_t *, + usb_device_request_setup_packet_t *, uint8_t *); + +#endif +/** + * @} + */ Index: uspace/app/virtusbkbd/virtusbkbd.c =================================================================== --- uspace/app/virtusbkbd/virtusbkbd.c (revision 27bdfa5c68b9ca4622a6409c5b598b7e63c8becf) +++ uspace/app/virtusbkbd/virtusbkbd.c (revision 27bdfa5c68b9ca4622a6409c5b598b7e63c8becf) @@ -0,0 +1,287 @@ +/* + * Copyright (c) 2010 Vojtech Horky + * 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 usbvirtkbd + * @{ + */ +/** + * @file + * @brief Virtual USB keyboard. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include "kbdconfig.h" +#include "keys.h" +#include "stdreq.h" + +/** Pause between individual key-presses in seconds. */ +#define KEY_PRESS_DELAY 2 +#define NAME "virt-usb-kbd" + + +#define __QUOTEME(x) #x +#define _QUOTEME(x) __QUOTEME(x) + +#define VERBOSE_EXEC(cmd, fmt, ...) \ + (printf("%s: %s" fmt "\n", NAME, _QUOTEME(cmd), __VA_ARGS__), cmd(__VA_ARGS__)) + +kb_status_t status; + +static int on_incoming_data(struct usbvirt_device *dev, + usb_endpoint_t endpoint, void *buffer, size_t size) +{ + printf("%s: ignoring incomming data to endpoint %d\n", NAME, endpoint); + + return EOK; +} + + +/** Compares current and last status of pressed keys. + * + * @warning Has side-efect - changes status_last field. + * + * @param status_now Status now. + * @param status_last Last status. + * @param len Size of status. + * @return Whether they are the same. + */ +static bool keypress_check_with_last_request(uint8_t *status_now, + uint8_t *status_last, size_t len) +{ + bool same = true; + size_t i; + for (i = 0; i < len; i++) { + if (status_now[i] != status_last[i]) { + status_last[i] = status_now[i]; + same = false; + } + } + return same; +} + +static int on_request_for_data(struct usbvirt_device *dev, + usb_endpoint_t endpoint, void *buffer, size_t size, size_t *actual_size) +{ + static uint8_t last_data[2 + KB_MAX_KEYS_AT_ONCE]; + + if (size < 2 + KB_MAX_KEYS_AT_ONCE) { + return EINVAL; + } + + *actual_size = 2 + KB_MAX_KEYS_AT_ONCE; + + uint8_t data[2 + KB_MAX_KEYS_AT_ONCE]; + data[0] = status.modifiers; + data[1] = 0; + + size_t i; + for (i = 0; i < KB_MAX_KEYS_AT_ONCE; i++) { + data[2 + i] = status.pressed_keys[i]; + } + + if (keypress_check_with_last_request(data, last_data, + 2 + KB_MAX_KEYS_AT_ONCE)) { + *actual_size = 0; + return EOK; + } + + memcpy(buffer, &data, *actual_size); + + return EOK; +} + +static usbvirt_control_transfer_handler_t endpoint_zero_handlers[] = { + { + .request_type = USBVIRT_MAKE_CONTROL_REQUEST_TYPE( + USB_DIRECTION_IN, + USBVIRT_REQUEST_TYPE_STANDARD, + USBVIRT_REQUEST_RECIPIENT_DEVICE), + .request = USB_DEVREQ_GET_DESCRIPTOR, + .name = "GetDescriptor", + .callback = stdreq_on_get_descriptor + }, + { + .request_type = USBVIRT_MAKE_CONTROL_REQUEST_TYPE( + USB_DIRECTION_IN, + USBVIRT_REQUEST_TYPE_CLASS, + USBVIRT_REQUEST_RECIPIENT_DEVICE), + .request = USB_DEVREQ_GET_DESCRIPTOR, + .name = "GetDescriptor", + .callback = stdreq_on_get_descriptor + }, + USBVIRT_CONTROL_TRANSFER_HANDLER_LAST +}; + +/** Keyboard callbacks. + * We abuse the fact that static variables are zero-filled. + */ +static usbvirt_device_ops_t keyboard_ops = { + .control_transfer_handlers = endpoint_zero_handlers, + .on_data = on_incoming_data, + .on_data_request = on_request_for_data +}; + +usbvirt_device_configuration_extras_t extra_descriptors[] = { + { + .data = (uint8_t *) &std_interface_descriptor, + .length = sizeof(std_interface_descriptor) + }, + { + .data = (uint8_t *) &hid_descriptor, + .length = sizeof(hid_descriptor) + }, + { + .data = (uint8_t *) &endpoint_descriptor, + .length = sizeof(endpoint_descriptor) + } +}; + +/** Keyboard configuration. */ +usbvirt_device_configuration_t configuration = { + .descriptor = &std_configuration_descriptor, + .extra = extra_descriptors, + .extra_count = sizeof(extra_descriptors)/sizeof(extra_descriptors[0]) +}; + +/** Keyboard standard descriptors. */ +usbvirt_descriptors_t descriptors = { + .device = &std_device_descriptor, + .configuration = &configuration, + .configuration_count = 1, +}; + +/** Keyboard device. + * Rest of the items will be initialized later. + */ +static usbvirt_device_t keyboard_dev = { + .ops = &keyboard_ops, + .descriptors = &descriptors, + .lib_debug_level = 3, + .lib_debug_enabled_tags = USBVIRT_DEBUGTAG_ALL, + .name = "keyboard" +}; + + +static void fibril_sleep(size_t sec) +{ + while (sec-- > 0) { + async_usleep(1000*1000); + } +} + + +/** Callback when keyboard status changed. + * + * @param status Current keyboard status. + */ +static void on_keyboard_change(kb_status_t *status) +{ + printf("%s: Current keyboard status: %02hhx", NAME, status->modifiers); + size_t i; + for (i = 0; i < KB_MAX_KEYS_AT_ONCE; i++) { + printf(" 0x%02X", (int)status->pressed_keys[i]); + } + printf("\n"); + + fibril_sleep(KEY_PRESS_DELAY); +} + +/** Simulated keyboard events. */ +static kb_event_t keyboard_events[] = { + /* Switch to VT6 (Alt+F6) */ + M_DOWN(KB_MOD_LEFT_ALT), + K_PRESS(KB_KEY_F6), + M_UP(KB_MOD_LEFT_ALT), + /* Type the word 'Hello' */ + M_DOWN(KB_MOD_LEFT_SHIFT), + K_PRESS(KB_KEY_H), + M_UP(KB_MOD_LEFT_SHIFT), + K_PRESS(KB_KEY_E), + K_PRESS(KB_KEY_L), + K_PRESS(KB_KEY_L), + K_PRESS(KB_KEY_O) +}; +static size_t keyboard_events_count = + sizeof(keyboard_events)/sizeof(keyboard_events[0]); + + + +int main(int argc, char * argv[]) +{ + printf("Dump of report descriptor (%zu bytes):\n", report_descriptor_size); + size_t i; + for (i = 0; i < report_descriptor_size; i++) { + printf(" 0x%02X", report_descriptor[i]); + if (((i > 0) && (((i+1) % 10) == 0)) + || (i + 1 == report_descriptor_size)) { + printf("\n"); + } + } + + kb_init(&status); + + + int rc = usbvirt_connect(&keyboard_dev); + if (rc != EOK) { + printf("%s: Unable to start communication with VHCD (%s).\n", + NAME, str_error(rc)); + return rc; + } + + printf("%s: Simulating keyboard events...\n", NAME); + fibril_sleep(10); + //while (1) { + kb_process_events(&status, keyboard_events, keyboard_events_count, + on_keyboard_change); + //} + + printf("%s: Terminating...\n", NAME); + + usbvirt_disconnect(&keyboard_dev); + + return 0; +} + + +/** @} + */