Index: .bzrignore =================================================================== --- .bzrignore (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ .bzrignore (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,126 @@ +# user makefile for local targets +Makefile.local + +# generated files (misc) +Makefile.depend +*.prev +*.map +*.disasm +_link.ld +./*.iso + +./Makefile.common +./Makefile.config +./common.h +./config.h +./autotool/ +./image.iso +./boot/distroot/ +./boot/initrd.fs +./boot/initrd.img +./kernel/kernel.bin +./kernel/kernel.dump +./kernel/kernel.raw +./kernel/generic/src/debug/real_map.bin + +./kernel/arch/ia32/include/common.h +./kernel/arch/amd64/include/common.h +./kernel/generic/include/arch +./kernel/generic/include/genarch +./uspace/lib/c/arch/amd64/include/common.h +./uspace/lib/c/arch/ia32/include/common.h +./uspace/lib/c/include/arch +./uspace/lib/c/include/kernel +./uspace/lib/c/include/libarch + + + + + + +# generated files (executables) +./uspace/app/bdsh/bdsh +./uspace/app/edit/edit +./uspace/app/getterm/getterm +./uspace/app/init/init +./uspace/app/klog/klog +./uspace/app/mkfat/mkfat +./uspace/app/netstart/netstart +./uspace/app/netecho/netecho +./uspace/app/nettest1/nettest1 +./uspace/app/nettest2/nettest2 +./uspace/app/ping/ping +./uspace/app/redir/redir +./uspace/app/sysinfo/sysinfo +./uspace/app/sbi/sbi +./uspace/app/stats/stats +./uspace/app/taskdump/taskdump +./uspace/app/tasks/tasks +./uspace/app/tester/tester +./uspace/app/test_serial/test_serial +./uspace/app/tetris/tetris +./uspace/app/top/top +./uspace/app/trace/trace +./uspace/app/usb/usb +./uspace/app/usbinfo/usbinfo +./uspace/app/virtusbkbd/vuk +./uspace/dist/app/* +./uspace/dist/cfg/net/general +./uspace/dist/cfg/net/lo +./uspace/dist/cfg/net/ne2k +./uspace/dist/drv/* +./uspace/dist/srv/* +./uspace/drv/root/root +./uspace/drv/isa/isa +./uspace/drv/ns8250/ns8250 +./uspace/drv/pciintel/pciintel +./uspace/drv/rootpc/rootpc +./uspace/drv/rootvirt/rootvirt +./uspace/drv/test1/test1 +./uspace/drv/test2/test2 +./uspace/drv/uhci/uhci +./uspace/drv/usbhub/usbhub +./uspace/drv/usbkbd/usbkbd +./uspace/drv/vhc/vhc +./uspace/srv/bd/ata_bd/ata_bd +./uspace/srv/bd/file_bd/file_bd +./uspace/srv/bd/gxe_bd/gxe_bd +./uspace/srv/bd/part/guid_part/g_part +./uspace/srv/bd/part/mbr_part/mbr_part +./uspace/srv/bd/rd/rd +./uspace/srv/clip/clip +./uspace/srv/devman/devman +./uspace/srv/devmap/devmap +./uspace/srv/fs/devfs/devfs +./uspace/srv/fs/fat/fat +./uspace/srv/fs/tmpfs/tmpfs +./uspace/srv/hid/adb_mouse/adb_ms +./uspace/srv/hid/char_mouse/char_ms +./uspace/srv/hid/console/console +./uspace/srv/hid/fb/fb +./uspace/srv/hid/kbd/kbd +./uspace/srv/hid/s3c24xx_ts/s3c24ts +./uspace/srv/hw/bus/pci/pci +./uspace/srv/hw/char/i8042/i8042 +./uspace/srv/hw/char/s3c24xx_uart/s3c24ser +./uspace/srv/hw/netif/dp8390/dp8390 +./uspace/srv/loader/loader +./uspace/srv/net/cfg/lo +./uspace/srv/net/cfg/ne2k +./uspace/srv/net/il/arp/arp +./uspace/srv/net/il/ip/ip +./uspace/srv/net/net/net +./uspace/srv/net/netif/lo/lo +./uspace/srv/net/netstart/netstart +./uspace/srv/net/nil/eth/eth +./uspace/srv/net/nil/nildummy/nildummy +./uspace/srv/net/tl/icmp/icmp +./uspace/srv/net/tl/tcp/tcp +./uspace/srv/net/tl/udp/udp +./uspace/srv/ns/ns +./uspace/srv/taskmon/taskmon +./uspace/srv/vfs/vfs + +# IDE files +.cproject +.project Index: HelenOS.config =================================================================== --- HelenOS.config (revision 6eb794aa8b215fdc5cb202ffc13bae94b06623b0) +++ HelenOS.config (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -547,4 +547,4 @@ % Launch (devman) test drivers -! [CONFIG_DEBUG=y] CONFIG_TEST_DRIVERS (y/n) - +! [CONFIG_DEBUG=y] CONFIG_TEST_DRIVERS (n/y) + Index: Makefile =================================================================== --- Makefile (revision 6eb794aa8b215fdc5cb202ffc13bae94b06623b0) +++ Makefile (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -92,2 +92,4 @@ $(MAKE) -C uspace clean $(MAKE) -C boot clean + +-include Makefile.local Index: boot/Makefile.common =================================================================== --- boot/Makefile.common (revision 6eb794aa8b215fdc5cb202ffc13bae94b06623b0) +++ boot/Makefile.common (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -99,4 +99,5 @@ $(USPACE_PATH)/srv/taskmon/taskmon \ $(USPACE_PATH)/srv/hw/netif/dp8390/dp8390 \ + $(USPACE_PATH)/srv/hw/bus/usb/hcd/virtual/vhcd \ $(USPACE_PATH)/srv/net/netif/lo/lo \ $(USPACE_PATH)/srv/net/il/arp/arp \ @@ -143,7 +144,9 @@ $(USPACE_PATH)/app/ping/ping \ $(USPACE_PATH)/app/stats/stats \ + $(USPACE_PATH)/app/sysinfo/sysinfo \ $(USPACE_PATH)/app/tasks/tasks \ $(USPACE_PATH)/app/top/top \ - $(USPACE_PATH)/app/sysinfo/sysinfo + $(USPACE_PATH)/app/usbinfo/usbinfo \ + $(USPACE_PATH)/app/virtusbkbd/vuk ifneq ($(CONFIG_BAREBONE),y) Index: boot/arch/amd64/Makefile.inc =================================================================== --- boot/arch/amd64/Makefile.inc (revision 6eb794aa8b215fdc5cb202ffc13bae94b06623b0) +++ boot/arch/amd64/Makefile.inc (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -40,5 +40,9 @@ pciintel \ isa \ - ns8250 + ns8250 \ + uhci \ + usbhub \ + usbkbd \ + vhc RD_DRV_CFG += \ Index: uspace/Makefile =================================================================== --- uspace/Makefile (revision 6eb794aa8b215fdc5cb202ffc13bae94b06623b0) +++ uspace/Makefile (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -49,4 +49,6 @@ app/trace \ app/top \ + app/usbinfo \ + app/virtusbkbd \ app/netecho \ app/nettest1 \ @@ -116,4 +118,8 @@ DIRS += drv/isa DIRS += drv/ns8250 + DIRS += drv/uhci + DIRS += drv/usbhub + DIRS += drv/usbkbd + DIRS += drv/vhc endif @@ -123,4 +129,8 @@ DIRS += drv/isa DIRS += drv/ns8250 + DIRS += drv/uhci + DIRS += drv/usbhub + DIRS += drv/usbkbd + DIRS += drv/vhc endif @@ -148,4 +158,14 @@ lib/packet \ lib/net + +ifeq ($(UARCH),amd64) + LIBS += lib/usb + LIBS += lib/usbvirt +endif + +ifeq ($(UARCH),ia32) + LIBS += lib/usb + LIBS += lib/usbvirt +endif LIBC_BUILD = $(addsuffix .build,$(LIBC)) Index: uspace/Makefile.common =================================================================== --- uspace/Makefile.common (revision 6eb794aa8b215fdc5cb202ffc13bae94b06623b0) +++ uspace/Makefile.common (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -86,4 +86,7 @@ LIBCLUI_PREFIX = $(LIB_PREFIX)/clui + +LIBUSB_PREFIX = $(LIB_PREFIX)/usb +LIBUSBVIRT_PREFIX = $(LIB_PREFIX)/usbvirt LIBDRV_PREFIX = $(LIB_PREFIX)/drv LIBPACKET_PREFIX = $(LIB_PREFIX)/packet Index: uspace/app/init/init.c =================================================================== --- uspace/app/init/init.c (revision 6eb794aa8b215fdc5cb202ffc13bae94b06623b0) +++ uspace/app/init/init.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -312,4 +312,5 @@ getterm("term/vc5", "/app/bdsh", false); getterm("term/vc6", "/app/klog", false); + getterm("term/vc7", "/srv/devman", false); return 0; Index: uspace/app/tester/Makefile =================================================================== --- uspace/app/tester/Makefile (revision 6eb794aa8b215fdc5cb202ffc13bae94b06623b0) +++ uspace/app/tester/Makefile (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -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 \ Index: uspace/app/tester/adt/usbaddrkeep.c =================================================================== --- uspace/app/tester/adt/usbaddrkeep.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/app/tester/adt/usbaddrkeep.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -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 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/app/tester/adt/usbaddrkeep.def (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,6 @@ +{ + "usbaddrkeep", + "USB address keeping structure", + &test_usbaddrkeep, + true +}, Index: uspace/app/tester/tester.c =================================================================== --- uspace/app/tester/tester.c (revision 6eb794aa8b215fdc5cb202ffc13bae94b06623b0) +++ uspace/app/tester/tester.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -63,4 +63,5 @@ #include "mm/malloc1.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 6eb794aa8b215fdc5cb202ffc13bae94b06623b0) +++ uspace/app/tester/tester.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -80,4 +80,5 @@ extern const char *test_malloc1(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 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/app/usbinfo/Makefile (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,39 @@ +# +# 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 = \ + dump.c \ + main.c + +include $(USPACE_PREFIX)/Makefile.common Index: uspace/app/usbinfo/dump.c =================================================================== --- uspace/app/usbinfo/dump.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/app/usbinfo/dump.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,129 @@ +/* + * 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 usb + * @{ + */ +/** + * @file + * @brief USB querying. + */ + +#include +#include +#include +#include +#include + +#include +#include + +#include "usbinfo.h" + +#define INDENT " " +#define BYTES_PER_LINE 12 + +#define BCD_INT(a) (((unsigned int)(a)) / 256) +#define BCD_FRAC(a) (((unsigned int)(a)) % 256) + +#define BCD_FMT "%x.%x" +#define BCD_ARGS(a) BCD_INT((a)), BCD_FRAC((a)) + +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"); + } + } +} + +void dump_match_ids(match_id_list_t *matches) +{ + printf("Match ids:\n"); + 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(INDENT "%d %s\n", match->score, match->id); + } +} + +void dump_standard_device_descriptor(usb_standard_device_descriptor_t *d) +{ + printf("Standard device descriptor:\n"); + + printf(INDENT "bLength = %d\n", d->length); + printf(INDENT "bDescriptorType = 0x%02x\n", d->descriptor_type); + printf(INDENT "bcdUSB = %d (" BCD_FMT ")\n", d->usb_spec_version, + BCD_ARGS(d->usb_spec_version)); + printf(INDENT "bDeviceClass = 0x%02x\n", d->device_class); + printf(INDENT "bDeviceSubClass = 0x%02x\n", d->device_subclass); + printf(INDENT "bDeviceProtocol = 0x%02x\n", d->device_protocol); + printf(INDENT "bMaxPacketSize0 = %d\n", d->max_packet_size); + printf(INDENT "idVendor = %d\n", d->vendor_id); + printf(INDENT "idProduct = %d\n", d->product_id); + printf(INDENT "bcdDevice = %d\n", d->device_version); + printf(INDENT "iManufacturer = %d\n", d->str_manufacturer); + printf(INDENT "iProduct = %d\n", d->str_product); + printf(INDENT "iSerialNumber = %d\n", d->str_serial_number); + printf(INDENT "bNumConfigurations = %d\n", d->configuration_count); +} + +void dump_standard_configuration_descriptor( + int index, usb_standard_configuration_descriptor_t *d) +{ + bool self_powered = d->attributes & 64; + bool remote_wakeup = d->attributes & 32; + + printf("Standard configuration descriptor #%d\n", index); + printf(INDENT "bLength = %d\n", d->length); + printf(INDENT "bDescriptorType = 0x%02x\n", d->descriptor_type); + printf(INDENT "wTotalLength = %d\n", d->total_length); + printf(INDENT "bNumInterfaces = %d\n", d->interface_count); + printf(INDENT "bConfigurationValue = %d\n", d->configuration_number); + printf(INDENT "iConfiguration = %d\n", d->str_configuration); + printf(INDENT "bmAttributes = %d [%s%s%s]\n", d->attributes, + self_powered ? "self-powered" : "", + (self_powered & remote_wakeup) ? ", " : "", + remote_wakeup ? "remote-wakeup" : ""); + printf(INDENT "MaxPower = %d (%dmA)\n", d->max_power, + 2 * d->max_power); + // printf(INDENT " = %d\n", d->); +} + + +/** @} + */ Index: uspace/app/usbinfo/main.c =================================================================== --- uspace/app/usbinfo/main.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/app/usbinfo/main.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,188 @@ +/* + * 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 usb + * @{ + */ +/** + * @file + * @brief USB querying. + */ + +#include +#include +#include +#include +#include +#include +#include +#include "usbinfo.h" + +#define DEFAULT_HOST_CONTROLLER_PATH "/virt/usbhc" + +static void print_usage(char *app_name) +{ + printf(NAME ": query USB devices for descriptors\n\n"); + printf("Usage: %s /path/to/hc usb-address\n where\n", app_name); + printf(" /path/to/hc Devman path to USB host controller " \ + "(use `-' for\n"); + printf(" default HC at `%s').\n", + DEFAULT_HOST_CONTROLLER_PATH); + printf(" usb-address USB address of device to be queried\n"); + printf("\n"); +} + +static int connect_to_hc(const char *path) +{ + int rc; + devman_handle_t handle; + + rc = devman_device_get_handle(path, &handle, 0); + if (rc != EOK) { + return rc; + } + + int phone = devman_device_connect(handle, 0); + + return phone; +} + +int main(int argc, char *argv[]) +{ + if (argc != 3) { + print_usage(argv[0]); + return EINVAL; + } + + char *hc_path = argv[1]; + long int address_long = strtol(argv[2], NULL, 0); + + /* + * Connect to given host controller driver. + */ + if (str_cmp(hc_path, "-") == 0) { + hc_path = (char *) DEFAULT_HOST_CONTROLLER_PATH; + } + int hc_phone = connect_to_hc(hc_path); + if (hc_phone < 0) { + fprintf(stderr, + NAME ": unable to connect to HC at `%s': %s.\n", + hc_path, str_error(hc_phone)); + return hc_phone; + } + + /* + * Verify address is okay. + */ + usb_address_t address = (usb_address_t) address_long; + if ((address < 0) || (address >= USB11_ADDRESS_MAX)) { + fprintf(stderr, NAME ": USB address out of range.\n"); + return ERANGE; + } + + /* + * Now, learn information about the device. + */ + int rc; + + /* + * Dump information about possible match ids. + */ + match_id_list_t match_id_list; + init_match_ids(&match_id_list); + rc = usb_drv_create_device_match_ids(hc_phone, &match_id_list, address); + if (rc != EOK) { + fprintf(stderr, + NAME ": failed to fetch match ids of the device: %s.\n", + str_error(rc)); + return rc; + } + dump_match_ids(&match_id_list); + + /* + * Get device descriptor and dump it. + */ + usb_standard_device_descriptor_t device_descriptor; + usb_dprintf(NAME, 1, + "usb_drv_req_get_device_descriptor(%d, %d, %p)\n", + hc_phone, (int) address, &device_descriptor); + + rc = usb_drv_req_get_device_descriptor(hc_phone, address, + &device_descriptor); + if (rc != EOK) { + fprintf(stderr, + NAME ": failed to fetch standard device descriptor: %s.\n", + str_error(rc)); + return rc; + } + dump_standard_device_descriptor(&device_descriptor); + + /* + * Get first configuration descriptor and dump it. + */ + usb_standard_configuration_descriptor_t config_descriptor; + int config_index = 0; + usb_dprintf(NAME, 1, + "usb_drv_req_get_bare_configuration_descriptor(%d, %d, %d, %p)\n", + hc_phone, (int) address, config_index, &config_descriptor); + + rc = usb_drv_req_get_bare_configuration_descriptor(hc_phone, address, + config_index, &config_descriptor ); + if (rc != EOK) { + fprintf(stderr, + NAME ": failed to fetch standard configuration descriptor: %s.\n", + str_error(rc)); + return rc; + } + dump_standard_configuration_descriptor(config_index, + &config_descriptor); + + void *full_config_descriptor = malloc(config_descriptor.total_length); + usb_dprintf(NAME, 1, + "usb_drv_req_get_full_configuration_descriptor(%d, %d, %d, %p, %zu)\n", + hc_phone, (int) address, config_index, + full_config_descriptor, config_descriptor.total_length); + + rc = usb_drv_req_get_full_configuration_descriptor(hc_phone, address, + config_index, + full_config_descriptor, config_descriptor.total_length, NULL); + if (rc != EOK) { + fprintf(stderr, + NAME ": failed to fetch full configuration descriptor: %s.\n", + str_error(rc)); + return rc; + } + dump_buffer("Full configuration descriptor:", + full_config_descriptor, config_descriptor.total_length); + + return EOK; +} + + +/** @} + */ Index: uspace/app/usbinfo/usbinfo.h =================================================================== --- uspace/app/usbinfo/usbinfo.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/app/usbinfo/usbinfo.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,55 @@ +/* + * 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 usb + * @{ + */ +/** @file + * @brief Common header for usbinfo application. + */ +#ifndef USBINFO_USBINFO_H_ +#define USBINFO_USBINFO_H_ + +#include +#include +#include +#include + + +#define NAME "usbinfo" + +void dump_buffer(const char *, const uint8_t *, size_t); +void dump_match_ids(match_id_list_t *matches); +void dump_standard_device_descriptor(usb_standard_device_descriptor_t *); +void dump_standard_configuration_descriptor(int, + usb_standard_configuration_descriptor_t *); + +#endif +/** + * @} + */ Index: uspace/app/virtusbkbd/Makefile =================================================================== --- uspace/app/virtusbkbd/Makefile (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/app/virtusbkbd/Makefile (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -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 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/app/virtusbkbd/descriptor.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -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 usb + * @{ + */ +/** @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 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/app/virtusbkbd/items.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -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 usb + * @{ + */ +/** @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 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/app/virtusbkbd/kbdconfig.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -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 usb + * @{ + */ +/** + * @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 = 0, + .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 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/app/virtusbkbd/kbdconfig.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -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 usb + * @{ + */ +/** @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 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/app/virtusbkbd/keys.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -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 usb + * @{ + */ +/** + * @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 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/app/virtusbkbd/keys.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -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 usb + * @{ + */ +/** @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 4 + +/** 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 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/app/virtusbkbd/report.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -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 usb + * @{ + */ +/** @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 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/app/virtusbkbd/stdreq.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -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 usb + * @{ + */ +/** + * @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 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/app/virtusbkbd/stdreq.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -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 usb + * @{ + */ +/** @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 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/app/virtusbkbd/virtusbkbd.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -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 usb + * @{ + */ +/** + * @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; +} + + +/** @} + */ Index: uspace/doc/doxygroups.h =================================================================== --- uspace/doc/doxygroups.h (revision 6eb794aa8b215fdc5cb202ffc13bae94b06623b0) +++ uspace/doc/doxygroups.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -155,5 +155,5 @@ * @endcond */ - + /** * @defgroup emul Emulation Libraries @@ -170,2 +170,13 @@ * @ingroup emul */ + +/** + * @defgroup usb USB + * @ingroup uspace + * @brief USB support for HelenOS. + */ + /** + * @defgroup libusb USB library + * @ingroup usb + * @brief Library for creating USB devices drivers. + */ Index: uspace/drv/root/root.c =================================================================== --- uspace/drv/root/root.c (revision 6eb794aa8b215fdc5cb202ffc13bae94b06623b0) +++ uspace/drv/root/root.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -88,5 +88,6 @@ int res = child_device_register_wrapper(parent, VIRTUAL_DEVICE_NAME, - VIRTUAL_DEVICE_MATCH_ID, VIRTUAL_DEVICE_MATCH_SCORE); + VIRTUAL_DEVICE_MATCH_ID, VIRTUAL_DEVICE_MATCH_SCORE, + NULL); return res; @@ -136,5 +137,5 @@ res = child_device_register_wrapper(parent, PLATFORM_DEVICE_NAME, - match_id, PLATFORM_DEVICE_MATCH_SCORE); + match_id, PLATFORM_DEVICE_MATCH_SCORE, NULL); return res; Index: uspace/drv/rootvirt/devices.def =================================================================== --- uspace/drv/rootvirt/devices.def (revision 6eb794aa8b215fdc5cb202ffc13bae94b06623b0) +++ uspace/drv/rootvirt/devices.def (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -22,2 +22,7 @@ }, #endif +/* Virtual USB host controller. */ +{ + .name = "usbhc", + .match_id = "usb&hc=vhc" +}, Index: uspace/drv/rootvirt/rootvirt.c =================================================================== --- uspace/drv/rootvirt/rootvirt.c (revision 6eb794aa8b215fdc5cb202ffc13bae94b06623b0) +++ uspace/drv/rootvirt/rootvirt.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -84,5 +84,5 @@ int rc = child_device_register_wrapper(parent, virt_dev->name, - virt_dev->match_id, 10); + virt_dev->match_id, 10, NULL); if (rc == EOK) { Index: uspace/drv/test1/test1.c =================================================================== --- uspace/drv/test1/test1.c (revision 6eb794aa8b215fdc5cb202ffc13bae94b06623b0) +++ uspace/drv/test1/test1.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -62,5 +62,5 @@ int rc = child_device_register_wrapper(parent, name, - match_id, match_score); + match_id, match_score, NULL); if (rc == EOK) { Index: uspace/drv/test2/test2.c =================================================================== --- uspace/drv/test2/test2.c (revision 6eb794aa8b215fdc5cb202ffc13bae94b06623b0) +++ uspace/drv/test2/test2.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -64,5 +64,5 @@ int rc = child_device_register_wrapper(parent, name, - match_id, match_score); + match_id, match_score, NULL); if (rc == EOK) { Index: uspace/drv/uhci/Makefile =================================================================== --- uspace/drv/uhci/Makefile (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/drv/uhci/Makefile (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,38 @@ +# +# 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 = ../.. +LIBS = $(LIBDRV_PREFIX)/libdrv.a $(LIBUSB_PREFIX)/libusb.a +EXTRA_CFLAGS += -I$(LIBDRV_PREFIX)/include -I$(LIBUSB_PREFIX)/include +BINARY = uhci + +SOURCES = \ + main.c \ + transfers.c + +include $(USPACE_PREFIX)/Makefile.common Index: uspace/drv/uhci/main.c =================================================================== --- uspace/drv/uhci/main.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/drv/uhci/main.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,70 @@ +/* + * 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 "uhci.h" + +static device_ops_t uhci_ops = { + .interfaces[USBHC_DEV_IFACE] = &uhci_iface, +}; + +static int uhci_add_device(device_t *device) +{ + usb_dprintf(NAME, 1, "uhci_add_device() called\n"); + device->ops = &uhci_ops; + + /* + * We need to announce the presence of our root hub. + */ + usb_dprintf(NAME, 2, "adding root hub\n"); + usb_hcd_add_root_hub(device); + + return EOK; +} + +static driver_ops_t uhci_driver_ops = { + .add_device = uhci_add_device, +}; + +static driver_t uhci_driver = { + .name = NAME, + .driver_ops = &uhci_driver_ops +}; + +int main(int argc, char *argv[]) +{ + /* + * Do some global initializations. + */ + sleep(5); + usb_dprintf_enable(NAME, 5); + + return driver_main(&uhci_driver); +} Index: uspace/drv/uhci/transfers.c =================================================================== --- uspace/drv/uhci/transfers.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/drv/uhci/transfers.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,160 @@ +/* + * 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 "uhci.h" + +static int enqueue_transfer_out(device_t *dev, + usb_target_t target, usb_transfer_type_t transfer_type, + void *buffer, size_t size, + usbhc_iface_transfer_out_callback_t callback, void *arg) +{ + printf(NAME ": transfer OUT [%d.%d (%s); %zu]\n", + target.address, target.endpoint, + usb_str_transfer_type(transfer_type), + size); + + return ENOTSUP; +} + +static int enqueue_transfer_setup(device_t *dev, + usb_target_t target, usb_transfer_type_t transfer_type, + void *buffer, size_t size, + usbhc_iface_transfer_out_callback_t callback, void *arg) +{ + printf(NAME ": transfer SETUP [%d.%d (%s); %zu]\n", + target.address, target.endpoint, + usb_str_transfer_type(transfer_type), + size); + + return ENOTSUP; +} + +static int enqueue_transfer_in(device_t *dev, + usb_target_t target, usb_transfer_type_t transfer_type, + void *buffer, size_t size, + usbhc_iface_transfer_in_callback_t callback, void *arg) +{ + printf(NAME ": transfer IN [%d.%d (%s); %zu]\n", + target.address, target.endpoint, + usb_str_transfer_type(transfer_type), + size); + + return ENOTSUP; +} + + +static int get_address(device_t *dev, devman_handle_t handle, + usb_address_t *address) +{ + return ENOTSUP; +} + +static int interrupt_out(device_t *dev, usb_target_t target, + void *data, size_t size, + usbhc_iface_transfer_out_callback_t callback, void *arg) +{ + return enqueue_transfer_out(dev, target, USB_TRANSFER_INTERRUPT, + data, size, + callback, arg); +} + +static int interrupt_in(device_t *dev, usb_target_t target, + void *data, size_t size, + usbhc_iface_transfer_in_callback_t callback, void *arg) +{ + return enqueue_transfer_in(dev, target, USB_TRANSFER_INTERRUPT, + data, size, + callback, arg); +} + +static int control_write_setup(device_t *dev, usb_target_t target, + void *data, size_t size, + usbhc_iface_transfer_out_callback_t callback, void *arg) +{ + return enqueue_transfer_setup(dev, target, USB_TRANSFER_CONTROL, + data, size, + callback, arg); +} + +static int control_write_data(device_t *dev, usb_target_t target, + void *data, size_t size, + usbhc_iface_transfer_out_callback_t callback, void *arg) +{ + return enqueue_transfer_out(dev, target, USB_TRANSFER_CONTROL, + data, size, + callback, arg); +} + +static int control_write_status(device_t *dev, usb_target_t target, + usbhc_iface_transfer_in_callback_t callback, void *arg) +{ + return enqueue_transfer_in(dev, target, USB_TRANSFER_CONTROL, + NULL, 0, + callback, arg); +} + +static int control_read_setup(device_t *dev, usb_target_t target, + void *data, size_t size, + usbhc_iface_transfer_out_callback_t callback, void *arg) +{ + return enqueue_transfer_setup(dev, target, USB_TRANSFER_CONTROL, + data, size, + callback, arg); +} + +static int control_read_data(device_t *dev, usb_target_t target, + void *data, size_t size, + usbhc_iface_transfer_in_callback_t callback, void *arg) +{ + return enqueue_transfer_in(dev, target, USB_TRANSFER_CONTROL, + data, size, + callback, arg); +} + +static int control_read_status(device_t *dev, usb_target_t target, + usbhc_iface_transfer_out_callback_t callback, void *arg) +{ + return enqueue_transfer_out(dev, target, USB_TRANSFER_CONTROL, + NULL, 0, + callback, arg); +} + + +usbhc_iface_t uhci_iface = { + .tell_address = get_address, + .interrupt_out = interrupt_out, + .interrupt_in = interrupt_in, + .control_write_setup = control_write_setup, + .control_write_data = control_write_data, + .control_write_status = control_write_status, + .control_read_setup = control_read_setup, + .control_read_data = control_read_data, + .control_read_status = control_read_status +}; Index: uspace/drv/uhci/uhci.h =================================================================== --- uspace/drv/uhci/uhci.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/drv/uhci/uhci.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,47 @@ +/* + * 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 usb + * @{ + */ +/** @file + * @brief UHCI driver + */ +#ifndef DRV_UHCI_UHCI_H +#define DRV_UHCI_UHCI_H + +#include + +#define NAME "uhci" + +usbhc_iface_t uhci_iface; + +#endif +/** + * @} + */ Index: uspace/drv/uhci/uhci.ma =================================================================== --- uspace/drv/uhci/uhci.ma (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/drv/uhci/uhci.ma (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,2 @@ +10 pci/ven=8086&dev=7020 + Index: uspace/drv/usbhub/Makefile =================================================================== --- uspace/drv/usbhub/Makefile (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/drv/usbhub/Makefile (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,40 @@ +# +# 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 = ../.. +LIBS = $(LIBDRV_PREFIX)/libdrv.a $(LIBUSB_PREFIX)/libusb.a +EXTRA_CFLAGS += -I$(LIBDRV_PREFIX)/include -I$(LIBUSB_PREFIX)/include +BINARY = usbhub + +SOURCES = \ + main.c \ + utils.c \ + usbhub.c \ + usblist.c + +include $(USPACE_PREFIX)/Makefile.common Index: uspace/drv/usbhub/main.c =================================================================== --- uspace/drv/usbhub/main.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/drv/usbhub/main.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,72 @@ +/* + * 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 "usbhub.h" +#include "usbhub_private.h" + + +usb_general_list_t usb_hub_list; + +static driver_ops_t hub_driver_ops = { + .add_device = usb_add_hub_device, +}; + +static driver_t hub_driver = { + .name = "usbhub", + .driver_ops = &hub_driver_ops +}; + +int usb_hub_control_loop(void * noparam){ + while(true){ + usb_hub_check_hub_changes(); + async_usleep(1000 * 1000); + } + return 0; +} + + +int main(int argc, char *argv[]) +{ + usb_dprintf_enable(NAME,1); + usb_lst_init(&usb_hub_list); + fid_t fid = fibril_create(usb_hub_control_loop, NULL); + if (fid == 0) { + dprintf(1, "failed to start fibril for HUB devices"); + //printf("%s: failed to start fibril for HUB devices\n", NAME); + return ENOMEM; + } + fibril_add_ready(fid); + + return driver_main(&hub_driver); +} Index: uspace/drv/usbhub/port_status.h =================================================================== --- uspace/drv/usbhub/port_status.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/drv/usbhub/port_status.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,303 @@ +/* + * Copyright (c) 2010 Matus Dekanek + * 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. + */ + +#ifndef PORT_STATUS_H +#define PORT_STATUS_H + +#include +#include +#include +#include "usbhub_private.h" + +/** + * structure holding port status and changes flags. + * should not be accessed directly, use supplied getter/setter methods. + * + * For more information refer to table 11-15 in + * "Universal Serial Bus Specification Revision 1.1" + * + */ +typedef uint32_t usb_port_status_t; + +/** + * set values in request to be it a port status request + * @param request + * @param port + */ +static inline void usb_hub_set_port_status_request( +usb_device_request_setup_packet_t * request, uint16_t port +){ + request->index = port; + request->request_type = USB_HUB_REQ_TYPE_GET_PORT_STATUS; + request->request = USB_HUB_REQUEST_GET_STATUS; + request->value = 0; + request->length = 4; +} + + +/** + * create request for usb hub port status + * @param port + * @return + */ +static inline usb_device_request_setup_packet_t * +usb_hub_create_port_status_request(uint16_t port){ + usb_device_request_setup_packet_t * result = + usb_new(usb_device_request_setup_packet_t); + usb_hub_set_port_status_request(result,port); + return result; +} + + +/** + * set the device request to be a port enable request + * @param request + * @param port + */ +static inline void usb_hub_set_enable_port_request( +usb_device_request_setup_packet_t * request, uint16_t port +){ + request->index = port; + request->request_type = USB_HUB_REQ_TYPE_SET_PORT_FEATURE; + request->request = USB_HUB_REQUEST_SET_FEATURE; + request->value = USB_HUB_FEATURE_C_PORT_ENABLE; + request->length = 0; +} + +/** + * enable specified port + * @param port + * @return + */ +static inline usb_device_request_setup_packet_t * +usb_hub_create_enable_port_request(uint16_t port){ + usb_device_request_setup_packet_t * result = + usb_new(usb_device_request_setup_packet_t); + usb_hub_set_enable_port_request(result,port); + return result; +} + +/** + * set the device request to be a port disable request + * @param request + * @param port + */ +static inline void usb_hub_set_disable_port_request( +usb_device_request_setup_packet_t * request, uint16_t port +){ + request->index = port; + request->request_type = USB_HUB_REQ_TYPE_SET_PORT_FEATURE; + request->request = USB_HUB_REQUEST_SET_FEATURE; + request->value = USB_HUB_FEATURE_C_PORT_SUSPEND; + request->length = 0; +} + +/** + * disable specified port + * @param port + * @return + */ +static inline usb_device_request_setup_packet_t * +usb_hub_create_disable_port_request(uint16_t port){ + usb_device_request_setup_packet_t * result = + usb_new(usb_device_request_setup_packet_t); + usb_hub_set_disable_port_request(result,port); + return result; +} + +/** + * set the device request to be a port disable request + * @param request + * @param port + */ +static inline void usb_hub_set_reset_port_request( +usb_device_request_setup_packet_t * request, uint16_t port +){ + request->index = port; + request->request_type = USB_HUB_REQ_TYPE_SET_PORT_FEATURE; + request->request = USB_HUB_REQUEST_SET_FEATURE; + request->value = USB_HUB_FEATURE_PORT_RESET; + request->length = 0; +} + +/** + * disable specified port + * @param port + * @return + */ +static inline usb_device_request_setup_packet_t * +usb_hub_create_reset_port_request(uint16_t port){ + usb_device_request_setup_packet_t * result = + usb_new(usb_device_request_setup_packet_t); + usb_hub_set_reset_port_request(result,port); + return result; +} + +/** + * set the device request to be a port disable request + * @param request + * @param port + */ +static inline void usb_hub_set_power_port_request( +usb_device_request_setup_packet_t * request, uint16_t port +){ + request->index = port; + request->request_type = USB_HUB_REQ_TYPE_SET_PORT_FEATURE; + request->request = USB_HUB_REQUEST_SET_FEATURE; + request->value = USB_HUB_FEATURE_PORT_POWER; + request->length = 0; +} + +/** get i`th bit of port status */ +static inline bool usb_port_get_bit(usb_port_status_t * status, int idx) +{ + return (((*status)>>(idx))%2); +} + +/** set i`th bit of port status */ +static inline void usb_port_set_bit( + usb_port_status_t * status, int idx, bool value) +{ + (*status) = value? + ((*status)|(1<<(idx))): + ((*status)&(~(1<<(idx)))); +} + +//device connnected on port +static inline bool usb_port_dev_connected(usb_port_status_t * status){ + return usb_port_get_bit(status,0); +} + +static inline void usb_port_set_dev_connected(usb_port_status_t * status,bool connected){ + usb_port_set_bit(status,0,connected); +} + +//port enabled +static inline bool usb_port_enabled(usb_port_status_t * status){ + return usb_port_get_bit(status,1); +} + +static inline void usb_port_set_enabled(usb_port_status_t * status,bool enabled){ + usb_port_set_bit(status,1,enabled); +} + +//port suspended +static inline bool usb_port_suspended(usb_port_status_t * status){ + return usb_port_get_bit(status,2); +} + +static inline void usb_port_set_suspended(usb_port_status_t * status,bool suspended){ + usb_port_set_bit(status,2,suspended); +} + +//over currect +static inline bool usb_port_over_current(usb_port_status_t * status){ + return usb_port_get_bit(status,3); +} + +static inline void usb_port_set_over_current(usb_port_status_t * status,bool value){ + usb_port_set_bit(status,3,value); +} + +//port reset +static inline bool usb_port_reset(usb_port_status_t * status){ + return usb_port_get_bit(status,4); +} + +static inline void usb_port_set_reset(usb_port_status_t * status,bool value){ + usb_port_set_bit(status,4,value); +} + +//powered +static inline bool usb_port_powered(usb_port_status_t * status){ + return usb_port_get_bit(status,8); +} + +static inline void usb_port_set_powered(usb_port_status_t * status,bool powered){ + usb_port_set_bit(status,8,powered); +} + +//low speed device attached +static inline bool usb_port_low_speed(usb_port_status_t * status){ + return usb_port_get_bit(status,9); +} + +static inline void usb_port_set_low_speed(usb_port_status_t * status,bool low_speed){ + usb_port_set_bit(status,9,low_speed); +} + + +//connect change +static inline bool usb_port_connect_change(usb_port_status_t * status){ + return usb_port_get_bit(status,16); +} + +static inline void usb_port_set_connect_change(usb_port_status_t * status,bool change){ + usb_port_set_bit(status,16,change); +} + +//port enable change +static inline bool usb_port_enabled_change(usb_port_status_t * status){ + return usb_port_get_bit(status,17); +} + +static inline void usb_port_set_enabled_change(usb_port_status_t * status,bool change){ + usb_port_set_bit(status,17,change); +} + +//suspend change +static inline bool usb_port_suspend_change(usb_port_status_t * status){ + return usb_port_get_bit(status,18); +} + +static inline void usb_port_set_suspend_change(usb_port_status_t * status,bool change){ + usb_port_set_bit(status,18,change); +} + +//over current change +static inline bool usb_port_overcurrent_change(usb_port_status_t * status){ + return usb_port_get_bit(status,19); +} + +static inline void usb_port_set_overcurrent_change(usb_port_status_t * status,bool change){ + usb_port_set_bit(status,19,change); +} + +//reset change +static inline bool usb_port_reset_completed(usb_port_status_t * status){ + return usb_port_get_bit(status,20); +} + +static inline void usb_port_set_reset_completed(usb_port_status_t * status,bool completed){ + usb_port_set_bit(status,20,completed); +} + + + +#endif /* PORT_STATUS_H */ + Index: uspace/drv/usbhub/usbhub.c =================================================================== --- uspace/drv/usbhub/usbhub.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/drv/usbhub/usbhub.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,511 @@ +/* + * Copyright (c) 2010 Matus Dekanek + * 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 usb hub driver + * @{ + */ +/** @file + * @brief usb hub main functionality + */ + +#include +#include +#include + +#include +#include +#include +#include +#include + +#include "usbhub.h" +#include "usbhub_private.h" +#include "port_status.h" + +//********************************************* +// +// hub driver code, initialization +// +//********************************************* + +usb_hub_info_t * usb_create_hub_info(device_t * device, int hc) { + usb_hub_info_t* result = usb_new(usb_hub_info_t); + //result->device = device; + result->port_count = -1; + /// \TODO is this correct? is the device stored? + result->device = device; + + + //printf("[usb_hub] phone to hc = %d\n", hc); + if (hc < 0) { + return result; + } + //get some hub info + usb_address_t addr = usb_drv_get_my_address(hc, device); + dprintf(1,"[usb_hub] addres of newly created hub = %d", addr); + /*if(addr<0){ + //return result; + + }*/ + + result->usb_device = usb_new(usb_hcd_attached_device_info_t); + result->usb_device->address = addr; + + // get hub descriptor + usb_target_t target; + target.address = addr; + target.endpoint = 0; + usb_device_request_setup_packet_t request; + //printf("[usb_hub] creating descriptor request\n"); + usb_hub_set_descriptor_request(&request); + + //printf("[usb_hub] creating serialized descriptor\n"); + void * serialized_descriptor = malloc(USB_HUB_MAX_DESCRIPTOR_SIZE); + usb_hub_descriptor_t * descriptor; + size_t received_size; + int opResult; + //printf("[usb_hub] starting control transaction\n"); + opResult = usb_drv_sync_control_read( + hc, target, &request, serialized_descriptor, + USB_HUB_MAX_DESCRIPTOR_SIZE, &received_size); + if (opResult != EOK) { + dprintf(1,"[usb_hub] failed when receiving hub descriptor, badcode = %d",opResult); + free(serialized_descriptor); + return result; + } + //printf("[usb_hub] deserializing descriptor\n"); + descriptor = usb_deserialize_hub_desriptor(serialized_descriptor); + if(descriptor==NULL){ + dprintf(1,"[usb_hub] could not deserialize descriptor "); + result->port_count = 1;///\TODO this code is only for debug!!! + return result; + } + //printf("[usb_hub] setting port count to %d\n",descriptor->ports_count); + result->port_count = descriptor->ports_count; + result->attached_devs = (usb_hub_attached_device_t*) + malloc((result->port_count+1) * sizeof(usb_hub_attached_device_t)); + int i; + for(i=0;iport_count+1;++i){ + result->attached_devs[i].devman_handle=0; + result->attached_devs[i].address=0; + } + //printf("[usb_hub] freeing data\n"); + free(serialized_descriptor); + free(descriptor->devices_removable); + free(descriptor); + + //finish + + dprintf(1,"[usb_hub] hub info created"); + + return result; +} + +int usb_add_hub_device(device_t *dev) { + dprintf(1, "add_hub_device(handle=%d)", (int) dev->handle); + dprintf(1,"[usb_hub] hub device"); + + /* + * We are some (probably deeply nested) hub. + * Thus, assign our own operations and explore already + * connected devices. + */ + + //create the hub structure + //get hc connection + int hc = usb_drv_hc_connect(dev, 0); + + usb_hub_info_t * hub_info = usb_create_hub_info(dev, hc); + int port; + int opResult; + usb_device_request_setup_packet_t request; + usb_target_t target; + target.address = hub_info->usb_device->address; + target.endpoint = 0; + + //get configuration descriptor + // this is not fully correct - there are more configurations + // and all should be checked + usb_standard_device_descriptor_t std_descriptor; + opResult = usb_drv_req_get_device_descriptor(hc, target.address, + &std_descriptor); + if(opResult!=EOK){ + dprintf(1,"[usb_hub] could not get device descriptor, %d",opResult); + return opResult; + } + dprintf(1,"[usb_hub] hub has %d configurations",std_descriptor.configuration_count); + if(std_descriptor.configuration_count<1){ + dprintf(1,"[usb_hub] THERE ARE NO CONFIGURATIONS AVAILABLE"); + } + usb_standard_configuration_descriptor_t config_descriptor; + opResult = usb_drv_req_get_bare_configuration_descriptor(hc, + target.address, 0, + &config_descriptor); + if(opResult!=EOK){ + dprintf(1,"[usb_hub] could not get configuration descriptor, %d",opResult); + return opResult; + } + //set configuration + request.request_type = 0; + request.request = USB_DEVREQ_SET_CONFIGURATION; + request.index=0; + request.length=0; + request.value_high=0; + request.value_low = config_descriptor.configuration_number; + opResult = usb_drv_sync_control_write(hc, target, &request, NULL, 0); + if (opResult != EOK) { + dprintf(1,"[usb_hub]something went wrong when setting hub`s configuration, %d", opResult); + } + + + for (port = 1; port < hub_info->port_count+1; ++port) { + usb_hub_set_power_port_request(&request, port); + opResult = usb_drv_sync_control_write(hc, target, &request, NULL, 0); + dprintf(1,"[usb_hub] powering port %d",port); + if (opResult != EOK) { + dprintf(1,"[usb_hub]something went wrong when setting hub`s %dth port", port); + } + } + //ports powered, hub seems to be enabled + + + ipc_hangup(hc); + + //add the hub to list + usb_lst_append(&usb_hub_list, hub_info); + dprintf(1,"[usb_hub] hub info added to list"); + //(void)hub_info; + usb_hub_check_hub_changes(); + + + + dprintf(1,"[usb_hub] hub dev added"); + dprintf(1,"\taddress %d, has %d ports ", + hub_info->usb_device->address, + hub_info->port_count); + dprintf(1,"\tused configuration %d",config_descriptor.configuration_number); + + return EOK; + //return ENOTSUP; +} + + + +//********************************************* +// +// hub driver code, main loop +// +//********************************************* + +/** + * reset the port with new device and reserve the default address + * @param hc + * @param port + * @param target + */ +static void usb_hub_init_add_device(int hc, uint16_t port, usb_target_t target) { + usb_device_request_setup_packet_t request; + int opResult; + dprintf(1,"[usb_hub] some connection changed"); + //get default address + opResult = usb_drv_reserve_default_address(hc); + if (opResult != EOK) { + dprintf(1,"[usb_hub] cannot assign default address, it is probably used"); + return; + } + //reset port + usb_hub_set_reset_port_request(&request, port); + opResult = usb_drv_sync_control_write( + hc, target, + &request, + NULL, 0 + ); + if (opResult != EOK) { + dprintf(1,"[usb_hub] something went wrong when reseting a port"); + } +} + +/** + * convenience function for releasing default address and writing debug info + * (these few lines are used too often to be written again and again) + * @param hc + * @return + */ +inline static int usb_hub_release_default_address(int hc){ + int opResult; + dprintf(1,"[usb_hub] releasing default address"); + opResult = usb_drv_release_default_address(hc); + if (opResult != EOK) { + dprintf(1,"[usb_hub] failed to release default address"); + } + return opResult; +} + + +/** + * finalize adding new device after port reset + * @param hc + * @param port + * @param target + */ +static void usb_hub_finalize_add_device( usb_hub_info_t * hub, + int hc, uint16_t port, usb_target_t target) { + + int opResult; + dprintf(1,"[usb_hub] finalizing add device"); + opResult = usb_hub_clear_port_feature(hc, target.address, + port, USB_HUB_FEATURE_C_PORT_RESET); + if (opResult != EOK) { + dprintf(1,"[usb_hub] failed to clear port reset feature"); + usb_hub_release_default_address(hc); + return; + } + + /* Request address at from host controller. */ + usb_address_t new_device_address = usb_drv_request_address(hc); + if (new_device_address < 0) { + dprintf(1,"[usb_hub] failed to get free USB address"); + opResult = new_device_address; + usb_hub_release_default_address(hc); + return; + } + dprintf(1,"[usb_hub] setting new address"); + opResult = usb_drv_req_set_address(hc, USB_ADDRESS_DEFAULT, + new_device_address); + + if (opResult != EOK) { + dprintf(1,"[usb_hub] could not set address for new device"); + usb_hub_release_default_address(hc); + return; + } + + + opResult = usb_hub_release_default_address(hc); + if(opResult!=EOK){ + return; + } + + devman_handle_t child_handle; + opResult = usb_drv_register_child_in_devman(hc, hub->device, + new_device_address, &child_handle); + if (opResult != EOK) { + dprintf(1,"[usb_hub] could not start driver for new device"); + return; + } + hub->attached_devs[port].devman_handle = child_handle; + hub->attached_devs[port].address = new_device_address; + + opResult = usb_drv_bind_address(hc, new_device_address, child_handle); + if (opResult != EOK) { + dprintf(1,"[usb_hub] could not assign address of device in hcd"); + return; + } + dprintf(1,"[usb_hub] new device address %d, handle %zu", + new_device_address, child_handle); + +} + +/** + * unregister device address in hc, close the port + * @param hc + * @param port + * @param target + */ +static void usb_hub_removed_device( + usb_hub_info_t * hub, int hc, uint16_t port, usb_target_t target) { + //usb_device_request_setup_packet_t request; + int opResult; + //disable port + /*usb_hub_set_disable_port_request(&request, port); + opResult = usb_drv_sync_control_write( + hc, target, + &request, + NULL, 0 + ); + if (opResult != EOK) { + //continue; + printf("[usb_hub] something went wrong when disabling a port\n"); + }*/ + /// \TODO remove device + + hub->attached_devs[port].devman_handle=0; + //close address + if(hub->attached_devs[port].address!=0){ + opResult = usb_drv_release_address(hc,hub->attached_devs[port].address); + if(opResult != EOK) { + dprintf(1, + "[usb_hub] could not release address of removed device: %d" + ,opResult); + } + hub->attached_devs[port].address = 0; + }else{ + dprintf(1, + "[usb_hub] this is strange, disconnected device had no address"); + //device was disconnected before it`s port was reset - return default address + usb_drv_release_default_address(hc); + } +} + +/** + * process interrupts on given hub port + * @param hc + * @param port + * @param target + */ +static void usb_hub_process_interrupt(usb_hub_info_t * hub, int hc, + uint16_t port, usb_address_t address) { + dprintf(1,"[usb_hub] interrupt at port %d", port); + //determine type of change + usb_target_t target; + target.address=address; + target.endpoint=0; + usb_port_status_t status; + size_t rcvd_size; + usb_device_request_setup_packet_t request; + int opResult; + usb_hub_set_port_status_request(&request, port); + //endpoint 0 + + opResult = usb_drv_sync_control_read( + hc, target, + &request, + &status, 4, &rcvd_size + ); + if (opResult != EOK) { + dprintf(1,"[usb_hub] ERROR: could not get port status"); + return; + } + if (rcvd_size != sizeof (usb_port_status_t)) { + dprintf(1,"[usb_hub] ERROR: received status has incorrect size"); + return; + } + //something connected/disconnected + if (usb_port_connect_change(&status)) { + opResult = usb_hub_clear_port_feature(hc, target.address, + port, USB_HUB_FEATURE_C_PORT_CONNECTION); + // TODO: check opResult + if (usb_port_dev_connected(&status)) { + dprintf(1,"[usb_hub] some connection changed"); + usb_hub_init_add_device(hc, port, target); + } else { + usb_hub_removed_device(hub, hc, port, target); + } + } + //port reset + if (usb_port_reset_completed(&status)) { + dprintf(1,"[usb_hub] port reset complete"); + if (usb_port_enabled(&status)) { + usb_hub_finalize_add_device(hub, hc, port, target); + } else { + dprintf(1,"[usb_hub] ERROR: port reset, but port still not enabled"); + } + } + + usb_port_set_connect_change(&status, false); + usb_port_set_reset(&status, false); + usb_port_set_reset_completed(&status, false); + usb_port_set_dev_connected(&status, false); + if (status) { + dprintf(1,"[usb_hub]there was some unsupported change on port %d",port); + } + /// \TODO handle other changes + /// \TODO debug log for various situations + +} + +/* Check changes on all known hubs. + */ +void usb_hub_check_hub_changes(void) { + /* + * Iterate through all hubs. + */ + usb_general_list_t * lst_item; + for (lst_item = usb_hub_list.next; + lst_item != &usb_hub_list; + lst_item = lst_item->next) { + usb_hub_info_t * hub_info = ((usb_hub_info_t*)lst_item->data); + /* + * Check status change pipe of this hub. + */ + + usb_target_t target; + target.address = hub_info->usb_device->address; + target.endpoint = 1;/// \TODO get from endpoint descriptor + dprintf(1,"[usb_hub] checking changes for hub at addr %d", + target.address); + + size_t port_count = hub_info->port_count; + + /* + * Connect to respective HC. + */ + int hc = usb_drv_hc_connect(hub_info->device, 0); + if (hc < 0) { + continue; + } + + /// FIXME: count properly + size_t byte_length = ((port_count+1) / 8) + 1; + + void *change_bitmap = malloc(byte_length); + size_t actual_size; + usb_handle_t handle; + + /* + * Send the request. + */ + int opResult = usb_drv_async_interrupt_in(hc, target, + change_bitmap, byte_length, &actual_size, + &handle); + + usb_drv_async_wait_for(handle); + + if (opResult != EOK) { + dprintf(1,"[usb_hub] something went wrong while getting status of hub"); + continue; + } + unsigned int port; + for (port = 1; port < port_count+1; ++port) { + bool interrupt = + (((uint8_t*) change_bitmap)[port / 8] >> (port % 8)) % 2; + if (interrupt) { + usb_hub_process_interrupt( + hub_info, hc, port, hub_info->usb_device->address); + } + } + + ipc_hangup(hc); + } +} + + + + + +/** + * @} + */ Index: uspace/drv/usbhub/usbhub.h =================================================================== --- uspace/drv/usbhub/usbhub.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/drv/usbhub/usbhub.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -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 usb + * @{ + */ +/** @file + * @brief Hub driver. + */ +#ifndef DRV_USBHUB_USBHUB_H +#define DRV_USBHUB_USBHUB_H + +#define NAME "usbhub" + +#include "usb/hcdhubd.h" + +/** basic information about device attached to hub */ +typedef struct{ + usb_address_t address; + devman_handle_t devman_handle; +}usb_hub_attached_device_t; + +/** Information about attached hub. */ +typedef struct { + /** Number of ports. */ + int port_count; + /** attached device handles */ + usb_hub_attached_device_t * attached_devs; + /** General usb device info. */ + usb_hcd_attached_device_info_t * usb_device; + /** General device info*/ + device_t * device; + +} usb_hub_info_t; + +/** + * function running the hub-controlling loop. + * @param noparam fundtion does not need any parameters + */ +int usb_hub_control_loop(void * noparam); + +/** Callback when new hub device is detected. + * + * @param dev New device. + * @return Error code. + */ +int usb_add_hub_device(device_t *dev); + +/** + * check changes on all registered hubs + */ +void usb_hub_check_hub_changes(void); + + +//int usb_add_hub_device(device_t *); + + + +#endif +/** + * @} + */ Index: uspace/drv/usbhub/usbhub.ma =================================================================== --- uspace/drv/usbhub/usbhub.ma (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/drv/usbhub/usbhub.ma (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,2 @@ +10 usb&hub +10 usb&class=hub Index: uspace/drv/usbhub/usbhub_private.h =================================================================== --- uspace/drv/usbhub/usbhub_private.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/drv/usbhub/usbhub_private.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,175 @@ +/* + * Copyright (c) 2010 Matus Dekanek + * 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 usb + * @{ + */ +/** @file + * @brief Hub driver. + */ + +#ifndef USBHUB_PRIVATE_H +#define USBHUB_PRIVATE_H + +#include "usbhub.h" +#include "usblist.h" + +#include +#include +#include +#include +#include +#include +#include +#include + +//************ +// +// convenience define for malloc +// +//************ +#define usb_new(type) (type*)malloc(sizeof(type)) + + +//************ +// +// convenience debug printf +// +//************ +#define dprintf(level, format, ...) \ + usb_dprintf(NAME, (level), format "\n", ##__VA_ARGS__) + +/** + * @brief create hub structure instance + * + * Set the address and port count information most importantly. + * + * @param device + * @param hc host controller phone + * @return + */ +usb_hub_info_t * usb_create_hub_info(device_t * device, int hc); + +/** list of hubs maanged by this driver */ +extern usb_general_list_t usb_hub_list; + + +/** + * @brief perform complete control read transaction + * + * manages all three steps of transaction: setup, read and finalize + * @param phone + * @param target + * @param request request for data + * @param rcvd_buffer received data + * @param rcvd_size + * @param actual_size actual size of received data + * @return error code + */ +int usb_drv_sync_control_read( + int phone, usb_target_t target, + usb_device_request_setup_packet_t * request, + void * rcvd_buffer, size_t rcvd_size, size_t * actual_size +); + +/** + * @brief perform complete control write transaction + * + * maanges all three steps of transaction: setup, write and finalize + * @param phone + * @param target + * @param request request to send data + * @param sent_buffer + * @param sent_size + * @return error code + */ +int usb_drv_sync_control_write( + int phone, usb_target_t target, + usb_device_request_setup_packet_t * request, + void * sent_buffer, size_t sent_size +); + + +/** + * set the device request to be a set address request + * @param request + * @param addr + * \TODO this will be obsolete see usb/dev_req.h + */ +static inline void usb_hub_set_set_address_request( +usb_device_request_setup_packet_t * request, uint16_t addr +){ + request->index = 0; + request->request_type = 0;/// \TODO this is not very nice sollution, we ned constant + request->request = USB_DEVREQ_SET_ADDRESS; + request->value = addr; + request->length = 0; +} + +/** + * set the device request to be a get hub descriptor request. + * @warning the size is allways set to USB_HUB_MAX_DESCRIPTOR_SIZE + * @param request + * @param addr + */ +static inline void usb_hub_set_descriptor_request( +usb_device_request_setup_packet_t * request +){ + request->index = 0; + request->request_type = USB_HUB_REQ_TYPE_GET_DESCRIPTOR; + request->request = USB_HUB_REQUEST_GET_DESCRIPTOR; + request->value_high = USB_DESCTYPE_HUB; + request->value_low = 0; + request->length = USB_HUB_MAX_DESCRIPTOR_SIZE; +} + +static inline int usb_hub_clear_port_feature(int hc, usb_address_t address, + int port_index, + usb_hub_class_feature_t feature) { + usb_target_t target = { + .address = address, + .endpoint = 0 + }; + usb_device_request_setup_packet_t clear_request = { + .request_type = USB_HUB_REQ_TYPE_CLEAR_PORT_FEATURE, + .request = USB_DEVREQ_CLEAR_FEATURE, + .length = 0, + .index = port_index + }; + clear_request.value = feature; + return usb_drv_psync_control_write(hc, target, &clear_request, + sizeof(clear_request), NULL, 0); +} + + + +#endif /* USBHUB_PRIVATE_H */ + +/** + * @} + */ Index: uspace/drv/usbhub/usblist.c =================================================================== --- uspace/drv/usbhub/usblist.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/drv/usbhub/usblist.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,80 @@ +/* + * Copyright (c) 2010 Matus Dekanek + * 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 usb hub driver + * @{ + */ +/** @file + * @brief usblist implementation + */ +#include + +#include "usbhub_private.h" + + +usb_general_list_t * usb_lst_create(void) { + usb_general_list_t* result = usb_new(usb_general_list_t); + usb_lst_init(result); + return result; +} + +void usb_lst_init(usb_general_list_t * lst) { + lst->prev = lst; + lst->next = lst; + lst->data = NULL; +} + +void usb_lst_prepend(usb_general_list_t* item, void* data) { + usb_general_list_t* appended = usb_new(usb_general_list_t); + appended->data = data; + appended->next = item; + appended->prev = item->prev; + item->prev->next = appended; + item->prev = appended; +} + +void usb_lst_append(usb_general_list_t* item, void* data) { + usb_general_list_t* appended = usb_new(usb_general_list_t); + appended->data = data; + appended->next = item->next; + appended->prev = item; + item->next->prev = appended; + item->next = appended; +} + +void usb_lst_remove(usb_general_list_t* item) { + item->next->prev = item->prev; + item->prev->next = item->next; +} + + + +/** + * @} + */ + + Index: uspace/drv/usbhub/usblist.h =================================================================== --- uspace/drv/usbhub/usblist.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/drv/usbhub/usblist.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,88 @@ +/* + * Copyright (c) 2010 Matus Dekanek + * 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. + */ + + +#ifndef USBLIST_H +#define USBLIST_H +/** @addtogroup usb hub driver + * @{ + */ +/** @file + * @brief HC driver and hub driver. + * + * My private list implementation; I did not like the original helenos list. + * This one does not depend on the structure of stored data and has + * much simpler and more straight-forward semantics. + */ + +/** + * general list structure + */ +typedef struct usb_general_list{ + void * data; + struct usb_general_list * prev, * next; +} usb_general_list_t; + +/** create head of usb general list */ +usb_general_list_t * usb_lst_create(void); + +/** initialize head of usb general list */ +void usb_lst_init(usb_general_list_t * lst); + + +/** is the list empty? */ +static inline bool usb_lst_empty(usb_general_list_t * lst){ + return lst?(lst->next==lst):true; +} + +/** append data behind item */ +void usb_lst_append(usb_general_list_t * lst, void * data); + +/** prepend data beore item */ +void usb_lst_prepend(usb_general_list_t * lst, void * data); + +/** remove list item from list */ +void usb_lst_remove(usb_general_list_t * item); + +/** get data o specified type from list item */ +#define usb_lst_get_data(item, type) (type *) (item->data) + +/** get usb_hub_info_t data from list item */ +static inline usb_hub_info_t * usb_hub_lst_get_data(usb_general_list_t * item) { + return usb_lst_get_data(item,usb_hub_info_t); +} + + +/** + * @} + */ + + + +#endif /* USBLIST_H */ + Index: uspace/drv/usbhub/utils.c =================================================================== --- uspace/drv/usbhub/utils.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/drv/usbhub/utils.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,262 @@ +/* + * Copyright (c) 2010 Matus Dekanek + * 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 libusb usb + * @{ + */ +/** @file + * @brief various utilities + */ +#include +#include +#include + +#include +#include +#include +#include +#include + +#include "usbhub.h" +#include "usbhub_private.h" +#include "port_status.h" + + +size_t USB_HUB_MAX_DESCRIPTOR_SIZE = 71; + +//********************************************* +// +// various utils +// +//********************************************* + +//hub descriptor utils + +void * usb_serialize_hub_descriptor(usb_hub_descriptor_t * descriptor) { + //base size + size_t size = 7; + //variable size according to port count + size_t var_size = descriptor->ports_count / 8 + ((descriptor->ports_count % 8 > 0) ? 1 : 0); + size += 2 * var_size; + uint8_t * result = (uint8_t*) malloc(size); + //size + result[0] = size; + //descriptor type + result[1] = USB_DESCTYPE_HUB; + result[2] = descriptor->ports_count; + /// @fixme handling of endianness?? + result[3] = descriptor->hub_characteristics / 256; + result[4] = descriptor->hub_characteristics % 256; + result[5] = descriptor->pwr_on_2_good_time; + result[6] = descriptor->current_requirement; + + size_t i; + for (i = 0; i < var_size; ++i) { + result[7 + i] = descriptor->devices_removable[i]; + } + for (i = 0; i < var_size; ++i) { + result[7 + var_size + i] = 255; + } + return result; +} + +usb_hub_descriptor_t * usb_deserialize_hub_desriptor(void * serialized_descriptor) { + uint8_t * sdescriptor = (uint8_t*) serialized_descriptor; + + if (sdescriptor[1] != USB_DESCTYPE_HUB) { + dprintf(1,"[usb_hub] wrong descriptor %x\n",sdescriptor[1]); + return NULL; + } + + usb_hub_descriptor_t * result = usb_new(usb_hub_descriptor_t); + + + result->ports_count = sdescriptor[2]; + /// @fixme handling of endianness?? + result->hub_characteristics = sdescriptor[4] + 256 * sdescriptor[3]; + result->pwr_on_2_good_time = sdescriptor[5]; + result->current_requirement = sdescriptor[6]; + size_t var_size = result->ports_count / 8 + ((result->ports_count % 8 > 0) + ? 1 : 0); + result->devices_removable = (uint8_t*) malloc(var_size); + //printf("[usb_hub] getting removable devices data \n"); + size_t i; + for (i = 0; i < var_size; ++i) { + result->devices_removable[i] = sdescriptor[7 + i]; + } + return result; +} + +//control transactions + +int usb_drv_sync_control_read( + int phone, usb_target_t target, + usb_device_request_setup_packet_t * request, + void * rcvd_buffer, size_t rcvd_size, size_t * actual_size + ) { + usb_handle_t handle; + int opResult; + //setup + opResult = usb_drv_async_control_read_setup(phone, target, + request, sizeof (usb_device_request_setup_packet_t), + &handle); + if (opResult != EOK) { + return opResult; + } + opResult = usb_drv_async_wait_for(handle); + if (opResult != EOK) { + return opResult; + } + //read + opResult = usb_drv_async_control_read_data(phone, target, + rcvd_buffer, rcvd_size, actual_size, + &handle); + if (opResult != EOK) { + return opResult; + } + opResult = usb_drv_async_wait_for(handle); + if (opResult != EOK) { + return opResult; + } + //finalize + opResult = usb_drv_async_control_read_status(phone, target, + &handle); + if (opResult != EOK) { + return opResult; + } + opResult = usb_drv_async_wait_for(handle); + if (opResult != EOK) { + return opResult; + } + return EOK; +} + +int usb_drv_sync_control_write( + int phone, usb_target_t target, + usb_device_request_setup_packet_t * request, + void * sent_buffer, size_t sent_size + ) { + usb_handle_t handle; + int opResult; + //setup + opResult = usb_drv_async_control_write_setup(phone, target, + request, sizeof (usb_device_request_setup_packet_t), + &handle); + if (opResult != EOK) { + return opResult; + } + opResult = usb_drv_async_wait_for(handle); + if (opResult != EOK) { + return opResult; + } + //write + opResult = usb_drv_async_control_write_data(phone, target, + sent_buffer, sent_size, + &handle); + if (opResult != EOK) { + return opResult; + } + opResult = usb_drv_async_wait_for(handle); + if (opResult != EOK) { + return opResult; + } + //finalize + opResult = usb_drv_async_control_write_status(phone, target, + &handle); + if (opResult != EOK) { + return opResult; + } + opResult = usb_drv_async_wait_for(handle); + if (opResult != EOK) { + return opResult; + } + return EOK; +} + + +/* + * method for testing port status bitmap + +static void usb_hub_test_port_status(void) { + printf("[usb_hub] -------------port status test---------\n"); + usb_port_status_t status = 0; + + //printf("original status %d (should be 0)\n",(uint32_t)status); + usb_port_set_bit(&status, 1, 1); + //printf("%d =?= 2\n",(uint32_t)status); + if (status != 2) { + printf("[usb_port_status] test failed: wrong set of bit 1\n"); + return; + } + usb_port_set_bit(&status, 3, 1); + if (status != 10) { + printf("[usb_port_status] test failed: wrong set of bit 3\n"); + return; + } + + usb_port_set_bit(&status, 15, 1); + if (status != 10 + (1 << 15)) { + printf("[usb_port_status] test failed: wrong set of bit 15\n"); + return; + } + usb_port_set_bit(&status, 1, 0); + if (status != 8 + (1 << 15)) { + printf("[usb_port_status] test failed: wrong unset of bit 1\n"); + return; + } + int i; + for (i = 0; i < 32; ++i) { + if (i == 3 || i == 15) { + if (!usb_port_get_bit(&status, i)) { + printf("[usb_port_status] test failed: wrong bit at %d\n", i); + } + } else { + if (usb_port_get_bit(&status, i)) { + printf("[usb_port_status] test failed: wrong bit at %d\n", i); + } + } + } + + printf("test ok\n"); + + + //printf("%d =?= 10\n",(uint32_t)status); + + //printf("this should be 0: %d \n",usb_port_get_bit(&status,0)); + //printf("this should be 1: %d \n",usb_port_get_bit(&status,1)); + //printf("this should be 0: %d \n",usb_port_get_bit(&status,2)); + //printf("this should be 1: %d \n",usb_port_get_bit(&status,3)); + //printf("this should be 0: %d \n",usb_port_get_bit(&status,4)); + +} +*/ + + +/** + * @} + */ Index: uspace/drv/usbkbd/Makefile =================================================================== --- uspace/drv/usbkbd/Makefile (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/drv/usbkbd/Makefile (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,37 @@ +# +# 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 = ../.. +LIBS = $(LIBDRV_PREFIX)/libdrv.a $(LIBUSB_PREFIX)/libusb.a +EXTRA_CFLAGS += -I$(LIBDRV_PREFIX)/include -I$(LIBUSB_PREFIX)/include +BINARY = usbkbd + +SOURCES = \ + main.c + +include $(USPACE_PREFIX)/Makefile.common Index: uspace/drv/usbkbd/main.c =================================================================== --- uspace/drv/usbkbd/main.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/drv/usbkbd/main.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,309 @@ +/* + * 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 +#include +#include +#include +#include + +#define BUFFER_SIZE 32 +#define NAME "usbkbd" + +#define GUESSED_POLL_ENDPOINT 1 + +/* + * Callbacks for parser + */ +static void usbkbd_process_keycodes(const uint16_t *key_codes, size_t count, + void *arg) +{ + +} + +/* + * Kbd functions + */ +static int usbkbd_parse_descriptors(usb_hid_dev_kbd_t *kbd_dev, + const uint8_t *data, size_t size) +{ +// const uint8_t *pos = data; + +// // get the configuration descriptor (should be first) +// if (*pos != sizeof(usb_standard_configuration_descriptor_t) +// || *(pos + 1) != USB_DESCTYPE_CONFIGURATION) { +// fprintf(stderr, "Wrong format of configuration descriptor"); +// return EINVAL; +// } + +// usb_standard_configuration_descriptor_t config_descriptor; +// memcpy(&config_descriptor, pos, +// sizeof(usb_standard_configuration_descriptor_t)); +// pos += sizeof(usb_standard_configuration_descriptor_t); + +// // parse other descriptors +// while (pos - data < size) { +// //uint8_t desc_size = *pos; +// uint8_t desc_type = *(pos + 1); +// switch (desc_type) { +// case USB_DESCTYPE_INTERFACE: +// break; +// case USB_DESCTYPE_ENDPOINT: +// break; +// case USB_DESCTYPE_HID: +// break; +// case USB_DESCTYPE_HID_REPORT: +// break; +// case USB_DESCTYPE_HID_PHYSICAL: +// break; +// } +// } + + return EOK; +} + +static int usbkbd_get_descriptors(usb_hid_dev_kbd_t *kbd_dev) +{ + // get the first configuration descriptor (TODO: or some other??) + usb_standard_configuration_descriptor_t config_desc; + + int rc = usb_drv_req_get_bare_configuration_descriptor( + kbd_dev->device->parent_phone, kbd_dev->address, 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_drv_req_get_full_configuration_descriptor( + kbd_dev->device->parent_phone, kbd_dev->address, 0, descriptors, + config_desc.total_length, &transferred); + + if (rc != EOK) { + return rc; + } + if (transferred != config_desc.total_length) { + return ELIMIT; + } + + rc = usbkbd_parse_descriptors(kbd_dev, descriptors, transferred); + free(descriptors); + + return rc; +} + +static usb_hid_dev_kbd_t *usbkbd_init_device(device_t *dev) +{ + usb_hid_dev_kbd_t *kbd_dev = (usb_hid_dev_kbd_t *)malloc( + sizeof(usb_hid_dev_kbd_t)); + + if (kbd_dev == NULL) { + fprintf(stderr, NAME ": No memory!\n"); + return NULL; + } + + kbd_dev->device = dev; + + // get phone to my HC and save it as my parent's phone + // TODO: maybe not a good idea if DDF will use parent_phone + kbd_dev->device->parent_phone = usb_drv_hc_connect(dev, 0); + + kbd_dev->address = usb_drv_get_my_address(dev->parent_phone, + dev); + + // doesn't matter now that we have no address +// if (kbd_dev->address < 0) { +// fprintf(stderr, NAME ": No device address!\n"); +// free(kbd_dev); +// return NULL; +// } + + // default endpoint + kbd_dev->poll_endpoint = GUESSED_POLL_ENDPOINT; + + /* + * 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 + usbkbd_get_descriptors(kbd_dev); + // TODO: parse descriptors and save endpoints + + return kbd_dev; +} + +static void usbkbd_process_interrupt_in(usb_hid_dev_kbd_t *kbd_dev, + uint8_t *buffer, size_t actual_size) +{ + /* + * here, the parser will be called, probably with some callbacks + * now only take last 6 bytes and process, i.e. send to kbd + */ + + 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); +} + +static void usbkbd_poll_keyboard(usb_hid_dev_kbd_t *kbd_dev) +{ + int rc; + usb_handle_t handle; + uint8_t buffer[BUFFER_SIZE]; + size_t actual_size; + //usb_endpoint_t poll_endpoint = 1; + +// usb_address_t my_address = usb_drv_get_my_address(dev->parent_phone, +// dev); +// if (my_address < 0) { +// return; +// } + + usb_target_t poll_target = { + .address = kbd_dev->address, + .endpoint = kbd_dev->poll_endpoint + }; + + while (true) { + async_usleep(1000 * 1000); + rc = usb_drv_async_interrupt_in(kbd_dev->device->parent_phone, + poll_target, buffer, BUFFER_SIZE, &actual_size, &handle); + + if (rc != EOK) { + continue; + } + + rc = usb_drv_async_wait_for(handle); + if (rc != EOK) { + continue; + } + + /* + * If the keyboard answered with NAK, it returned no data. + * This implies that no change happened since last query. + */ + if (actual_size == 0) { + continue; + } + + /* + * TODO: Process pressed keys. + */ + usbkbd_process_interrupt_in(kbd_dev, buffer, actual_size); + } + + // not reached + assert(0); +} + +static int usbkbd_fibril_device(void *arg) +{ + printf("!!! USB device fibril\n"); + + if (arg == NULL) { + printf("No device!\n"); + return -1; + } + + device_t *dev = (device_t *)arg; + + // initialize device (get and process descriptors, get address, etc.) + usb_hid_dev_kbd_t *kbd_dev = usbkbd_init_device(dev); + + usbkbd_poll_keyboard(kbd_dev); + + return EOK; +} + +static int usbkbd_add_device(device_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(dev, 0); +// if (phone < 0) { +// /* +// * Connecting to HC failed, roll-back and announce +// * failure. +// */ +// return phone; +// } + +// dev->parent_phone = phone; + + /* + * Create new fibril for handling this keyboard + */ + fid_t fid = fibril_create(usbkbd_fibril_device, dev); + if (fid == 0) { + printf("%s: failed to start fibril for HID device\n", NAME); + return ENOMEM; + } + fibril_add_ready(fid); + + /* + * 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[]) +{ + return driver_main(&kbd_driver); +} Index: uspace/drv/usbkbd/usbkbd.ma =================================================================== --- uspace/drv/usbkbd/usbkbd.ma (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/drv/usbkbd/usbkbd.ma (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,4 @@ +10 usb&class=hid +10 usb&class=HID +10 usb&interface&class=HID +10 usb&hid Index: uspace/drv/vhc/Makefile =================================================================== --- uspace/drv/vhc/Makefile (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/drv/vhc/Makefile (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,52 @@ +# +# 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 = ../.. +LIBS = \ + $(LIBUSB_PREFIX)/libusb.a \ + $(LIBUSBVIRT_PREFIX)/libusbvirt.a \ + $(LIBDRV_PREFIX)/libdrv.a +EXTRA_CFLAGS += \ + -I$(LIBUSBVIRT_PREFIX)/include \ + -I$(LIBUSB_PREFIX)/include \ + -I$(LIBDRV_PREFIX)/include +BINARY = vhc + +SOURCES = \ + hub/hub.c \ + hub/virthub.c \ + hub/virthubops.c \ + conndev.c \ + connhost.c \ + debug.c \ + devices.c \ + hc.c \ + hcd.c \ + hub.c + +include $(USPACE_PREFIX)/Makefile.common Index: uspace/drv/vhc/conn.h =================================================================== --- uspace/drv/vhc/conn.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/drv/vhc/conn.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,58 @@ +/* + * 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 usb + * @{ + */ +/** @file + * @brief Connection handling of incoming calls. + */ +#ifndef VHCD_CONN_H_ +#define VHCD_CONN_H_ + +#include +#include +#include +#include "vhcd.h" +#include "devices.h" + +void connection_handler_host(sysarg_t); + +usb_hcd_transfer_ops_t vhc_transfer_ops; +usbhc_iface_t vhc_iface; + +void address_init(void); + + +void default_connection_handler(device_t *, ipc_callid_t, ipc_call_t *); + + +#endif +/** + * @} + */ Index: uspace/drv/vhc/conndev.c =================================================================== --- uspace/drv/vhc/conndev.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/drv/vhc/conndev.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,115 @@ +/* + * 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 usb + * @{ + */ +/** @file + * @brief Connection handling of calls from virtual device (implementation). + */ + +#include +#include +#include + +#include "conn.h" +#include "hc.h" +#include "hub.h" + +#define DEVICE_NAME_MAXLENGTH 32 + +static int get_device_name(int phone, char *buffer, size_t len) +{ + ipc_call_t answer_data; + sysarg_t answer_rc; + aid_t req; + int rc; + + req = async_send_0(phone, + IPC_M_USBVIRT_GET_NAME, + &answer_data); + + rc = async_data_read_start(phone, buffer, len); + if (rc != EOK) { + async_wait_for(req, NULL); + return EINVAL; + } + + async_wait_for(req, &answer_rc); + rc = (int)answer_rc; + + if (IPC_GET_ARG1(answer_data) < len) { + len = IPC_GET_ARG1(answer_data); + } else { + len--; + } + buffer[len] = 0; + + return rc; +} + +/** 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(device_t *dev, + 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); + virtdev_connection_t *dev + = virtdev_add_device(callback); + if (!dev) { + ipc_answer_0(icallid, EEXISTS); + ipc_hangup(callback); + return; + } + ipc_answer_0(icallid, EOK); + + char devname[DEVICE_NAME_MAXLENGTH + 1]; + int rc = get_device_name(callback, devname, DEVICE_NAME_MAXLENGTH); + + dprintf(0, "virtual device connected (name: %s)", + rc == EOK ? devname : ""); + + /* FIXME: destroy the device when the client disconnects. */ + + return; + } + + ipc_answer_0(icallid, EINVAL); +} + + +/** + * @} + */ Index: uspace/drv/vhc/connhost.c =================================================================== --- uspace/drv/vhc/connhost.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/drv/vhc/connhost.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,299 @@ +/* + * 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 usb + * @{ + */ +/** @file + * @brief Connection handling of calls from host (implementation). + */ +#include +#include +#include +#include + +#include "vhcd.h" +#include "conn.h" +#include "hc.h" + +typedef struct { + usb_direction_t direction; + usbhc_iface_transfer_out_callback_t out_callback; + usbhc_iface_transfer_in_callback_t in_callback; + device_t *dev; + void *arg; +} transfer_info_t; + +static void universal_callback(void *buffer, size_t size, + usb_transaction_outcome_t outcome, void *arg) +{ + transfer_info_t *transfer = (transfer_info_t *) arg; + + switch (transfer->direction) { + case USB_DIRECTION_IN: + transfer->in_callback(transfer->dev, + outcome, size, + transfer->arg); + break; + case USB_DIRECTION_OUT: + transfer->out_callback(transfer->dev, + outcome, + transfer->arg); + break; + default: + assert(false && "unreachable"); + break; + } + + free(transfer); +} + +static transfer_info_t *create_transfer_info(device_t *dev, + usb_direction_t direction, void *arg) +{ + transfer_info_t *transfer = malloc(sizeof(transfer_info_t)); + + transfer->direction = direction; + transfer->in_callback = NULL; + transfer->out_callback = NULL; + transfer->arg = arg; + transfer->dev = dev; + + return transfer; +} + +static int enqueue_transfer_out(device_t *dev, + usb_target_t target, usb_transfer_type_t transfer_type, + void *buffer, size_t size, + usbhc_iface_transfer_out_callback_t callback, void *arg) +{ + dprintf(3, "transfer OUT [%d.%d (%s); %zu]", + target.address, target.endpoint, + usb_str_transfer_type(transfer_type), + size); + + transfer_info_t *transfer + = create_transfer_info(dev, USB_DIRECTION_OUT, arg); + transfer->out_callback = callback; + + hc_add_transaction_to_device(false, target, transfer_type, buffer, size, + universal_callback, transfer); + + return EOK; +} + +static int enqueue_transfer_setup(device_t *dev, + usb_target_t target, usb_transfer_type_t transfer_type, + void *buffer, size_t size, + usbhc_iface_transfer_out_callback_t callback, void *arg) +{ + dprintf(3, "transfer SETUP [%d.%d (%s); %zu]", + target.address, target.endpoint, + usb_str_transfer_type(transfer_type), + size); + + transfer_info_t *transfer + = create_transfer_info(dev, USB_DIRECTION_OUT, arg); + transfer->out_callback = callback; + + hc_add_transaction_to_device(true, target, transfer_type, buffer, size, + universal_callback, transfer); + + return EOK; +} + +static int enqueue_transfer_in(device_t *dev, + usb_target_t target, usb_transfer_type_t transfer_type, + void *buffer, size_t size, + usbhc_iface_transfer_in_callback_t callback, void *arg) +{ + dprintf(3, "transfer IN [%d.%d (%s); %zu]", + target.address, target.endpoint, + usb_str_transfer_type(transfer_type), + size); + + transfer_info_t *transfer + = create_transfer_info(dev, USB_DIRECTION_IN, arg); + transfer->in_callback = callback; + + hc_add_transaction_from_device(target, transfer_type, buffer, size, + universal_callback, transfer); + + return EOK; +} + + +static int interrupt_out(device_t *dev, usb_target_t target, + void *data, size_t size, + usbhc_iface_transfer_out_callback_t callback, void *arg) +{ + return enqueue_transfer_out(dev, target, USB_TRANSFER_INTERRUPT, + data, size, + callback, arg); +} + +static int interrupt_in(device_t *dev, usb_target_t target, + void *data, size_t size, + usbhc_iface_transfer_in_callback_t callback, void *arg) +{ + return enqueue_transfer_in(dev, target, USB_TRANSFER_INTERRUPT, + data, size, + callback, arg); +} + +static int control_write_setup(device_t *dev, usb_target_t target, + void *data, size_t size, + usbhc_iface_transfer_out_callback_t callback, void *arg) +{ + return enqueue_transfer_setup(dev, target, USB_TRANSFER_CONTROL, + data, size, + callback, arg); +} + +static int control_write_data(device_t *dev, usb_target_t target, + void *data, size_t size, + usbhc_iface_transfer_out_callback_t callback, void *arg) +{ + return enqueue_transfer_out(dev, target, USB_TRANSFER_CONTROL, + data, size, + callback, arg); +} + +static int control_write_status(device_t *dev, usb_target_t target, + usbhc_iface_transfer_in_callback_t callback, void *arg) +{ + return enqueue_transfer_in(dev, target, USB_TRANSFER_CONTROL, + NULL, 0, + callback, arg); +} + +static int control_read_setup(device_t *dev, usb_target_t target, + void *data, size_t size, + usbhc_iface_transfer_out_callback_t callback, void *arg) +{ + return enqueue_transfer_setup(dev, target, USB_TRANSFER_CONTROL, + data, size, + callback, arg); +} + +static int control_read_data(device_t *dev, usb_target_t target, + void *data, size_t size, + usbhc_iface_transfer_in_callback_t callback, void *arg) +{ + return enqueue_transfer_in(dev, target, USB_TRANSFER_CONTROL, + data, size, + callback, arg); +} + +static int control_read_status(device_t *dev, usb_target_t target, + usbhc_iface_transfer_out_callback_t callback, void *arg) +{ + return enqueue_transfer_out(dev, target, USB_TRANSFER_CONTROL, + NULL, 0, + callback, arg); +} + +static usb_address_keeping_t addresses; + + +static int reserve_default_address(device_t *dev) +{ + usb_address_keeping_reserve_default(&addresses); + return EOK; +} + +static int release_default_address(device_t *dev) +{ + usb_address_keeping_release_default(&addresses); + return EOK; +} + +static int request_address(device_t *dev, usb_address_t *address) +{ + usb_address_t addr = usb_address_keeping_request(&addresses); + if (addr < 0) { + return (int)addr; + } + + *address = addr; + return EOK; +} + +static int release_address(device_t *dev, usb_address_t address) +{ + return usb_address_keeping_release(&addresses, address); +} + +static int bind_address(device_t *dev, usb_address_t address, + devman_handle_t handle) +{ + usb_address_keeping_devman_bind(&addresses, address, handle); + return EOK; +} + +static int tell_address(device_t *dev, devman_handle_t handle, + usb_address_t *address) +{ + usb_address_t addr = usb_address_keeping_find(&addresses, handle); + if (addr < 0) { + return addr; + } + + *address = addr; + return EOK; +} + +void address_init(void) +{ + usb_address_keeping_init(&addresses, 50); +} + +usbhc_iface_t vhc_iface = { + .tell_address = tell_address, + + .reserve_default_address = reserve_default_address, + .release_default_address = release_default_address, + .request_address = request_address, + .bind_address = bind_address, + .release_address = release_address, + + .interrupt_out = interrupt_out, + .interrupt_in = interrupt_in, + + .control_write_setup = control_write_setup, + .control_write_data = control_write_data, + .control_write_status = control_write_status, + + .control_read_setup = control_read_setup, + .control_read_data = control_read_data, + .control_read_status = control_read_status +}; + +/** + * @} + */ Index: uspace/drv/vhc/debug.c =================================================================== --- uspace/drv/vhc/debug.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/drv/vhc/debug.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,55 @@ +/* + * 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 usb + * @{ + */ +/** @file + * @brief Debugging support. + */ +#include +#include +#include + +#include "vhcd.h" + + +/** Debug print informing of invalid call. + */ +void dprintf_inval_call(int level, ipc_call_t call, sysarg_t phone_hash) +{ + dprintf(level, "phone%#x: invalid call [%u (%u, %u, %u, %u, %u)]", + phone_hash, + IPC_GET_IMETHOD(call), + IPC_GET_ARG1(call), IPC_GET_ARG2(call), IPC_GET_ARG3(call), + IPC_GET_ARG4(call), IPC_GET_ARG5(call)); +} + +/** + * @} + */ Index: uspace/drv/vhc/devices.c =================================================================== --- uspace/drv/vhc/devices.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/drv/vhc/devices.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,190 @@ +/* + * 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 usb + * @{ + */ +/** @file + * @brief Virtual device management (implementation). + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include "devices.h" +#include "hub.h" +#include "hub/virthub.h" +#include "vhcd.h" + +#define list_foreach(pos, head) \ + for (pos = (head)->next; pos != (head); \ + pos = pos->next) + +static LIST_INITIALIZE(devices); + +/** Create virtual device. + * + * @param address USB address. + * @param phone Callback phone. + * @return New device. + * @retval NULL Out of memory or address already occupied. + */ +virtdev_connection_t *virtdev_add_device(int phone) +{ + virtdev_connection_t *dev = (virtdev_connection_t *) + malloc(sizeof(virtdev_connection_t)); + dev->phone = phone; + list_append(&dev->link, &devices); + + virthub_connect_device(&virtual_hub_device, dev); + + return dev; +} + +/** Destroy virtual device. + */ +void virtdev_destroy_device(virtdev_connection_t *dev) +{ + virthub_disconnect_device(&virtual_hub_device, dev); + list_remove(&dev->link); + free(dev); +} + +/** Send data to all connected devices. + * + * @param transaction Transaction to be sent over the bus. + */ +usb_transaction_outcome_t virtdev_send_to_all(transaction_t *transaction) +{ + link_t *pos; + list_foreach(pos, &devices) { + virtdev_connection_t *dev + = list_get_instance(pos, virtdev_connection_t, link); + + if (!virthub_is_device_enabled(&virtual_hub_device, dev)) { + continue; + } + + ipc_call_t answer_data; + sysarg_t answer_rc; + aid_t req; + int rc = EOK; + int method = IPC_M_USBVIRT_TRANSACTION_SETUP; + + switch (transaction->type) { + case USBVIRT_TRANSACTION_SETUP: + method = IPC_M_USBVIRT_TRANSACTION_SETUP; + break; + case USBVIRT_TRANSACTION_IN: + method = IPC_M_USBVIRT_TRANSACTION_IN; + break; + case USBVIRT_TRANSACTION_OUT: + method = IPC_M_USBVIRT_TRANSACTION_OUT; + break; + } + + req = async_send_3(dev->phone, + method, + transaction->target.address, + transaction->target.endpoint, + transaction->len, + &answer_data); + + if (transaction->len > 0) { + if (transaction->type == USBVIRT_TRANSACTION_IN) { + rc = async_data_read_start(dev->phone, + transaction->buffer, transaction->len); + } else { + rc = async_data_write_start(dev->phone, + transaction->buffer, transaction->len); + } + } + + if (rc != EOK) { + async_wait_for(req, NULL); + } else { + async_wait_for(req, &answer_rc); + rc = (int)answer_rc; + } + } + + /* + * Send the data to the virtual hub as well + * (if the address matches). + */ + if (virtual_hub_device.address == transaction->target.address) { + size_t tmp; + dprintf(1, "sending `%s' transaction to hub", + usbvirt_str_transaction_type(transaction->type)); + switch (transaction->type) { + case USBVIRT_TRANSACTION_SETUP: + virtual_hub_device.transaction_setup( + &virtual_hub_device, + transaction->target.endpoint, + transaction->buffer, transaction->len); + break; + + case USBVIRT_TRANSACTION_IN: + virtual_hub_device.transaction_in( + &virtual_hub_device, + transaction->target.endpoint, + transaction->buffer, transaction->len, + &tmp); + if (tmp < transaction->len) { + transaction->len = tmp; + } + break; + + case USBVIRT_TRANSACTION_OUT: + virtual_hub_device.transaction_out( + &virtual_hub_device, + transaction->target.endpoint, + transaction->buffer, transaction->len); + break; + } + dprintf(4, "transaction on hub processed..."); + } + + /* + * TODO: maybe screw some transactions to get more + * real-life image. + */ + return USB_OUTCOME_OK; +} + +/** + * @} + */ Index: uspace/drv/vhc/devices.h =================================================================== --- uspace/drv/vhc/devices.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/drv/vhc/devices.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,59 @@ +/* + * 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 usb + * @{ + */ +/** @file + * @brief Virtual device management. + */ +#ifndef VHCD_DEVICES_H_ +#define VHCD_DEVICES_H_ + +#include +#include + +#include "hc.h" + +/** Connected virtual device. */ +typedef struct { + /** Phone used when sending data to device. */ + int phone; + /** Linked-list handle. */ + link_t link; +} virtdev_connection_t; + +virtdev_connection_t *virtdev_add_device(int); +virtdev_connection_t *virtdev_get_mine(void); +void virtdev_destroy_device(virtdev_connection_t *); +usb_transaction_outcome_t virtdev_send_to_all(transaction_t *); + +#endif +/** + * @} + */ Index: uspace/drv/vhc/hc.c =================================================================== --- uspace/drv/vhc/hc.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/drv/vhc/hc.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,209 @@ +/* + * 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 usb + * @{ + */ +/** @file + * @brief Virtual HC (implementation). + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include "vhcd.h" +#include "hc.h" +#include "devices.h" +#include "hub.h" + +#define USLEEP_BASE (0 * 5 * 1000) + +#define USLEEP_VAR 50 + +#define SHORTENING_VAR 15 + +#define PROB_OUTCOME_BABBLE 5 +#define PROB_OUTCOME_CRCERROR 7 + +#define PROB_TEST(var, new_value, prob, number) \ + do { \ + if (((number) % (prob)) == 0) { \ + var = (new_value); \ + } \ + } while (0) + +static link_t transaction_list; + +#define TRANSACTION_FORMAT "T[%d.%d %s/%s (%d)]" +#define TRANSACTION_PRINTF(t) \ + (t).target.address, (t).target.endpoint, \ + usb_str_transfer_type((t).transfer_type), \ + usbvirt_str_transaction_type((t).type), \ + (int)(t).len + +#define transaction_get_instance(lnk) \ + list_get_instance(lnk, transaction_t, link) + +#define HUB_STATUS_MAX_LEN (HUB_PORT_COUNT + 64) + +static inline unsigned int pseudo_random(unsigned int *seed) +{ + *seed = ((*seed) * 873511) % 22348977 + 7; + return ((*seed) >> 8); +} + +/** Call transaction callback. + * Calling this callback informs the backend that transaction was processed. + */ +static void process_transaction_with_outcome(transaction_t * transaction, + usb_transaction_outcome_t outcome) +{ + dprintf(3, "transaction " TRANSACTION_FORMAT " done, outcome: %s", + TRANSACTION_PRINTF(*transaction), + usb_str_transaction_outcome(outcome)); + + transaction->callback(transaction->buffer, transaction->len, outcome, + transaction->callback_arg); +} + +/** Host controller manager main function. + */ +static int hc_manager_fibril(void *arg) +{ + list_initialize(&transaction_list); + + static unsigned int seed = 4573; + + printf("%s: transaction processor ready.\n", NAME); + + while (true) { + async_usleep(USLEEP_BASE + (pseudo_random(&seed) % USLEEP_VAR)); + + if (list_empty(&transaction_list)) { + continue; + } + + char ports[HUB_STATUS_MAX_LEN + 1]; + virthub_get_status(&virtual_hub_device, ports, HUB_STATUS_MAX_LEN); + + link_t *first_transaction_link = transaction_list.next; + transaction_t *transaction + = transaction_get_instance(first_transaction_link); + list_remove(first_transaction_link); + + + dprintf(0, "about to process " TRANSACTION_FORMAT " [%s]", + TRANSACTION_PRINTF(*transaction), ports); + + dprintf(3, "processing transaction " TRANSACTION_FORMAT "", + TRANSACTION_PRINTF(*transaction)); + + usb_transaction_outcome_t outcome; + outcome = virtdev_send_to_all(transaction); + + process_transaction_with_outcome(transaction, outcome); + + free(transaction); + } + + assert(false && "unreachable"); + return EOK; +} + +void hc_manager(void) +{ + fid_t fid = fibril_create(hc_manager_fibril, NULL); + if (fid == 0) { + printf(NAME ": failed to start HC manager fibril\n"); + return; + } + fibril_add_ready(fid); +} + +/** Create new transaction + */ +static transaction_t *transaction_create(usbvirt_transaction_type_t type, + usb_target_t target, usb_transfer_type_t transfer_type, + void * buffer, size_t len, + hc_transaction_done_callback_t callback, void * arg) +{ + transaction_t * transaction = malloc(sizeof(transaction_t)); + + list_initialize(&transaction->link); + transaction->type = type; + transaction->transfer_type = transfer_type; + transaction->target = target; + transaction->buffer = buffer; + transaction->len = len; + transaction->callback = callback; + transaction->callback_arg = arg; + + dprintf(3, "creating transaction " TRANSACTION_FORMAT, + TRANSACTION_PRINTF(*transaction)); + + return transaction; +} + +/** Add transaction directioned towards the device. + */ +void hc_add_transaction_to_device(bool setup, usb_target_t target, + usb_transfer_type_t transfer_type, + void * buffer, size_t len, + hc_transaction_done_callback_t callback, void * arg) +{ + transaction_t *transaction = transaction_create( + setup ? USBVIRT_TRANSACTION_SETUP : USBVIRT_TRANSACTION_OUT, + target, transfer_type, + buffer, len, callback, arg); + list_append(&transaction->link, &transaction_list); +} + +/** Add transaction directioned from the device. + */ +void hc_add_transaction_from_device(usb_target_t target, + usb_transfer_type_t transfer_type, + void * buffer, size_t len, + hc_transaction_done_callback_t callback, void * arg) +{ + transaction_t *transaction = transaction_create(USBVIRT_TRANSACTION_IN, + target, transfer_type, + buffer, len, callback, arg); + list_append(&transaction->link, &transaction_list); +} + +/** + * @} + */ Index: uspace/drv/vhc/hc.h =================================================================== --- uspace/drv/vhc/hc.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/drv/vhc/hc.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,89 @@ +/* + * 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 usb + * @{ + */ +/** @file + * @brief Virtual HC. + */ +#ifndef VHCD_HC_H_ +#define VHCD_HC_H_ + +#include +#include + +/** Callback after transaction is sent to USB. + * + * @param buffer Transaction data buffer. + * @param size Transaction data size. + * @param outcome Transaction outcome. + * @param arg Custom argument. + */ +typedef void (*hc_transaction_done_callback_t)(void *buffer, size_t size, + usb_transaction_outcome_t outcome, void *arg); + +/** Pending transaction details. */ +typedef struct { + /** Linked-list link. */ + link_t link; + /** Transaction type. */ + usbvirt_transaction_type_t type; + /** Transfer type. */ + usb_transfer_type_t transfer_type; + /** Device address. */ + usb_target_t target; + /** Direction of the transaction. */ + usb_direction_t direction; + /** Transaction data buffer. */ + void * buffer; + /** Transaction data length. */ + size_t len; + /** Callback after transaction is done. */ + hc_transaction_done_callback_t callback; + /** Argument to the callback. */ + void * callback_arg; +} transaction_t; + +void hc_manager(void); + +void hc_add_transaction_to_device(bool setup, + usb_target_t target, usb_transfer_type_t transfer_type, + void * buffer, size_t len, + hc_transaction_done_callback_t callback, void * arg); + +void hc_add_transaction_from_device( + usb_target_t target, usb_transfer_type_t transfer_type, + void * buffer, size_t len, + hc_transaction_done_callback_t callback, void * arg); + + +#endif +/** + * @} + */ Index: uspace/drv/vhc/hcd.c =================================================================== --- uspace/drv/vhc/hcd.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/drv/vhc/hcd.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,118 @@ +/* + * 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 usb + * @{ + */ +/** @file + * @brief Virtual host controller driver. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include "vhcd.h" +#include "hc.h" +#include "devices.h" +#include "hub.h" +#include "conn.h" + +static device_ops_t vhc_ops = { + .interfaces[USBHC_DEV_IFACE] = &vhc_iface, + .default_handler = default_connection_handler +}; + +static int vhc_count = 0; +static int vhc_add_device(device_t *dev) +{ + /* + * Currently, we know how to simulate only single HC. + */ + if (vhc_count > 0) { + return ELIMIT; + } + + vhc_count++; + + dev->ops = &vhc_ops; + + /* + * Initialize address management. + */ + address_init(); + + /* + * Initialize our hub and announce its presence. + */ + virtual_hub_device_init(dev); + + printf("%s: virtual USB host controller ready.\n", NAME); + + return EOK; +} + +static driver_ops_t vhc_driver_ops = { + .add_device = vhc_add_device, +}; + +static driver_t vhc_driver = { + .name = NAME, + .driver_ops = &vhc_driver_ops +}; + + +int main(int argc, char * argv[]) +{ + /* + * Temporary workaround. Wait a little bit to be the last driver + * in devman output. + */ + sleep(5); + + usb_dprintf_enable(NAME, 0); + + printf(NAME ": virtual USB host controller driver.\n"); + + hc_manager(); + + return driver_main(&vhc_driver); +} + + +/** + * @} + */ Index: uspace/drv/vhc/hub.c =================================================================== --- uspace/drv/vhc/hub.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/drv/vhc/hub.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,104 @@ +/* + * 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 usb + * @{ + */ +/** @file + * @brief Virtual USB hub. + */ +#include +#include +#include +#include +#include +#include +#include +#include + +#include "hub.h" +#include "hub/virthub.h" +#include "vhcd.h" + +usbvirt_device_t virtual_hub_device; + +static int hub_register_in_devman_fibril(void *arg); + +void virtual_hub_device_init(device_t *hc_dev) +{ + virthub_init(&virtual_hub_device); + + /* + * We need to register the root hub. + * This must be done in separate fibril because the device + * we are connecting to are ourselves and we cannot connect + * before leaving the add_device() function. + */ + fid_t root_hub_registration + = fibril_create(hub_register_in_devman_fibril, hc_dev); + if (root_hub_registration == 0) { + printf(NAME ": failed to register root hub\n"); + return; + } + + fibril_add_ready(root_hub_registration); +} + +/** Register root hub in devman. + * + * @param arg Host controller device (type device_t *). + * @return Error code. + */ +int hub_register_in_devman_fibril(void *arg) +{ + device_t *hc_dev = (device_t *) arg; + + int hc = usb_drv_hc_connect(hc_dev, IPC_FLAG_BLOCKING); + if (hc < 0) { + printf(NAME ": failed to register root hub\n"); + return hc; + } + + usb_drv_reserve_default_address(hc); + + usb_address_t hub_address = usb_drv_request_address(hc); + usb_drv_req_set_address(hc, USB_ADDRESS_DEFAULT, hub_address); + + usb_drv_release_default_address(hc); + + devman_handle_t hub_handle; + usb_drv_register_child_in_devman(hc, hc_dev, hub_address, &hub_handle); + usb_drv_bind_address(hc, hub_address, hub_handle); + + return EOK; +} + + +/** + * @} + */ Index: uspace/drv/vhc/hub.h =================================================================== --- uspace/drv/vhc/hub.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/drv/vhc/hub.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,52 @@ +/* + * 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 usb + * @{ + */ +/** @file + * @brief Virtual USB hub. + */ +#ifndef VHCD_HUB_H_ +#define VHCD_HUB_H_ + +#include +#include + +#include "devices.h" +#include "hub/hub.h" +#include "hub/virthub.h" + +extern usbvirt_device_t virtual_hub_device; + +void virtual_hub_device_init(device_t *); + +#endif +/** + * @} + */ Index: uspace/drv/vhc/hub/hub.c =================================================================== --- uspace/drv/vhc/hub/hub.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/drv/vhc/hub/hub.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,489 @@ +/* + * 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 usb + * @{ + */ +/** @file + * @brief Representation of an USB hub (implementation). + */ +#include +#include +#include +#include +#include +#include +#include +#include + +#include "hub.h" + + +/** Produce a byte from bit values. + */ +#define MAKE_BYTE(b0, b1, b2, b3, b4, b5, b6, b7) \ + (( \ + ((b0) << 0) \ + | ((b1) << 1) \ + | ((b2) << 2) \ + | ((b3) << 3) \ + | ((b4) << 4) \ + | ((b5) << 5) \ + | ((b6) << 6) \ + | ((b7) << 7) \ + )) + +/* Static functions. */ +static hub_port_t *get_hub_port(hub_t *, size_t); +static void set_port_status_change(hub_port_t *, hub_status_change_t); +static void clear_port_status_change(hub_port_t *, uint16_t); +static int set_port_state_delayed_fibril(void *); +static void set_port_state_delayed(hub_t *, size_t, suseconds_t, + hub_port_state_t, hub_port_state_t); + +/** Convert hub port state to a char. */ +char hub_port_state_to_char(hub_port_state_t state) { + switch (state) { + case HUB_PORT_STATE_NOT_CONFIGURED: + return '-'; + case HUB_PORT_STATE_POWERED_OFF: + return 'O'; + case HUB_PORT_STATE_DISCONNECTED: + return 'X'; + case HUB_PORT_STATE_DISABLED: + return 'D'; + case HUB_PORT_STATE_RESETTING: + return 'R'; + case HUB_PORT_STATE_ENABLED: + return 'E'; + case HUB_PORT_STATE_SUSPENDED: + return 'S'; + case HUB_PORT_STATE_RESUMING: + return 'F'; + default: + return '?'; + } +} + +/** Initialize single hub port. + * + * @param port Port to be initialized. + * @param index Port index (one based). + */ +static void hub_init_port(hub_port_t *port, size_t index) +{ + port->connected_device = NULL; + port->index = index; + port->state = HUB_PORT_STATE_NOT_CONFIGURED; + port->status_change = 0; +} + +/** Initialize the hub. + * + * @param hub Hub to be initialized. + */ +void hub_init(hub_t *hub) +{ + size_t i; + for (i = 0; i < HUB_PORT_COUNT; i++) { + hub_init_port(&hub->ports[i], i + 1); + } + hub->custom_data = NULL; + fibril_mutex_initialize(&hub->guard); +} + +/** Connect a device to the hub. + * + * @param hub Hub to connect device to. + * @param device Device to be connected. + * @return Index of port the device was connected to. + * @retval -1 No free port available. + */ +size_t hub_connect_device(hub_t *hub, void *device) +{ + size_t i; + for (i = 0; i < HUB_PORT_COUNT; i++) { + hub_port_t *port = &hub->ports[i]; + + if (port->connected_device != NULL) { + continue; + } + + port->connected_device = device; + + /* + * TODO: + * If the hub was configured, we can normally + * announce the plug-in. + * Otherwise, we will wait until hub is configured + * and announce changes in single burst. + */ + //if (port->state == HUB_PORT_STATE_DISCONNECTED) { + port->state = HUB_PORT_STATE_DISABLED; + set_port_status_change(port, HUB_STATUS_C_PORT_CONNECTION); + //} + + return i; + } + + return (size_t) -1; +} + +/** Find port device is connected to. + * + * @param hub Hub in question. + * @param device Device in question. + * @return Port index (zero based). + * @retval -1 Device is not connected. + */ +size_t hub_find_device(hub_t *hub, void *device) +{ + size_t i; + for (i = 0; i < HUB_PORT_COUNT; i++) { + hub_port_t *port = &hub->ports[i]; + + if (port->connected_device == device) { + return i; + } + } + + return 0; +} + +/** Acquire exclusive access to the hub. + * + * @param hub Hub in question. + */ +void hub_acquire(hub_t *hub) +{ + fibril_mutex_lock(&hub->guard); +} + +/** Give up exclusive access to the hub. + * + * @param hub Hub in question. + */ +void hub_release(hub_t *hub) +{ + fibril_mutex_unlock(&hub->guard); +} + +/** Change port state. + * + * @param hub Hub the port belongs to. + * @param port_index Port index (zero based). + * @param state New port state. + */ +void hub_set_port_state(hub_t *hub, size_t port_index, hub_port_state_t state) +{ + hub_port_t *port = get_hub_port(hub, port_index); + if (port == NULL) { + return; + } + + switch (state) { + case HUB_PORT_STATE_POWERED_OFF: + clear_port_status_change(port, HUB_STATUS_C_PORT_CONNECTION); + clear_port_status_change(port, HUB_STATUS_C_PORT_ENABLE); + clear_port_status_change(port, HUB_STATUS_C_PORT_RESET); + break; + case HUB_PORT_STATE_RESUMING: + set_port_state_delayed(hub, port_index, + 10, state, HUB_PORT_STATE_ENABLED); + break; + case HUB_PORT_STATE_RESETTING: + set_port_state_delayed(hub, port_index, + 10, state, HUB_PORT_STATE_ENABLED); + break; + case HUB_PORT_STATE_ENABLED: + if (port->state == HUB_PORT_STATE_RESETTING) { + set_port_status_change(port, HUB_STATUS_C_PORT_RESET); + } + break; + default: + break; + } + + port->state = state; +} + +/** Change state of all ports. + * + * @param hub Hub in question. + * @param state New state for all ports. + */ +void hub_set_port_state_all(hub_t *hub, hub_port_state_t state) +{ + size_t i; + for (i = 0; i < HUB_PORT_COUNT; i++) { + hub_set_port_state(hub, i, state); + } +} + +/** Get port state. + * + * @param hub Hub the port belongs to. + * @param port_index Port index (zero based). + * @return Port state. + */ +hub_port_state_t hub_get_port_state(hub_t *hub, size_t port_index) +{ + hub_port_t *port = get_hub_port(hub, port_index); + if (port == NULL) { + return HUB_PORT_STATE_UNKNOWN; + } + + return port->state; +} + +/** Clear port status change bit. + * + * @param hub Hub the port belongs to. + * @param port_index Port index (zero based). + * @param change Change to be cleared. + */ +void hub_clear_port_status_change(hub_t *hub, size_t port_index, + hub_status_change_t change) +{ + hub_port_t *port = get_hub_port(hub, port_index); + if (port == NULL) { + return; + } + + clear_port_status_change(port, change); +} + +/** Get port status change bits. + * + * @param hub Hub the port belongs to. + * @param port_index Port index (zero based). + * @return Port status change bitmap in standard format. + */ +uint16_t hub_get_port_status_change(hub_t *hub, size_t port_index) +{ + hub_port_t *port = get_hub_port(hub, port_index); + if (port == NULL) { + return 0; + } + + return port->status_change; +} + +/** Get port status bits. + * + * @param hub Hub the port belongs to. + * @param port_index Port index (zero based). + * @return Port status bitmap in standard format. + */ +uint32_t hub_get_port_status(hub_t *hub, size_t port_index) +{ + hub_port_t *port = get_hub_port(hub, port_index); + if (port == NULL) { + return 0; + } + + uint32_t status; + status = MAKE_BYTE( + /* Current connect status. */ + port->connected_device == NULL ? 0 : 1, + /* Port enabled/disabled. */ + port->state == HUB_PORT_STATE_ENABLED ? 1 : 0, + /* Suspend. */ + (port->state == HUB_PORT_STATE_SUSPENDED) + || (port->state == HUB_PORT_STATE_RESUMING) ? 1 : 0, + /* Over-current. */ + 0, + /* Reset. */ + port->state == HUB_PORT_STATE_RESETTING ? 1 : 0, + /* Reserved. */ + 0, 0, 0) + + | (MAKE_BYTE( + /* Port power. */ + port->state == HUB_PORT_STATE_POWERED_OFF ? 0 : 1, + /* Full-speed device. */ + 0, + /* Reserved. */ + 0, 0, 0, 0, 0, 0 + )) << 8; + + status |= (port->status_change << 16); + + return status; +} + +/** Create hub status change bitmap. + * + * @warning This function assumes that the whole bitmap fits into 8 bits. + * + * @param hub Hub in question. + * @return Hub status change bitmap. + */ +uint8_t hub_get_status_change_bitmap(hub_t *hub) +{ + uint8_t change_map = 0; + + size_t i; + for (i = 0; i < HUB_PORT_COUNT; i++) { + hub_port_t *port = &hub->ports[i]; + + if (port->status_change != 0) { + change_map |= (1 << port->index); + } + } + + return change_map; +} + + +/* + * + * STATIC (HELPER) FUNCTIONS + * + */ + +/** Find a port in a hub. + * + * @param hub Hub in question. + * @param port Port index (zero based). + * @return Port structure. + * @retval NULL Invalid port index. + */ +static hub_port_t *get_hub_port(hub_t *hub, size_t port) +{ + if (port >= HUB_PORT_COUNT) { + return NULL; + } + + return &hub->ports[port]; +} + +/** Adds a port status change to a port. + * + * @param port The port with status change. + * @param change Change to be added to the status. + */ +static void set_port_status_change(hub_port_t *port, + hub_status_change_t change) +{ + assert(port != NULL); + port->status_change |= change; +} + +/** Clears a port status change on a port. + * + * @param port The port with status change. + * @param change Change to be removed from the status. + */ +static void clear_port_status_change(hub_port_t *port, + uint16_t change) +{ + assert(port != NULL); + port->status_change &= (~change); +} + +/** Structure for automatic (delayed) port state change. */ +struct delay_port_state_change { + /** Delay in microseconds. */ + suseconds_t delay; + /** Old state of the port. */ + hub_port_state_t old_state; + /** New state of the port. */ + hub_port_state_t new_state; + /** Port index (zero based). */ + size_t port; + /** Hub. */ + hub_t *hub; +}; + +/** Fibril responsible for delayed port state change. + * + * @param arg Pointer to delay_port_state_change. + * @return Always EOK. + */ +static int set_port_state_delayed_fibril(void *arg) +{ + struct delay_port_state_change *change + = (struct delay_port_state_change *) arg; + + async_usleep(change->delay); + + hub_acquire(change->hub); + + hub_port_t *port = get_hub_port(change->hub, change->port); + assert(port != NULL); + + if (port->state == change->old_state) { + hub_set_port_state(change->hub, change->port, + change->new_state); + } + + hub_release(change->hub); + + free(change); + + return EOK; +} + +/** Change port state with a delay. + * + * @warning If the port state changes during the waiting phase, the state + * is not changed. + * + * @param hub Hub in question. + * @param port_index Port index (zero based). + * @param delay_time_ms Delay time in miliseconds. + * @param old_state Old (current) state of the port. + * @param new_state New state of the port. + */ +static void set_port_state_delayed(hub_t *hub, size_t port_index, + suseconds_t delay_time_ms, + hub_port_state_t old_state, hub_port_state_t new_state) +{ + struct delay_port_state_change *change + = malloc(sizeof(struct delay_port_state_change)); + + change->hub = hub; + change->port = port_index; + change->delay = delay_time_ms * 1000; + change->old_state = old_state; + change->new_state = new_state; + fid_t fibril = fibril_create(set_port_state_delayed_fibril, change); + if (fibril == 0) { + printf("Failed to create fibril\n"); + free(change); + return; + } + fibril_add_ready(fibril); +} + + + +/** + * @} + */ Index: uspace/drv/vhc/hub/hub.h =================================================================== --- uspace/drv/vhc/hub/hub.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/drv/vhc/hub/hub.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,111 @@ +/* + * 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 usb + * @{ + */ +/** @file + * @brief Representation of an USB hub. + */ +#ifndef VHC_HUB_HUB_H_ +#define VHC_HUB_HUB_H_ + +#include + +#define HUB_PORT_COUNT 2 +#define BITS2BYTES(bits) (bits ? ((((bits)-1)>>3)+1) : 0) + +/** Hub port internal state. + * Some states (e.g. port over current) are not covered as they are not + * simulated at all. + */ +typedef enum { + HUB_PORT_STATE_UNKNOWN, + HUB_PORT_STATE_NOT_CONFIGURED, + HUB_PORT_STATE_POWERED_OFF, + HUB_PORT_STATE_DISCONNECTED, + HUB_PORT_STATE_DISABLED, + HUB_PORT_STATE_RESETTING, + HUB_PORT_STATE_ENABLED, + HUB_PORT_STATE_SUSPENDED, + HUB_PORT_STATE_RESUMING, + /* HUB_PORT_STATE_, */ +} hub_port_state_t; + +char hub_port_state_to_char(hub_port_state_t); + +/** Hub status change mask bits. */ +typedef enum { + HUB_STATUS_C_PORT_CONNECTION = (1 << 0), + HUB_STATUS_C_PORT_ENABLE = (1 << 1), + HUB_STATUS_C_PORT_SUSPEND = (1 << 2), + HUB_STATUS_C_PORT_OVER_CURRENT = (1 << 3), + HUB_STATUS_C_PORT_RESET = (1 << 4), + /* HUB_STATUS_C_ = (1 << ), */ +} hub_status_change_t; + +/** Hub port information. */ +typedef struct { + /** Custom pointer to connected device. */ + void *connected_device; + /** Port index (one based). */ + size_t index; + /** Port state. */ + hub_port_state_t state; + /** Status change bitmap. */ + uint16_t status_change; +} hub_port_t; + +/** Hub device type. */ +typedef struct { + /** Hub ports. */ + hub_port_t ports[HUB_PORT_COUNT]; + /** Custom hub data. */ + void *custom_data; + /** Access guard to the whole hub. */ + fibril_mutex_t guard; +} hub_t; + +void hub_init(hub_t *); +size_t hub_connect_device(hub_t *, void *); +size_t hub_find_device(hub_t *, void *); +void hub_acquire(hub_t *); +void hub_release(hub_t *); +void hub_set_port_state(hub_t *, size_t, hub_port_state_t); +void hub_set_port_state_all(hub_t *, hub_port_state_t); +hub_port_state_t hub_get_port_state(hub_t *, size_t); +void hub_clear_port_status_change(hub_t *, size_t, hub_status_change_t); +uint16_t hub_get_port_status_change(hub_t *, size_t); +uint32_t hub_get_port_status(hub_t *, size_t); +uint8_t hub_get_status_change_bitmap(hub_t *); + + +#endif +/** + * @} + */ Index: uspace/drv/vhc/hub/virthub.c =================================================================== --- uspace/drv/vhc/hub/virthub.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/drv/vhc/hub/virthub.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,265 @@ +/* + * 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 usb + * @{ + */ +/** @file + * @brief + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "virthub.h" +#include "hub.h" + + +/** 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_HUB, + .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_HUB, + .interface_subclass = 0, + .interface_protocol = 0, + .str_interface = 0 +}; + +/** Hub descriptor. */ +hub_descriptor_t hub_descriptor = { + .length = sizeof(hub_descriptor_t), + .type = USB_DESCTYPE_HUB, + .port_count = HUB_PORT_COUNT, + .characteristics = 0, + .power_on_warm_up = 50, /* Huh? */ + .max_current = 100, /* Huh again. */ + .removable_device = { 0 }, + .port_power = { 0xFF } +}; + +/** Endpoint descriptor. */ +usb_standard_endpoint_descriptor_t endpoint_descriptor = { + .length = sizeof(usb_standard_endpoint_descriptor_t), + .descriptor_type = USB_DESCTYPE_ENDPOINT, + .endpoint_address = HUB_STATUS_CHANGE_PIPE | 128, + .attributes = USB_TRANSFER_INTERRUPT, + .max_packet_size = 8, + .poll_interval = 0xFF +}; + +/** 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(hub_descriptor) + + sizeof(endpoint_descriptor) + , + .interface_count = 1, + .configuration_number = HUB_CONFIGURATION_ID, + .str_configuration = 0, + .attributes = 128, /* denotes bus-powered device */ + .max_power = 50 +}; + +/** All hub configuration descriptors. */ +static usbvirt_device_configuration_extras_t extra_descriptors[] = { + { + .data = (uint8_t *) &std_interface_descriptor, + .length = sizeof(std_interface_descriptor) + }, + { + .data = (uint8_t *) &hub_descriptor, + .length = sizeof(hub_descriptor) + }, + { + .data = (uint8_t *) &endpoint_descriptor, + .length = sizeof(endpoint_descriptor) + } +}; + +/** Hub configuration. */ +usbvirt_device_configuration_t configuration = { + .descriptor = &std_configuration_descriptor, + .extra = extra_descriptors, + .extra_count = sizeof(extra_descriptors)/sizeof(extra_descriptors[0]) +}; + +/** Hub standard descriptors. */ +usbvirt_descriptors_t descriptors = { + .device = &std_device_descriptor, + .configuration = &configuration, + .configuration_count = 1, +}; + +/** Initializes virtual hub device. + * + * @param dev Virtual USB device backend. + * @return Error code. + */ +int virthub_init(usbvirt_device_t *dev) +{ + if (dev == NULL) { + return EBADMEM; + } + dev->ops = &hub_ops; + dev->descriptors = &descriptors; + dev->lib_debug_level = 0; + dev->lib_debug_enabled_tags = USBVIRT_DEBUGTAG_ALL; + + hub_t *hub = malloc(sizeof(hub_t)); + if (hub == NULL) { + return ENOMEM; + } + + hub_init(hub); + dev->device_data = hub; + + usbvirt_connect_local(dev); + + return EOK; +} + +/** Connect a device to a virtual hub. + * + * @param dev Virtual device representing the hub. + * @param conn Device to be connected. + * @return Port device was connected to. + */ +int virthub_connect_device(usbvirt_device_t *dev, virtdev_connection_t *conn) +{ + assert(dev != NULL); + assert(conn != NULL); + + hub_t *hub = (hub_t *) dev->device_data; + + hub_acquire(hub); + size_t port = hub_connect_device(hub, conn); + hub_release(hub); + + return port; +} + +/** Disconnect a device from a virtual hub. + * + * @param dev Virtual device representing the hub. + * @param conn Device to be disconnected. + * @return Error code. + */ +int virthub_disconnect_device(usbvirt_device_t *dev, virtdev_connection_t *conn) +{ + assert(dev != NULL); + assert(conn != NULL); + + hub_t *hub = (hub_t *) dev->device_data; + + hub_acquire(hub); + /* TODO: implement. */ + hub_release(hub); + + return ENOTSUP; +} + +/** Whether trafic is propagated to given device. + * + * @param dev Virtual device representing the hub. + * @param conn Connected device. + * @return Whether port is signalling to the device. + */ +bool virthub_is_device_enabled(usbvirt_device_t *dev, virtdev_connection_t *conn) +{ + assert(dev != NULL); + assert(conn != NULL); + + hub_t *hub = (hub_t *) dev->device_data; + + hub_acquire(hub); + + hub_port_state_t state = HUB_PORT_STATE_UNKNOWN; + size_t port = hub_find_device(hub, conn); + if (port != (size_t) -1) { + state = hub_get_port_state(hub, port); + } + hub_release(hub); + + return state == HUB_PORT_STATE_ENABLED; +} + +/** Format status of a virtual hub. + * + * @param dev Virtual device representing the hub. + * @param[out] status Hub status information. + * @param[in] len Size of the @p status buffer. + */ +void virthub_get_status(usbvirt_device_t *dev, char *status, size_t len) +{ + assert(dev != NULL); + if (len == 0) { + return; + } + + hub_t *hub = (hub_t *) dev->device_data; + + char port_status[HUB_PORT_COUNT + 1]; + + size_t i; + for (i = 0; i < HUB_PORT_COUNT; i++) { + port_status[i] = hub_port_state_to_char( + hub_get_port_state(hub, i)); + } + port_status[HUB_PORT_COUNT] = 0; + + snprintf(status, len, "vhub:%s", port_status); +} + +/** + * @} + */ Index: uspace/drv/vhc/hub/virthub.h =================================================================== --- uspace/drv/vhc/hub/virthub.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/drv/vhc/hub/virthub.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -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 usb + * @{ + */ +/** @file + * @brief USB hub as a virtual USB device. + */ +#ifndef VHC_HUB_VIRTHUB_H_ +#define VHC_HUB_VIRTHUB_H_ + +#include +#include "../devices.h" +#include "hub.h" + +/** Endpoint number for status change pipe. */ +#define HUB_STATUS_CHANGE_PIPE 1 +/** Configuration value for hub configuration. */ +#define HUB_CONFIGURATION_ID 1 + + +/** Hub descriptor. + */ +typedef struct { + /** Size of this descriptor in bytes. */ + uint8_t length; + /** Descriptor type (USB_DESCTYPE_HUB). */ + uint8_t type; + /** Number of downstream ports. */ + uint8_t port_count; + /** Hub characteristics. */ + uint16_t characteristics; + /** Time from power-on to stabilized current. + * Expressed in 2ms unit. + */ + uint8_t power_on_warm_up; + /** Maximum current (in mA). */ + uint8_t max_current; + /** Whether device at given port is removable. */ + uint8_t removable_device[BITS2BYTES(HUB_PORT_COUNT+1)]; + /** Port power control. + * This is USB1.0 compatibility field, all bits must be 1. + */ + uint8_t port_power[BITS2BYTES(HUB_PORT_COUNT+1)]; +} __attribute__ ((packed)) hub_descriptor_t; + +extern usbvirt_device_ops_t hub_ops; +extern hub_descriptor_t hub_descriptor; + +int virthub_init(usbvirt_device_t *); +int virthub_connect_device(usbvirt_device_t *, virtdev_connection_t *); +int virthub_disconnect_device(usbvirt_device_t *, virtdev_connection_t *); +bool virthub_is_device_enabled(usbvirt_device_t *, virtdev_connection_t *); +void virthub_get_status(usbvirt_device_t *, char *, size_t); + +#endif +/** + * @} + */ Index: uspace/drv/vhc/hub/virthubops.c =================================================================== --- uspace/drv/vhc/hub/virthubops.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/drv/vhc/hub/virthubops.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,433 @@ +/* + * 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 usb + * @{ + */ +/** @file + * @brief Virtual USB hub operations. + */ +#include +#include +#include "virthub.h" +#include "hub.h" + +/** Callback when device changes states. */ +static void on_state_change(struct usbvirt_device *dev, + usbvirt_device_state_t old_state, usbvirt_device_state_t new_state) +{ + hub_t *hub = (hub_t *)dev->device_data; + + hub_acquire(hub); + + switch (new_state) { + case USBVIRT_STATE_CONFIGURED: + hub_set_port_state_all(hub, HUB_PORT_STATE_POWERED_OFF); + break; + case USBVIRT_STATE_ADDRESS: + hub_set_port_state_all(hub, HUB_PORT_STATE_NOT_CONFIGURED); + break; + default: + break; + } + + hub_release(hub); +} + +/** Callback for data request. */ +static int req_on_data(struct usbvirt_device *dev, + usb_endpoint_t endpoint, + void *buffer, size_t size, size_t *actual_size) +{ + if (endpoint != HUB_STATUS_CHANGE_PIPE) { + return EINVAL; + } + + hub_t *hub = (hub_t *)dev->device_data; + + hub_acquire(hub); + + uint8_t change_map = hub_get_status_change_bitmap(hub); + + uint8_t *b = (uint8_t *) buffer; + if (size > 0) { + *b = change_map; + *actual_size = 1; + } + + hub_release(hub); + + return EOK; +} + +/** Handle ClearHubFeature request. + * + * @param dev Virtual device representing the hub. + * @param request The SETUP packet of the control request. + * @param data Extra data (when DATA stage present). + * @return Error code. + */ +static int req_clear_hub_feature(usbvirt_device_t *dev, + usb_device_request_setup_packet_t *request, + uint8_t *data) +{ + return ENOTSUP; +} + +/** Handle ClearPortFeature request. + * + * @param dev Virtual device representing the hub. + * @param request The SETUP packet of the control request. + * @param data Extra data (when DATA stage present). + * @return Error code. + */ +static int req_clear_port_feature(usbvirt_device_t *dev, + usb_device_request_setup_packet_t *request, + uint8_t *data) +{ + int rc; + size_t port = request->index - 1; + usb_hub_class_feature_t feature = request->value; + hub_t *hub = (hub_t *) dev->device_data; + + hub_acquire(hub); + + hub_port_state_t port_state = hub_get_port_state(hub, port); + + switch (feature) { + case USB_HUB_FEATURE_PORT_ENABLE: + if ((port_state != HUB_PORT_STATE_NOT_CONFIGURED) + && (port_state != HUB_PORT_STATE_POWERED_OFF)) { + hub_set_port_state(hub, port, HUB_PORT_STATE_DISABLED); + } + rc = EOK; + break; + + case USB_HUB_FEATURE_PORT_SUSPEND: + if (port_state != HUB_PORT_STATE_SUSPENDED) { + rc = EOK; + break; + } + hub_set_port_state(hub, port, HUB_PORT_STATE_RESUMING); + rc = EOK; + break; + + case USB_HUB_FEATURE_PORT_POWER: + if (port_state != HUB_PORT_STATE_NOT_CONFIGURED) { + hub_set_port_state(hub, port, HUB_PORT_STATE_POWERED_OFF); + } + rc = EOK; + break; + + case USB_HUB_FEATURE_C_PORT_CONNECTION: + hub_clear_port_status_change(hub, port, HUB_STATUS_C_PORT_CONNECTION); + rc = EOK; + break; + + case USB_HUB_FEATURE_C_PORT_ENABLE: + hub_clear_port_status_change(hub, port, HUB_STATUS_C_PORT_ENABLE); + rc = EOK; + break; + + case USB_HUB_FEATURE_C_PORT_SUSPEND: + hub_clear_port_status_change(hub, port, HUB_STATUS_C_PORT_SUSPEND); + rc = EOK; + break; + + case USB_HUB_FEATURE_C_PORT_OVER_CURRENT: + hub_clear_port_status_change(hub, port, HUB_STATUS_C_PORT_OVER_CURRENT); + rc = EOK; + break; + + case USB_HUB_FEATURE_C_PORT_RESET: + hub_clear_port_status_change(hub, port, HUB_STATUS_C_PORT_RESET); + rc = EOK; + break; + + default: + rc = ENOTSUP; + break; + } + + hub_release(hub); + + return rc; +} + +/** Handle GetBusState request. + * + * @param dev Virtual device representing the hub. + * @param request The SETUP packet of the control request. + * @param data Extra data (when DATA stage present). + * @return Error code. + */ +static int req_get_bus_state(usbvirt_device_t *dev, + usb_device_request_setup_packet_t *request, + uint8_t *data) +{ + return ENOTSUP; +} + +/** Handle GetDescriptor request. + * + * @param dev Virtual device representing the hub. + * @param request The SETUP packet of the control request. + * @param data Extra data (when DATA stage present). + * @return Error code. + */ +static int req_get_descriptor(usbvirt_device_t *dev, + usb_device_request_setup_packet_t *request, + uint8_t *data) +{ + if (request->value_high == USB_DESCTYPE_HUB) { + int rc = dev->control_transfer_reply(dev, 0, + &hub_descriptor, hub_descriptor.length); + + return rc; + } + /* Let the framework handle all the rest. */ + return EFORWARD; +} + +/** Handle GetHubStatus request. + * + * @param dev Virtual device representing the hub. + * @param request The SETUP packet of the control request. + * @param data Extra data (when DATA stage present). + * @return Error code. + */ +static int req_get_hub_status(usbvirt_device_t *dev, + usb_device_request_setup_packet_t *request, + uint8_t *data) +{ + uint32_t hub_status = 0; + + return dev->control_transfer_reply(dev, 0, + &hub_status, sizeof(hub_status)); +} + +/** Handle GetPortStatus request. + * + * @param dev Virtual device representing the hub. + * @param request The SETUP packet of the control request. + * @param data Extra data (when DATA stage present). + * @return Error code. + */ +static int req_get_port_status(usbvirt_device_t *dev, + usb_device_request_setup_packet_t *request, + uint8_t *data) +{ + hub_t *hub = (hub_t *) dev->device_data; + + hub_acquire(hub); + + uint32_t status = hub_get_port_status(hub, request->index - 1); + + hub_release(hub); + + return dev->control_transfer_reply(dev, 0, &status, 4); +} + +/** Handle SetHubFeature request. + * + * @param dev Virtual device representing the hub. + * @param request The SETUP packet of the control request. + * @param data Extra data (when DATA stage present). + * @return Error code. + */ +static int req_set_hub_feature(usbvirt_device_t *dev, + usb_device_request_setup_packet_t *request, + uint8_t *data) +{ + return ENOTSUP; +} + +/** Handle SetPortFeature request. + * + * @param dev Virtual device representing the hub. + * @param request The SETUP packet of the control request. + * @param data Extra data (when DATA stage present). + * @return Error code. + */ +static int req_set_port_feature(usbvirt_device_t *dev, + usb_device_request_setup_packet_t *request, + uint8_t *data) +{ + int rc; + size_t port = request->index - 1; + usb_hub_class_feature_t feature = request->value; + hub_t *hub = (hub_t *) dev->device_data; + + hub_acquire(hub); + + hub_port_state_t port_state = hub_get_port_state(hub, port); + + switch (feature) { + case USB_HUB_FEATURE_PORT_RESET: + if (port_state != HUB_PORT_STATE_POWERED_OFF) { + hub_set_port_state(hub, port, HUB_PORT_STATE_RESETTING); + } + rc = EOK; + break; + + case USB_HUB_FEATURE_PORT_SUSPEND: + if (port_state == HUB_PORT_STATE_ENABLED) { + hub_set_port_state(hub, port, HUB_PORT_STATE_SUSPENDED); + } + rc = EOK; + break; + + case USB_HUB_FEATURE_PORT_POWER: + if (port_state == HUB_PORT_STATE_POWERED_OFF) { + hub_set_port_state(hub, port, HUB_PORT_STATE_DISCONNECTED); + } + rc = EOK; + break; + + default: + break; + } + + hub_release(hub); + + return rc; +} + + +/** IN class request. */ +#define CLASS_REQ_IN(recipient) \ + USBVIRT_MAKE_CONTROL_REQUEST_TYPE(USB_DIRECTION_IN, \ + USBVIRT_REQUEST_TYPE_CLASS, recipient) +/** OUT class request. */ +#define CLASS_REQ_OUT(recipient) \ + USBVIRT_MAKE_CONTROL_REQUEST_TYPE(USB_DIRECTION_OUT, \ + USBVIRT_REQUEST_TYPE_CLASS, recipient) + +/** Recipient: other. */ +#define REC_OTHER USBVIRT_REQUEST_RECIPIENT_OTHER +/** Recipient: device. */ +#define REC_DEVICE USBVIRT_REQUEST_RECIPIENT_DEVICE +/** Direction: in. */ +#define DIR_IN USB_DIRECTION_IN +/** Direction: out. */ +#define DIR_OUT USB_DIRECTION_OUT + +/** Create a class request. + * + * @param direction Request direction. + * @param recipient Request recipient. + * @param req Request code. + */ +#define CLASS_REQ(direction, recipient, req) \ + .request_type = USBVIRT_MAKE_CONTROL_REQUEST_TYPE(direction, \ + USBVIRT_REQUEST_TYPE_CLASS, recipient), \ + .request = req + +/** Create a standard request. + * + * @param direction Request direction. + * @param recipient Request recipient. + * @param req Request code. + */ +#define STD_REQ(direction, recipient, req) \ + .request_type = USBVIRT_MAKE_CONTROL_REQUEST_TYPE(direction, \ + USBVIRT_REQUEST_TYPE_STANDARD, recipient), \ + .request = req + +/** Hub operations on control endpoint zero. */ +static usbvirt_control_transfer_handler_t endpoint_zero_handlers[] = { + { + STD_REQ(DIR_IN, REC_DEVICE, USB_DEVREQ_GET_DESCRIPTOR), + .name = "GetDescriptor", + .callback = req_get_descriptor + }, + { + CLASS_REQ(DIR_IN, REC_DEVICE, USB_DEVREQ_GET_DESCRIPTOR), + .name = "GetDescriptor", + .callback = req_get_descriptor + }, + { + CLASS_REQ(DIR_IN, REC_OTHER, USB_HUB_REQUEST_GET_STATUS), + .name = "GetPortStatus", + .callback = req_get_port_status + }, + { + CLASS_REQ(DIR_OUT, REC_DEVICE, USB_HUB_REQUEST_CLEAR_FEATURE), + .name = "ClearHubFeature", + .callback = req_clear_hub_feature + }, + { + CLASS_REQ(DIR_OUT, REC_OTHER, USB_HUB_REQUEST_CLEAR_FEATURE), + .name = "ClearPortFeature", + .callback = req_clear_port_feature + }, + { + CLASS_REQ(DIR_IN, REC_OTHER, USB_HUB_REQUEST_GET_STATE), + .name = "GetBusState", + .callback = req_get_bus_state + }, + { + CLASS_REQ(DIR_IN, REC_DEVICE, USB_HUB_REQUEST_GET_DESCRIPTOR), + .name = "GetHubDescriptor", + .callback = req_get_descriptor + }, + { + CLASS_REQ(DIR_IN, REC_DEVICE, USB_HUB_REQUEST_GET_STATUS), + .name = "GetHubStatus", + .callback = req_get_hub_status + }, + { + CLASS_REQ(DIR_IN, REC_OTHER, USB_HUB_REQUEST_GET_STATUS), + .name = "GetPortStatus", + .callback = req_get_port_status + }, + { + CLASS_REQ(DIR_OUT, REC_DEVICE, USB_HUB_REQUEST_SET_FEATURE), + .name = "SetHubFeature", + .callback = req_set_hub_feature + }, + { + CLASS_REQ(DIR_OUT, REC_OTHER, USB_HUB_REQUEST_SET_FEATURE), + .name = "SetPortFeature", + .callback = req_set_port_feature + }, + USBVIRT_CONTROL_TRANSFER_HANDLER_LAST +}; + + +/** Hub operations. */ +usbvirt_device_ops_t hub_ops = { + .control_transfer_handlers = endpoint_zero_handlers, + .on_data = NULL, + .on_data_request = req_on_data, + .on_state_change = on_state_change, +}; + +/** + * @} + */ Index: uspace/drv/vhc/vhc.ma =================================================================== --- uspace/drv/vhc/vhc.ma (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/drv/vhc/vhc.ma (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,2 @@ +10 usb&hc=vhc + Index: uspace/drv/vhc/vhcd.h =================================================================== --- uspace/drv/vhc/vhcd.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/drv/vhc/vhcd.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,54 @@ +/* + * 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 usb + * @{ + */ +/** @file + * @brief Virtual USB host controller common definitions. + */ +#ifndef VHCD_VHCD_H_ +#define VHCD_VHCD_H_ + +#include + +#define NAME "vhc" +#define NAME_DEV "hcd-virt-dev" +#define NAMESPACE "usb" + +#define DEVMAP_PATH_HC NAMESPACE "/" NAME +#define DEVMAP_PATH_DEV NAMESPACE "/" NAME_DEV + +#define dprintf(level, format, ...) \ + usb_dprintf(NAME, (level), format "\n", ##__VA_ARGS__) +void dprintf_inval_call(int, ipc_call_t, sysarg_t); + +#endif +/** + * @} + */ Index: uspace/lib/c/generic/devman.c =================================================================== --- uspace/lib/c/generic/devman.c (revision 6eb794aa8b215fdc5cb202ffc13bae94b06623b0) +++ uspace/lib/c/generic/devman.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -230,8 +230,8 @@ if (flags & IPC_FLAG_BLOCKING) { - phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_DEVMAN, + phone = async_connect_me_to_blocking(PHONE_NS, SERVICE_DEVMAN, DEVMAN_CONNECT_TO_DEVICE, handle); } else { - phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAN, + phone = async_connect_me_to(PHONE_NS, SERVICE_DEVMAN, DEVMAN_CONNECT_TO_DEVICE, handle); } Index: uspace/lib/c/include/ipc/dev_iface.h =================================================================== --- uspace/lib/c/include/ipc/dev_iface.h (revision 6eb794aa8b215fdc5cb202ffc13bae94b06623b0) +++ uspace/lib/c/include/ipc/dev_iface.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -38,4 +38,8 @@ HW_RES_DEV_IFACE = 0, CHAR_DEV_IFACE, + + /** Interface provided by USB host controller. */ + USBHC_DEV_IFACE, + // TODO add more interfaces DEV_IFACE_MAX @@ -50,4 +54,14 @@ DEV_IFACE_ID(DEV_FIRST_CUSTOM_METHOD_IDX) +/* + * The first argument is actually method (as the "real" method is used + * for indexing into interfaces. + */ + +#define DEV_IPC_GET_ARG1(call) IPC_GET_ARG2((call)) +#define DEV_IPC_GET_ARG2(call) IPC_GET_ARG3((call)) +#define DEV_IPC_GET_ARG3(call) IPC_GET_ARG4((call)) +#define DEV_IPC_GET_ARG4(call) IPC_GET_ARG5((call)) + #endif Index: uspace/lib/drv/Makefile =================================================================== --- uspace/lib/drv/Makefile (revision 6eb794aa8b215fdc5cb202ffc13bae94b06623b0) +++ uspace/lib/drv/Makefile (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -29,5 +29,5 @@ USPACE_PREFIX = ../.. -EXTRA_CFLAGS = -Iinclude +EXTRA_CFLAGS = -Iinclude -I$(LIBUSB_PREFIX)/include LIBRARY = libdrv @@ -36,4 +36,5 @@ generic/dev_iface.c \ generic/remote_res.c \ + generic/remote_usbhc.c \ generic/remote_char.c Index: uspace/lib/drv/generic/dev_iface.c =================================================================== --- uspace/lib/drv/generic/dev_iface.c (revision 6eb794aa8b215fdc5cb202ffc13bae94b06623b0) +++ uspace/lib/drv/generic/dev_iface.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -39,9 +39,11 @@ #include "remote_res.h" #include "remote_char.h" +#include "remote_usbhc.h" static iface_dipatch_table_t remote_ifaces = { .ifaces = { &remote_res_iface, - &remote_char_iface + &remote_char_iface, + &remote_usbhc_iface } }; Index: uspace/lib/drv/generic/driver.c =================================================================== --- uspace/lib/drv/generic/driver.c (revision 6eb794aa8b215fdc5cb202ffc13bae94b06623b0) +++ uspace/lib/drv/generic/driver.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -390,5 +390,6 @@ */ int child_device_register_wrapper(device_t *parent, const char *child_name, - const char *child_match_id, int child_match_score) + const char *child_match_id, int child_match_score, + devman_handle_t *child_handle) { device_t *child = NULL; @@ -418,4 +419,7 @@ goto failure; + if (child_handle != NULL) { + *child_handle = child->handle; + } return EOK; Index: uspace/lib/drv/generic/remote_usbhc.c =================================================================== --- uspace/lib/drv/generic/remote_usbhc.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/lib/drv/generic/remote_usbhc.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,502 @@ +/* + * 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 libdrv + * @{ + */ +/** @file + */ + +#include +#include +#include + +#include "usbhc_iface.h" +#include "driver.h" + +#define USB_MAX_PAYLOAD_SIZE 1020 + +static void remote_usbhc_get_address(device_t *, void *, ipc_callid_t, ipc_call_t *); +static void remote_usbhc_get_buffer(device_t *, void *, ipc_callid_t, ipc_call_t *); +static void remote_usbhc_interrupt_out(device_t *, void *, ipc_callid_t, ipc_call_t *); +static void remote_usbhc_interrupt_in(device_t *, void *, ipc_callid_t, ipc_call_t *); +static void remote_usbhc_control_write_setup(device_t *, void *, ipc_callid_t, ipc_call_t *); +static void remote_usbhc_control_write_data(device_t *, void *, ipc_callid_t, ipc_call_t *); +static void remote_usbhc_control_write_status(device_t *, void *, ipc_callid_t, ipc_call_t *); +static void remote_usbhc_control_read_setup(device_t *, void *, ipc_callid_t, ipc_call_t *); +static void remote_usbhc_control_read_data(device_t *, void *, ipc_callid_t, ipc_call_t *); +static void remote_usbhc_control_read_status(device_t *, void *, ipc_callid_t, ipc_call_t *); +static void remote_usbhc_reserve_default_address(device_t *, void *, ipc_callid_t, ipc_call_t *); +static void remote_usbhc_release_default_address(device_t *, void *, ipc_callid_t, ipc_call_t *); +static void remote_usbhc_request_address(device_t *, void *, ipc_callid_t, ipc_call_t *); +static void remote_usbhc_bind_address(device_t *, void *, ipc_callid_t, ipc_call_t *); +static void remote_usbhc_release_address(device_t *, void *, ipc_callid_t, ipc_call_t *); +//static void remote_usbhc(device_t *, void *, ipc_callid_t, ipc_call_t *); + +/** Remote USB interface operations. */ +static remote_iface_func_ptr_t remote_usbhc_iface_ops [] = { + remote_usbhc_get_address, + + remote_usbhc_get_buffer, + + remote_usbhc_reserve_default_address, + remote_usbhc_release_default_address, + + remote_usbhc_request_address, + remote_usbhc_bind_address, + remote_usbhc_release_address, + + remote_usbhc_interrupt_out, + remote_usbhc_interrupt_in, + + remote_usbhc_control_write_setup, + remote_usbhc_control_write_data, + remote_usbhc_control_write_status, + + remote_usbhc_control_read_setup, + remote_usbhc_control_read_data, + remote_usbhc_control_read_status +}; + +/** Remote USB interface structure. + */ +remote_iface_t remote_usbhc_iface = { + .method_count = sizeof(remote_usbhc_iface_ops) / + sizeof(remote_usbhc_iface_ops[0]), + .methods = remote_usbhc_iface_ops +}; + +typedef struct { + ipc_callid_t caller; + void *buffer; + size_t size; +} async_transaction_t; + +void remote_usbhc_get_address(device_t *device, void *iface, + ipc_callid_t callid, ipc_call_t *call) +{ + usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface; + + if (!usb_iface->tell_address) { + ipc_answer_0(callid, ENOTSUP); + return; + } + + devman_handle_t handle = DEV_IPC_GET_ARG1(*call); + + usb_address_t address; + int rc = usb_iface->tell_address(device, handle, &address); + if (rc != EOK) { + ipc_answer_0(callid, rc); + } else { + ipc_answer_1(callid, EOK, address); + } +} + +void remote_usbhc_get_buffer(device_t *device, void *iface, + ipc_callid_t callid, ipc_call_t *call) +{ + sysarg_t buffer_hash = DEV_IPC_GET_ARG1(*call); + async_transaction_t * trans = (async_transaction_t *)buffer_hash; + if (trans == NULL) { + ipc_answer_0(callid, ENOENT); + return; + } + if (trans->buffer == NULL) { + ipc_answer_0(callid, EINVAL); + free(trans); + return; + } + + ipc_callid_t cid; + size_t accepted_size; + if (!async_data_read_receive(&cid, &accepted_size)) { + ipc_answer_0(callid, EINVAL); + return; + } + + if (accepted_size > trans->size) { + accepted_size = trans->size; + } + async_data_read_finalize(cid, trans->buffer, accepted_size); + + ipc_answer_1(callid, EOK, accepted_size); + + free(trans->buffer); + free(trans); +} + +void remote_usbhc_reserve_default_address(device_t *device, void *iface, + ipc_callid_t callid, ipc_call_t *call) +{ + usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface; + + if (!usb_iface->reserve_default_address) { + ipc_answer_0(callid, ENOTSUP); + return; + } + + int rc = usb_iface->reserve_default_address(device); + + ipc_answer_0(callid, rc); +} + +void remote_usbhc_release_default_address(device_t *device, void *iface, + ipc_callid_t callid, ipc_call_t *call) +{ + usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface; + + if (!usb_iface->release_default_address) { + ipc_answer_0(callid, ENOTSUP); + return; + } + + int rc = usb_iface->release_default_address(device); + + ipc_answer_0(callid, rc); +} + +void remote_usbhc_request_address(device_t *device, void *iface, + ipc_callid_t callid, ipc_call_t *call) +{ + usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface; + + if (!usb_iface->request_address) { + ipc_answer_0(callid, ENOTSUP); + return; + } + + usb_address_t address; + int rc = usb_iface->request_address(device, &address); + if (rc != EOK) { + ipc_answer_0(callid, rc); + } else { + ipc_answer_1(callid, EOK, (sysarg_t) address); + } +} + +void remote_usbhc_bind_address(device_t *device, void *iface, + ipc_callid_t callid, ipc_call_t *call) +{ + usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface; + + if (!usb_iface->bind_address) { + ipc_answer_0(callid, ENOTSUP); + return; + } + + usb_address_t address = (usb_address_t) DEV_IPC_GET_ARG1(*call); + devman_handle_t handle = (devman_handle_t) DEV_IPC_GET_ARG2(*call); + + int rc = usb_iface->bind_address(device, address, handle); + + ipc_answer_0(callid, rc); +} + +void remote_usbhc_release_address(device_t *device, void *iface, + ipc_callid_t callid, ipc_call_t *call) +{ + usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface; + + if (!usb_iface->release_address) { + ipc_answer_0(callid, ENOTSUP); + return; + } + + usb_address_t address = (usb_address_t) DEV_IPC_GET_ARG1(*call); + + int rc = usb_iface->release_address(device, address); + + ipc_answer_0(callid, rc); +} + + +static void callback_out(device_t *device, + usb_transaction_outcome_t outcome, void *arg) +{ + async_transaction_t *trans = (async_transaction_t *)arg; + + // FIXME - answer according to outcome + ipc_answer_0(trans->caller, EOK); + + free(trans); +} + +static void callback_in(device_t *device, + usb_transaction_outcome_t outcome, size_t actual_size, void *arg) +{ + async_transaction_t *trans = (async_transaction_t *)arg; + + // FIXME - answer according to outcome + ipc_answer_1(trans->caller, EOK, (sysarg_t)trans); + + trans->size = actual_size; +} + +/** Process an outgoing transfer (both OUT and SETUP). + * + * @param device Target device. + * @param callid Initiating caller. + * @param call Initiating call. + * @param transfer_func Transfer function (might be NULL). + */ +static void remote_usbhc_out_transfer(device_t *device, + ipc_callid_t callid, ipc_call_t *call, + usbhc_iface_transfer_out_t transfer_func) +{ + if (!transfer_func) { + ipc_answer_0(callid, ENOTSUP); + return; + } + + size_t expected_len = DEV_IPC_GET_ARG3(*call); + usb_target_t target = { + .address = DEV_IPC_GET_ARG1(*call), + .endpoint = DEV_IPC_GET_ARG2(*call) + }; + + size_t len = 0; + void *buffer = NULL; + if (expected_len > 0) { + int rc = async_data_write_accept(&buffer, false, + 1, USB_MAX_PAYLOAD_SIZE, + 0, &len); + + if (rc != EOK) { + ipc_answer_0(callid, rc); + return; + } + } + + async_transaction_t *trans = malloc(sizeof(async_transaction_t)); + trans->caller = callid; + trans->buffer = buffer; + trans->size = len; + + int rc = transfer_func(device, target, buffer, len, + callback_out, trans); + + if (rc != EOK) { + ipc_answer_0(callid, rc); + if (buffer != NULL) { + free(buffer); + } + free(trans); + } +} + +/** Process an incoming transfer. + * + * @param device Target device. + * @param callid Initiating caller. + * @param call Initiating call. + * @param transfer_func Transfer function (might be NULL). + */ +static void remote_usbhc_in_transfer(device_t *device, + ipc_callid_t callid, ipc_call_t *call, + usbhc_iface_transfer_in_t transfer_func) +{ + if (!transfer_func) { + ipc_answer_0(callid, ENOTSUP); + return; + } + + size_t len = DEV_IPC_GET_ARG3(*call); + usb_target_t target = { + .address = DEV_IPC_GET_ARG1(*call), + .endpoint = DEV_IPC_GET_ARG2(*call) + }; + + async_transaction_t *trans = malloc(sizeof(async_transaction_t)); + trans->caller = callid; + trans->buffer = malloc(len); + trans->size = len; + + int rc = transfer_func(device, target, trans->buffer, len, + callback_in, trans); + + if (rc != EOK) { + ipc_answer_0(callid, rc); + free(trans->buffer); + free(trans); + } +} + +/** Process status part of control transfer. + * + * @param device Target device. + * @param callid Initiating caller. + * @param call Initiating call. + * @param direction Transfer direction (read ~ in, write ~ out). + * @param transfer_in_func Transfer function for control read (might be NULL). + * @param transfer_out_func Transfer function for control write (might be NULL). + */ +static void remote_usbhc_status_transfer(device_t *device, + ipc_callid_t callid, ipc_call_t *call, + usb_direction_t direction, + int (*transfer_in_func)(device_t *, usb_target_t, + usbhc_iface_transfer_in_callback_t, void *), + int (*transfer_out_func)(device_t *, usb_target_t, + usbhc_iface_transfer_out_callback_t, void *)) +{ + switch (direction) { + case USB_DIRECTION_IN: + if (!transfer_in_func) { + ipc_answer_0(callid, ENOTSUP); + return; + } + break; + case USB_DIRECTION_OUT: + if (!transfer_out_func) { + ipc_answer_0(callid, ENOTSUP); + return; + } + break; + default: + assert(false && "unreachable code"); + break; + } + + usb_target_t target = { + .address = DEV_IPC_GET_ARG1(*call), + .endpoint = DEV_IPC_GET_ARG2(*call) + }; + + async_transaction_t *trans = malloc(sizeof(async_transaction_t)); + trans->caller = callid; + trans->buffer = NULL; + trans->size = 0; + + int rc; + switch (direction) { + case USB_DIRECTION_IN: + rc = transfer_in_func(device, target, + callback_in, trans); + break; + case USB_DIRECTION_OUT: + rc = transfer_out_func(device, target, + callback_out, trans); + break; + default: + assert(false && "unreachable code"); + break; + } + + if (rc != EOK) { + ipc_answer_0(callid, rc); + free(trans); + } + return; +} + + +void remote_usbhc_interrupt_out(device_t *device, void *iface, + ipc_callid_t callid, ipc_call_t *call) +{ + usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface; + assert(usb_iface != NULL); + + return remote_usbhc_out_transfer(device, callid, call, + usb_iface->interrupt_out); +} + +void remote_usbhc_interrupt_in(device_t *device, void *iface, + ipc_callid_t callid, ipc_call_t *call) +{ + usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface; + assert(usb_iface != NULL); + + return remote_usbhc_in_transfer(device, callid, call, + usb_iface->interrupt_in); +} + +void remote_usbhc_control_write_setup(device_t *device, void *iface, + ipc_callid_t callid, ipc_call_t *call) +{ + usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface; + assert(usb_iface != NULL); + + return remote_usbhc_out_transfer(device, callid, call, + usb_iface->control_write_setup); +} + +void remote_usbhc_control_write_data(device_t *device, void *iface, + ipc_callid_t callid, ipc_call_t *call) +{ + usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface; + assert(usb_iface != NULL); + + return remote_usbhc_out_transfer(device, callid, call, + usb_iface->control_write_data); +} + +void remote_usbhc_control_write_status(device_t *device, void *iface, + ipc_callid_t callid, ipc_call_t *call) +{ + usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface; + assert(usb_iface != NULL); + + return remote_usbhc_status_transfer(device, callid, call, + USB_DIRECTION_IN, usb_iface->control_write_status, NULL); +} + +void remote_usbhc_control_read_setup(device_t *device, void *iface, + ipc_callid_t callid, ipc_call_t *call) +{ + usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface; + assert(usb_iface != NULL); + + return remote_usbhc_out_transfer(device, callid, call, + usb_iface->control_read_setup); +} + +void remote_usbhc_control_read_data(device_t *device, void *iface, + ipc_callid_t callid, ipc_call_t *call) +{ + usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface; + assert(usb_iface != NULL); + + return remote_usbhc_in_transfer(device, callid, call, + usb_iface->control_read_data); +} + +void remote_usbhc_control_read_status(device_t *device, void *iface, + ipc_callid_t callid, ipc_call_t *call) +{ + usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface; + assert(usb_iface != NULL); + + return remote_usbhc_status_transfer(device, callid, call, + USB_DIRECTION_OUT, NULL, usb_iface->control_read_status); +} + + + +/** + * @} + */ Index: uspace/lib/drv/include/driver.h =================================================================== --- uspace/lib/drv/include/driver.h (revision 6eb794aa8b215fdc5cb202ffc13bae94b06623b0) +++ uspace/lib/drv/include/driver.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -199,5 +199,6 @@ int child_device_register(device_t *, device_t *); -int child_device_register_wrapper(device_t *, const char *, const char *, int); +int child_device_register_wrapper(device_t *, const char *, const char *, int, + devman_handle_t *); Index: uspace/lib/drv/include/remote_usbhc.h =================================================================== --- uspace/lib/drv/include/remote_usbhc.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/lib/drv/include/remote_usbhc.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,44 @@ +/* + * 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 libdrv + * @{ + */ +/** @file + */ + +#ifndef LIBDRV_REMOTE_USBHC_H_ +#define LIBDRV_REMOTE_USBHC_H_ + +remote_iface_t remote_usbhc_iface; + +#endif + +/** + * @} + */ Index: uspace/lib/drv/include/usbhc_iface.h =================================================================== --- uspace/lib/drv/include/usbhc_iface.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/lib/drv/include/usbhc_iface.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,256 @@ +/* + * 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 libdrv usb + * @{ + */ +/** @file + * @brief USB interface definition. + */ + +#ifndef LIBDRV_USBHC_IFACE_H_ +#define LIBDRV_USBHC_IFACE_H_ + +#include "driver.h" +#include + + +/** IPC methods for communication with HC through DDF interface. + * + * Notes for async methods: + * + * Methods for sending data to device (OUT transactions) + * - e.g. IPC_M_USBHC_INTERRUPT_OUT - + * always use the same semantics: + * - first, IPC call with given method is made + * - argument #1 is target address + * - argument #2 is target endpoint + * - argument #3 is buffer size + * - this call is immediately followed by IPC data write (from caller) + * - the initial call (and the whole transaction) is answer after the + * transaction is scheduled by the HC and acknowledged by the device + * or immediately after error is detected + * - the answer carries only the error code + * + * Methods for retrieving data from device (IN transactions) + * - e.g. IPC_M_USBHC_INTERRUPT_IN - + * also use the same semantics: + * - first, IPC call with given method is made + * - argument #1 is target address + * - argument #2 is target endpoint + * - argument #3 is buffer size + * - the call is not answered until the device returns some data (or until + * error occurs) + * - if the call is answered with EOK, first argument of the answer is buffer + * hash that could be used to retrieve the actual data + * + * Some special methods (NO-DATA transactions) do not send any data. These + * might behave as both OUT or IN transactions because communication parts + * where actual buffers are exchanged are omitted. + * + * The mentioned data retrieval can be done any time after receiving EOK + * answer to IN method. + * This retrieval is done using the IPC_M_USBHC_GET_BUFFER where + * the first argument is buffer hash from call answer. + * This call must be immediately followed by data read-in and after the + * data are transferred, the initial call (IPC_M_USBHC_GET_BUFFER) + * is answered. Each buffer can be retrieved only once. + * + * For all these methods, wrap functions exists. Important rule: functions + * for IN transactions have (as parameters) buffers where retrieved data + * will be stored. These buffers must be already allocated and shall not be + * touch until the transaction is completed + * (e.g. not before calling usb_wait_for() with appropriate handle). + * OUT transactions buffers can be freed immediately after call is dispatched + * (i.e. after return from wrapping function). + * + */ +typedef enum { + /** Tell USB address assigned to device. + * Parameters: + * - devman handle id + * Answer: + * - EINVAL - unknown handle or handle not managed by this driver + * - ENOTSUP - operation not supported by HC (shall not happen) + * - arbitrary error code if returned by remote implementation + * - EOK - handle found, first parameter contains the USB address + */ + IPC_M_USBHC_GET_ADDRESS, + + /** Asks for data buffer. + * See explanation at usb_iface_funcs_t. + * This function does not have counter part in functional interface + * as it is handled by the remote part itself. + */ + IPC_M_USBHC_GET_BUFFER, + + + /** Reserve usage of default address. + * This call informs the host controller that the caller will be + * using default USB address. It is duty of the HC driver to ensure + * that only single entity will have it reserved. + * The address is returned via IPC_M_USBHC_RELEASE_DEFAULT_ADDRESS. + * The caller can start using the address after receiving EOK + * answer. + */ + IPC_M_USBHC_RESERVE_DEFAULT_ADDRESS, + + /** Release usage of default address. + * @see IPC_M_USBHC_RESERVE_DEFAULT_ADDRESS + */ + IPC_M_USBHC_RELEASE_DEFAULT_ADDRESS, + + /** Asks for address assignment by host controller. + * Answer: + * - ELIMIT - host controller run out of address + * - EOK - address assigned + * Answer arguments: + * - assigned address + * + * The address must be released by via IPC_M_USBHC_RELEASE_ADDRESS. + */ + IPC_M_USBHC_REQUEST_ADDRESS, + + /** Bind USB address with devman handle. + * Parameters: + * - USB address + * - devman handle + * Answer: + * - EOK - address binded + * - ENOENT - address is not in use + */ + IPC_M_USBHC_BIND_ADDRESS, + + /** Release address in use. + * Arguments: + * - address to be released + * Answer: + * - ENOENT - address not in use + * - EPERM - trying to release default USB address + */ + IPC_M_USBHC_RELEASE_ADDRESS, + + + /** Send interrupt data to device. + * See explanation at usb_iface_funcs_t (OUT transaction). + */ + IPC_M_USBHC_INTERRUPT_OUT, + + /** Get interrupt data from device. + * See explanation at usb_iface_funcs_t (IN transaction). + */ + IPC_M_USBHC_INTERRUPT_IN, + + + /** Start WRITE control transfer. + * See explanation at usb_iface_funcs_t (OUT transaction). + */ + IPC_M_USBHC_CONTROL_WRITE_SETUP, + + /** Send control-transfer data to device. + * See explanation at usb_iface_funcs_t (OUT transaction). + */ + IPC_M_USBHC_CONTROL_WRITE_DATA, + + /** Terminate WRITE control transfer. + * See explanation at usb_iface_funcs_t (NO-DATA transaction). + */ + IPC_M_USBHC_CONTROL_WRITE_STATUS, + + + + /** Start READ control transfer. + * See explanation at usb_iface_funcs_t (OUT transaction). + */ + IPC_M_USBHC_CONTROL_READ_SETUP, + + /** Get control-transfer data from device. + * See explanation at usb_iface_funcs_t (IN transaction). + */ + IPC_M_USBHC_CONTROL_READ_DATA, + + /** Terminate READ control transfer. + * See explanation at usb_iface_funcs_t (NO-DATA transaction). + */ + IPC_M_USBHC_CONTROL_READ_STATUS, + + + /* IPC_M_USB_ */ +} usbhc_iface_funcs_t; + +/** Callback for outgoing transfer. */ +typedef void (*usbhc_iface_transfer_out_callback_t)(device_t *, + usb_transaction_outcome_t, void *); + +/** Callback for incoming transfer. */ +typedef void (*usbhc_iface_transfer_in_callback_t)(device_t *, + usb_transaction_outcome_t, size_t, void *); + + +/** Out transfer processing function prototype. */ +typedef int (*usbhc_iface_transfer_out_t)(device_t *, usb_target_t, + void *, size_t, + usbhc_iface_transfer_out_callback_t, void *); + +/** Setup transfer processing function prototype. */ +typedef usbhc_iface_transfer_out_t usbhc_iface_transfer_setup_t; + +/** In transfer processing function prototype. */ +typedef int (*usbhc_iface_transfer_in_t)(device_t *, usb_target_t, + void *, size_t, + usbhc_iface_transfer_in_callback_t, void *); + +/** USB devices communication interface. */ +typedef struct { + int (*tell_address)(device_t *, devman_handle_t, usb_address_t *); + + int (*reserve_default_address)(device_t *); + int (*release_default_address)(device_t *); + int (*request_address)(device_t *, usb_address_t *); + int (*bind_address)(device_t *, usb_address_t, devman_handle_t); + int (*release_address)(device_t *, usb_address_t); + + usbhc_iface_transfer_out_t interrupt_out; + usbhc_iface_transfer_in_t interrupt_in; + + usbhc_iface_transfer_setup_t control_write_setup; + usbhc_iface_transfer_out_t control_write_data; + int (*control_write_status)(device_t *, usb_target_t, + usbhc_iface_transfer_in_callback_t, void *); + + usbhc_iface_transfer_setup_t control_read_setup; + usbhc_iface_transfer_in_t control_read_data; + int (*control_read_status)(device_t *, usb_target_t, + usbhc_iface_transfer_out_callback_t, void *); +} usbhc_iface_t; + + +#endif +/** + * @} + */ Index: uspace/lib/usb/Makefile =================================================================== --- uspace/lib/usb/Makefile (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/lib/usb/Makefile (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,49 @@ +# +# 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 = ../.. +LIBRARY = libusb +LIBS = $(LIBDRV_PREFIX)/libdrv.a +EXTRA_CFLAGS += -I$(LIBDRV_PREFIX)/include -Iinclude + +SOURCES = \ + src/addrkeep.c \ + src/class.c \ + src/debug.c \ + src/drvpsync.c \ + src/hcdhubd.c \ + src/hcdrv.c \ + src/hidparser.c \ + src/localdrv.c \ + src/recognise.c \ + src/remotedrv.c \ + src/usb.c \ + src/usbdrvreq.c \ + src/usbdrv.c + +include $(USPACE_PREFIX)/Makefile.common Index: uspace/lib/usb/include/usb/classes/classes.h =================================================================== --- uspace/lib/usb/include/usb/classes/classes.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/lib/usb/include/usb/classes/classes.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,67 @@ +/* + * 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 libusb usb + * @{ + */ +/** @file + * @brief USB device classes and subclasses. + */ +#ifndef LIBUSB_CLASSES_H_ +#define LIBUSB_CLASSES_H_ + +/** USB device class. */ +typedef enum { + USB_CLASS_USE_INTERFACE = 0x00, + USB_CLASS_AUDIO = 0x01, + USB_CLASS_COMMUNICATIONS_CDC_CONTROL = 0x02, + USB_CLASS_HID = 0x03, + USB_CLASS_PHYSICAL = 0x05, + USB_CLASS_IMAGE = 0x06, + USB_CLASS_PRINTER = 0x07, + USB_CLASS_MASS_STORAGE = 0x08, + USB_CLASS_HUB = 0x09, + USB_CLASS_CDC_DATA = 0x0A, + USB_CLASS_SMART_CARD = 0x0B, + USB_CLASS_CONTENT_SECURITY = 0x0D, + USB_CLASS_VIDEO = 0x0E, + USB_CLASS_PERSONAL_HEALTHCARE = 0x0F, + USB_CLASS_DIAGNOSTIC = 0xDC, + USB_CLASS_WIRELESS_CONTROLLER = 0xE0, + USB_CLASS_MISCELLANEOUS = 0xEF, + USB_CLASS_APPLICATION_SPECIFIC = 0xFE, + USB_CLASS_VENDOR_SPECIFIC = 0xFF, + /* USB_CLASS_ = 0x, */ +} usb_class_t; + +const char *usb_str_class(usb_class_t); + +#endif +/** + * @} + */ Index: uspace/lib/usb/include/usb/classes/hid.h =================================================================== --- uspace/lib/usb/include/usb/classes/hid.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/lib/usb/include/usb/classes/hid.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,109 @@ +/* + * 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 libusb usb + * @{ + */ +/** @file + * @brief USB HID device related types. + */ +#ifndef LIBUSB_HID_H_ +#define LIBUSB_HID_H_ + +#include +#include +#include + +/** USB/HID device requests. */ +typedef enum { + USB_HIDREQ_GET_REPORT = 1, + USB_HIDREQ_GET_IDLE = 2, + USB_HIDREQ_GET_PROTOCOL = 3, + /* Values 4 to 8 are reserved. */ + USB_HIDREQ_SET_REPORT = 9, + USB_HIDREQ_SET_IDLE = 10, + USB_HIDREQ_SET_PROTOCOL = 11 +} usb_hid_request_t; + +/** USB/HID interface protocols. */ +typedef enum { + USB_HID_PROTOCOL_NONE = 0, + USB_HID_PROTOCOL_KEYBOARD = 1, + USB_HID_PROTOCOL_MOUSE = 2 +} usb_hid_protocol_t; + +/** Part of standard USB HID descriptor specifying one class descriptor. + * + * (See HID Specification, p.22) + */ +typedef struct { + /** Type of class descriptor (Report or Physical). */ + uint8_t class_descriptor_type; + /** Length of class descriptor. */ + uint16_t class_descriptor_length; +} __attribute__ ((packed)) usb_standard_hid_descriptor_class_item_t; + +/** Standard USB HID descriptor. + * + * (See HID Specification, p.22) + * + * It is actually only the "header" of the descriptor, as it may have arbitrary + * length if more than one class descritor is provided. + */ +typedef struct { + /** Size of this descriptor in bytes. */ + uint8_t length; + /** Descriptor type (USB_DESCTYPE_HID). */ + uint8_t descriptor_type; + /** HID Class Specification release. */ + uint16_t spec_release; + /** Country code of localized hardware. */ + uint8_t country_code; + /** Total number of class (i.e. Report and Physical) descriptors. */ + uint8_t class_count; + /** First mandatory class descriptor info. */ + usb_standard_hid_descriptor_class_item_t class_descriptor; +} __attribute__ ((packed)) usb_standard_hid_descriptor_t; + + +/** + * @brief USB/HID keyboard device type. + * + * Quite dummy right now. + */ +typedef struct { + device_t *device; + usb_address_t address; + usb_endpoint_t poll_endpoint; + usb_hid_report_parser_t *parser; +} usb_hid_dev_kbd_t; + +#endif +/** + * @} + */ Index: uspace/lib/usb/include/usb/classes/hidparser.h =================================================================== --- uspace/lib/usb/include/usb/classes/hidparser.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/lib/usb/include/usb/classes/hidparser.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,65 @@ +/* + * 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 libusb usb + * @{ + */ +/** @file + * @brief USB HID parser. + */ +#ifndef LIBUSB_HIDPARSER_H_ +#define LIBUSB_HIDPARSER_H_ + +#include + +/** HID report parser structure. */ +typedef struct { +} usb_hid_report_parser_t; + +/** HID parser callbacks for IN items. */ +typedef struct { + /** Callback for keyboard. + * + * @param key_codes Array of pressed key (including modifiers). + * @param count Length of @p key_codes. + * @param arg Custom argument. + */ + void (*keyboard)(const uint16_t *key_codes, size_t count, void *arg); +} usb_hid_report_in_callbacks_t; + +int usb_hid_parse_report_descriptor(usb_hid_report_parser_t *parser, + const uint8_t *data, size_t size); + +int usb_hid_parse_report(const usb_hid_report_parser_t *parser, + const uint8_t *data, size_t size, + const usb_hid_report_in_callbacks_t *callbacks, void *arg); + +#endif +/** + * @} + */ Index: uspace/lib/usb/include/usb/classes/hidut.h =================================================================== --- uspace/lib/usb/include/usb/classes/hidut.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/lib/usb/include/usb/classes/hidut.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,68 @@ +/* + * 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 libusb usb + * @{ + */ +/** @file + * @brief USB HID Usage Tables. + */ +#ifndef LIBUSB_HIDUT_H_ +#define LIBUSB_HIDUT_H_ + +/** USB/HID Usage Pages. */ +typedef enum { + USB_HIDUT_PAGE_GENERIC_DESKTOP = 1, + USB_HIDUT_PAGE_SIMULATION = 2, + USB_HIDUT_PAGE_VR = 3, + USB_HIDUT_PAGE_SPORT = 4, + USB_HIDUT_PAGE_GAME = 5, + USB_HIDUT_PAGE_GENERIC_DEVICE = 6, + USB_HIDUT_PAGE_KEYBOARD = 7, + USB_HIDUT_PAGE_LED = 8, + USB_HIDUT_PAGE_BUTTON = 9 + /* USB_HIDUT_PAGE_ = , */ +} usb_hidut_usage_page_t; + +/** Usages for Generic Desktop Page. */ +typedef enum { + USB_HIDUT_USAGE_GENERIC_DESKTOP_POINTER = 1, + USB_HIDUT_USAGE_GENERIC_DESKTOP_MOUSE = 2, + USB_HIDUT_USAGE_GENERIC_DESKTOP_JOYSTICK = 4, + USB_HIDUT_USAGE_GENERIC_DESKTOP_GAMEPAD = 5, + USB_HIDUT_USAGE_GENERIC_DESKTOP_KEYBOARD = 6, + USB_HIDUT_USAGE_GENERIC_DESKTOP_KEYPAD = 7 + /* USB_HIDUT_USAGE_GENERIC_DESKTOP_ = , */ + +} usb_hidut_usage_generic_desktop_t; + + +#endif +/** + * @} + */ Index: uspace/lib/usb/include/usb/classes/hidutkbd.h =================================================================== --- uspace/lib/usb/include/usb/classes/hidutkbd.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/lib/usb/include/usb/classes/hidutkbd.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,175 @@ +/* + * 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 libusb usb + * @{ + */ +/** @file + * @brief USB HID key codes. + * @details + * This is not a typical header as by default it is equal to empty file. + * However, by cleverly defining the USB_HIDUT_KBD_KEY you can use it + * to generate conversion tables etc. + * + * For example, this creates enum for known keys: + * @code +#define USB_HIDUT_KBD_KEY(name, usage_id, l, lc, l1, l2) \ + USB_KBD_KEY_##name = usage_id, +typedef enum { + #include +} usb_key_code_t; + @endcode + * + * Maybe, it might be better that you would place such enums into separate + * files and create them as separate step before compiling to allow tools + * such as Doxygen get the definitions right. + * + * @warning This file does not include guard to prevent multiple inclusions + * into a single file. + */ + + +#ifndef USB_HIDUT_KBD_KEY +/** Declare keyboard key. + * @param name Key name (identifier). + * @param usage_id Key code (see Keyboard/Keypad Page (0x07) in HUT1.12. + * @param letter Corresponding character (0 if not applicable). + * @param letter_caps Corresponding character with Caps on. + * @param letter_mod1 Corresponding character with modifier #1 on. + * @param letter_mod2 Corresponding character with modifier #2 on. + */ +#define USB_HIDUT_KBD_KEY(name, usage_id, letter, letter_caps, letter_mod1, letter_mod2) + +#endif + +#define __NONPRINT(name, usage_id) \ + USB_HIDUT_KBD_KEY(name, usage_id, 0, 0, 0, 0) + +/* US alphabet letters */ +USB_HIDUT_KBD_KEY(A, 0x04, 'a', 'A', 0, 0) +USB_HIDUT_KBD_KEY(B, 0x05, 'b', 'B', 0, 0) +USB_HIDUT_KBD_KEY(C, 0x06, 'c', 'C', 0, 0) +USB_HIDUT_KBD_KEY(D, 0x07, 'd', 'D', 0, 0) +USB_HIDUT_KBD_KEY(E, 0x08, 'e', 'E', 0, 0) +USB_HIDUT_KBD_KEY(F, 0x09, 'f', 'F', 0, 0) +USB_HIDUT_KBD_KEY(G, 0x0A, 'g', 'G', 0, 0) +USB_HIDUT_KBD_KEY(H, 0x0B, 'h', 'H', 0, 0) +USB_HIDUT_KBD_KEY(I, 0x0C, 'i', 'I', 0, 0) +USB_HIDUT_KBD_KEY(J, 0x0D, 'j', 'J', 0, 0) +USB_HIDUT_KBD_KEY(K, 0x0E, 'k', 'K', 0, 0) +USB_HIDUT_KBD_KEY(L, 0x0F, 'l', 'L', 0, 0) +USB_HIDUT_KBD_KEY(M, 0x10, 'm', 'M', 0, 0) +USB_HIDUT_KBD_KEY(N, 0x11, 'n', 'N', 0, 0) +USB_HIDUT_KBD_KEY(O, 0x12, 'o', 'O', 0, 0) +USB_HIDUT_KBD_KEY(P, 0x13, 'p', 'P', 0, 0) +USB_HIDUT_KBD_KEY(Q, 0x14, 'q', 'Q', 0, 0) +USB_HIDUT_KBD_KEY(R, 0x15, 'r', 'R', 0, 0) +USB_HIDUT_KBD_KEY(S, 0x16, 's', 'S', 0, 0) +USB_HIDUT_KBD_KEY(T, 0x17, 't', 'T', 0, 0) +USB_HIDUT_KBD_KEY(U, 0x18, 'u', 'U', 0, 0) +USB_HIDUT_KBD_KEY(V, 0x19, 'v', 'V', 0, 0) +USB_HIDUT_KBD_KEY(W, 0x1A, 'w', 'W', 0, 0) +USB_HIDUT_KBD_KEY(X, 0x1B, 'x', 'X', 0, 0) +USB_HIDUT_KBD_KEY(Y, 0x1C, 'y', 'Y', 0, 0) +USB_HIDUT_KBD_KEY(Z, 0x1D, 'z', 'Z', 0, 0) + +/* Keyboard digits */ +USB_HIDUT_KBD_KEY(1, 0x1E, '1', '!', 0, 0) +USB_HIDUT_KBD_KEY(2, 0x1F, '2', '@', 0, 0) +USB_HIDUT_KBD_KEY(3, 0x20, '3', '#', 0, 0) +USB_HIDUT_KBD_KEY(4, 0x21, '4', '$', 0, 0) +USB_HIDUT_KBD_KEY(5, 0x22, '5', '%', 0, 0) +USB_HIDUT_KBD_KEY(6, 0x23, '6', '^', 0, 0) +USB_HIDUT_KBD_KEY(7, 0x24, '7', '&', 0, 0) +USB_HIDUT_KBD_KEY(8, 0x25, '8', '*', 0, 0) +USB_HIDUT_KBD_KEY(9, 0x26, '9', '(', 0, 0) +USB_HIDUT_KBD_KEY(0, 0x27, '0', ')', 0, 0) + +/* More-or-less typewriter command keys */ +USB_HIDUT_KBD_KEY(ENTER, 0x28, '\n', 0, 0, 0) +USB_HIDUT_KBD_KEY(ESCAPE, 0x29, 0, 0, 0, 0) +USB_HIDUT_KBD_KEY(BACKSPACE, 0x2A, '\b', 0, 0, 0) +USB_HIDUT_KBD_KEY(TAB, 0x2B, '\t', 0, 0, 0) +USB_HIDUT_KBD_KEY(SPACE, 0x2C, ' ', 0, 0, 0) + +/* Special (printable) characters */ +USB_HIDUT_KBD_KEY(DASH, 0x2D, '-', '_', 0, 0) +USB_HIDUT_KBD_KEY(EQUALS, 0x2E, '=', '+', 0, 0) +USB_HIDUT_KBD_KEY(LEFT_BRACKET, 0x2F, '[', '{', 0, 0) +USB_HIDUT_KBD_KEY(RIGHT_BRACKET, 0x30, ']', '}', 0, 0) +USB_HIDUT_KBD_KEY(BACKSLASH, 0x31, '\\', '|', 0, 0) +USB_HIDUT_KBD_KEY(HASH, 0x32, '#', '~', 0, 0) +USB_HIDUT_KBD_KEY(SEMICOLON, 0x33, ';', ':', 0, 0) +USB_HIDUT_KBD_KEY(APOSTROPHE, 0x34, '\'', '"', 0, 0) +USB_HIDUT_KBD_KEY(GRAVE_ACCENT, 0x35, '`', '~', 0, 0) +USB_HIDUT_KBD_KEY(COMMA, 0x36, ',', '<', 0, 0) +USB_HIDUT_KBD_KEY(PERIOD, 0x37, '.', '>', 0, 0) +USB_HIDUT_KBD_KEY(SLASH, 0x38, '/', '?', 0, 0) + +USB_HIDUT_KBD_KEY(CAPS_LOCK, 0x39, 0, 0, 0, 0) + +/* Function keys */ +__NONPRINT( F1, 0x3A) +__NONPRINT( F2, 0x3B) +__NONPRINT( F3, 0x3C) +__NONPRINT( F4, 0x3D) +__NONPRINT( F5, 0x3E) +__NONPRINT( F6, 0x3F) +__NONPRINT( F7, 0x40) +__NONPRINT( F8, 0x41) +__NONPRINT( F9, 0x42) +__NONPRINT(F10, 0x43) +__NONPRINT(F11, 0x44) +__NONPRINT(F12, 0x45) + +/* Cursor movement keys & co. */ +__NONPRINT(PRINT_SCREEN, 0x46) +__NONPRINT(SCROLL_LOCK, 0x47) +__NONPRINT(PAUSE, 0x48) +__NONPRINT(INSERT, 0x49) +__NONPRINT(HOME, 0x4A) +__NONPRINT(PAGE_UP, 0x4B) +__NONPRINT(DELETE, 0x4C) +__NONPRINT(END, 0x4D) +__NONPRINT(PAGE_DOWN, 0x4E) +__NONPRINT(RIGHT_ARROW, 0x4F) +__NONPRINT(LEFT_ARROW, 0x50) +__NONPRINT(DOWN_ARROW, 0x51) +__NONPRINT(UP_ARROW, 0x52) + + + + +/* USB_HIDUT_KBD_KEY(, 0x, '', '', 0, 0) */ + +#undef __NONPRINT + +/** + * @} + */ + Index: uspace/lib/usb/include/usb/classes/hub.h =================================================================== --- uspace/lib/usb/include/usb/classes/hub.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/lib/usb/include/usb/classes/hub.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,224 @@ +/* + * 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 libusb usb + * @{ + */ +/** @file + * @brief USB hub related structures. + */ +#ifndef LIBUSB_HUB_H_ +#define LIBUSB_HUB_H_ + +#include +#include + + +/** Hub class feature selector. + * @warning The constants are not unique (feature selectors are used + * for hub and port). + */ +typedef enum { + USB_HUB_FEATURE_C_HUB_LOCAL_POWER = 0, + USB_HUB_FEATURE_C_HUB_OVER_CURRENT = 1, + USB_HUB_FEATURE_PORT_CONNECTION = 0, + USB_HUB_FEATURE_PORT_ENABLE = 1, + USB_HUB_FEATURE_PORT_SUSPEND = 2, + USB_HUB_FEATURE_PORT_OVER_CURRENT = 3, + USB_HUB_FEATURE_PORT_RESET = 4, + USB_HUB_FEATURE_PORT_POWER = 8, + USB_HUB_FEATURE_PORT_LOW_SPEED = 9, + USB_HUB_FEATURE_C_PORT_CONNECTION = 16, + USB_HUB_FEATURE_C_PORT_ENABLE = 17, + USB_HUB_FEATURE_C_PORT_SUSPEND = 18, + USB_HUB_FEATURE_C_PORT_OVER_CURRENT = 19, + USB_HUB_FEATURE_C_PORT_RESET = 20, + /* USB_HUB_FEATURE_ = , */ +} usb_hub_class_feature_t; + + +/** + * @brief usb hub descriptor + * + * For more information see Universal Serial Bus Specification Revision 1.1 chapter 11.16.2 + */ +typedef struct hub_descriptor_type{ + /** Number of bytes in this descriptor, including this byte */ + //uint8_t bDescLength; + + /** Descriptor Type, value: 29H for hub descriptor */ + //uint8_t bDescriptorType; + + /** Number of downstream ports that this hub supports */ + uint8_t ports_count; + + /** + D1...D0: Logical Power Switching Mode + 00: Ganged power switching (all ports’ power at + once) + 01: Individual port power switching + 1X: Reserved. Used only on 1.0 compliant hubs + that implement no power switching. + D2: Identifies a Compound Device + 0: Hub is not part of a compound device + 1: Hub is part of a compound device + D4...D3: Over-current Protection Mode + 00: Global Over-current Protection. The hub + reports over-current as a summation of all + ports’ current draw, without a breakdown of + individual port over-current status. + 01: Individual Port Over-current Protection. The + hub reports over-current on a per-port basis. + Each port has an over-current indicator. + 1X: No Over-current Protection. This option is + allowed only for bus-powered hubs that do not + implement over-current protection. + D15...D5: + Reserved + */ + uint16_t hub_characteristics; + + /** + Time (in 2ms intervals) from the time the power-on + sequence begins on a port until power is good on that + port. The USB System Software uses this value to + determine how long to wait before accessing a + powered-on port. + */ + uint8_t pwr_on_2_good_time; + + /** + Maximum current requirements of the Hub Controller + electronics in mA. + */ + uint8_t current_requirement; + + /** + Indicates if a port has a removable device attached. + This field is reported on byte-granularity. Within a + byte, if no port exists for a given location, the field + representing the port characteristics returns 0. + Bit value definition: + 0B - Device is removable + 1B - Device is non-removable + This is a bitmap corresponding to the individual ports + on the hub: + Bit 0: Reserved for future use + Bit 1: Port 1 + Bit 2: Port 2 + .... + Bit n: Port n (implementation-dependent, up to a + maximum of 255 ports). + */ + uint8_t * devices_removable; + + /** + This field exists for reasons of compatibility with + software written for 1.0 compliant devices. All bits in + this field should be set to 1B. This field has one bit for + each port on the hub with additional pad bits, if + necessary, to make the number of bits in the field an + integer multiple of 8. + */ + //uint8_t * port_pwr_ctrl_mask; +} usb_hub_descriptor_t; + + + +/** @brief usb hub specific request types. + * + * For more information see Universal Serial Bus Specification Revision 1.1 chapter 11.16.2 + */ +typedef enum { + /** This request resets a value reported in the hub status. */ + USB_HUB_REQ_TYPE_CLEAR_HUB_FEATURE = 0x20, + /** This request resets a value reported in the port status. */ + USB_HUB_REQ_TYPE_CLEAR_PORT_FEATURE = 0x23, + /** This is an optional per-port diagnostic request that returns the bus state value, as sampled at the last EOF2 point. */ + USB_HUB_REQ_TYPE_GET_STATE = 0xA3, + /** This request returns the hub descriptor. */ + USB_HUB_REQ_TYPE_GET_DESCRIPTOR = 0xA0, + /** This request returns the current hub status and the states that have changed since the previous acknowledgment. */ + USB_HUB_REQ_TYPE_GET_HUB_STATUS = 0xA0, + /** This request returns the current port status and the current value of the port status change bits. */ + USB_HUB_REQ_TYPE_GET_PORT_STATUS = 0xA3, + /** This request overwrites the hub descriptor. */ + USB_HUB_REQ_TYPE_SET_DESCRIPTOR = 0x20, + /** This request sets a value reported in the hub status. */ + USB_HUB_REQ_TYPE_SET_HUB_FEATURE = 0x20, + /** This request sets a value reported in the port status. */ + USB_HUB_REQ_TYPE_SET_PORT_FEATURE = 0x23 +} usb_hub_bm_request_type_t; + +/** @brief hub class request codes*/ +/// \TODO these are duplicit to standart descriptors +typedef enum { + /** */ + USB_HUB_REQUEST_GET_STATUS = 0, + /** */ + USB_HUB_REQUEST_CLEAR_FEATURE = 1, + /** */ + USB_HUB_REQUEST_GET_STATE = 2, + /** */ + USB_HUB_REQUEST_SET_FEATURE = 3, + /** */ + USB_HUB_REQUEST_GET_DESCRIPTOR = 6, + /** */ + USB_HUB_REQUEST_SET_DESCRIPTOR = 7 +} usb_hub_request_t; + +/** + * Maximum size of usb hub descriptor in bytes + */ +extern size_t USB_HUB_MAX_DESCRIPTOR_SIZE; + +/** + * @brief create uint8_t array with serialized descriptor + * + * @param descriptor + */ +void * usb_serialize_hub_descriptor(usb_hub_descriptor_t * descriptor); + +/** + * @brief create deserialized desriptor structure out of serialized descriptor + * + * The serialized descriptor must be proper usb hub descriptor, otherwise an eerror might occur. + * + * @param sdescriptor serialized descriptor + */ +usb_hub_descriptor_t * usb_deserialize_hub_desriptor(void * sdescriptor); + + + + + + +#endif +/** + * @} + */ Index: uspace/lib/usb/include/usb/debug.h =================================================================== --- uspace/lib/usb/include/usb/debug.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/lib/usb/include/usb/debug.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -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. + */ + +/** @addtogroup libusb usb + * @{ + */ +/** @file + * @brief Debugging related functions. + */ +#ifndef LIBUSB_DEBUG_H_ +#define LIBUSB_DEBUG_H_ + +void usb_dprintf(const char *tag, int level, const char *format, ...); +void usb_dprintf_enable(const char *tag, int level); + + +#endif Index: uspace/lib/usb/include/usb/descriptor.h =================================================================== --- uspace/lib/usb/include/usb/descriptor.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/lib/usb/include/usb/descriptor.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,176 @@ +/* + * 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 libusb usb + * @{ + */ +/** @file + * @brief Standard USB descriptors. + */ +#ifndef LIBUSB_DESCRIPTOR_H_ +#define LIBUSB_DESCRIPTOR_H_ + +#include +#include + +/** Descriptor type. */ +typedef enum { + USB_DESCTYPE_DEVICE = 1, + USB_DESCTYPE_CONFIGURATION = 2, + USB_DESCTYPE_STRING = 3, + USB_DESCTYPE_INTERFACE = 4, + USB_DESCTYPE_ENDPOINT = 5, + USB_DESCTYPE_HID = 0x21, + USB_DESCTYPE_HID_REPORT = 0x22, + USB_DESCTYPE_HID_PHYSICAL = 0x23, + USB_DESCTYPE_HUB = 0x29, + /* USB_DESCTYPE_ = */ +} usb_descriptor_type_t; + +/** Standard USB device descriptor. + */ +typedef struct { + /** Size of this descriptor in bytes. */ + uint8_t length; + /** Descriptor type (USB_DESCTYPE_DEVICE). */ + uint8_t descriptor_type; + /** USB specification release number. + * The number shall be coded as binary-coded decimal (BCD). + */ + uint16_t usb_spec_version; + /** Device class. */ + uint8_t device_class; + /** Device sub-class. */ + uint8_t device_subclass; + /** Device protocol. */ + uint8_t device_protocol; + /** Maximum packet size for endpoint zero. + * Valid values are only 8, 16, 32, 64). + */ + uint8_t max_packet_size; + /** Vendor ID. */ + uint16_t vendor_id; + /** Product ID. */ + uint16_t product_id; + /** Device release number (in BCD). */ + uint16_t device_version; + /** Manufacturer descriptor index. */ + uint8_t str_manufacturer; + /** Product descriptor index. */ + uint8_t str_product; + /** Device serial number desriptor index. */ + uint8_t str_serial_number; + /** Number of possible configurations. */ + uint8_t configuration_count; +} __attribute__ ((packed)) usb_standard_device_descriptor_t; + +/** Standard USB configuration descriptor. + */ +typedef struct { + /** Size of this descriptor in bytes. */ + uint8_t length; + /** Descriptor type (USB_DESCTYPE_CONFIGURATION). */ + uint8_t descriptor_type; + /** Total length of all data of this configuration. + * This includes the combined length of all descriptors + * (configuration, interface, endpoint, class-specific and + * vendor-specific) valid for this configuration. + */ + uint16_t total_length; + /** Number of possible interfaces under this configuration. */ + uint8_t interface_count; + /** Configuration value used when setting this configuration. */ + uint8_t configuration_number; + /** String descriptor describing this configuration. */ + uint8_t str_configuration; + /** Attribute bitmap. */ + uint8_t attributes; + /** Maximum power consumption from the USB under this configuration. + * Expressed in 2mA unit (e.g. 50 ~ 100mA). + */ + uint8_t max_power; +} __attribute__ ((packed)) usb_standard_configuration_descriptor_t; + +/** Standard USB interface descriptor. + */ +typedef struct { + /** Size of this descriptor in bytes. */ + uint8_t length; + /** Descriptor type (USB_DESCTYPE_INTERFACE). */ + uint8_t descriptor_type; + /** Number of interface. + * Zero-based index into array of interfaces for current configuration. + */ + uint8_t interface_number; + /** Alternate setting for value in interface_number. */ + uint8_t alternate_setting; + /** Number of endpoints used by this interface. + * This number must exclude usage of endpoint zero + * (default control pipe). + */ + uint8_t endpoint_count; + /** Class code. */ + uint8_t interface_class; + /** Subclass code. */ + uint8_t interface_subclass; + /** Protocol code. */ + uint8_t interface_protocol; + /** String descriptor describing this interface. */ + uint8_t str_interface; +} __attribute__ ((packed)) usb_standard_interface_descriptor_t; + +/** Standard USB endpoint descriptor. + */ +typedef struct { + /** Size of this descriptor in bytes. */ + uint8_t length; + /** Descriptor type (USB_DESCTYPE_ENDPOINT). */ + uint8_t descriptor_type; + /** Endpoint address together with data flow direction. */ + uint8_t endpoint_address; + /** Endpoint attributes. + * Includes transfer type (usb_transfer_type_t). + */ + uint8_t attributes; + /** Maximum packet size. */ + uint16_t max_packet_size; + /** Polling interval in milliseconds. + * Ignored for bulk and control endpoints. + * Isochronous endpoints must use value 1. + * Interrupt endpoints any value from 1 to 255. + */ + uint8_t poll_interval; +} __attribute__ ((packed)) usb_standard_endpoint_descriptor_t; + + +/* TODO: string descriptors. */ + +#endif +/** + * @} + */ Index: uspace/lib/usb/include/usb/devreq.h =================================================================== --- uspace/lib/usb/include/usb/devreq.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/lib/usb/include/usb/devreq.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,99 @@ +/* + * 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 libusb usb + * @{ + */ +/** @file + * @brief Standard USB device requests. + */ +#ifndef LIBUSB_DEVREQ_H_ +#define LIBUSB_DEVREQ_H_ + +#include +#include +#include +#include + +/** Standard device request. */ +typedef enum { + USB_DEVREQ_GET_STATUS = 0, + USB_DEVREQ_CLEAR_FEATURE = 1, + USB_DEVREQ_SET_FEATURE = 3, + USB_DEVREQ_SET_ADDRESS = 5, + USB_DEVREQ_GET_DESCRIPTOR = 6, + USB_DEVREQ_SET_DESCRIPTOR = 7, + USB_DEVREQ_GET_CONFIGURATION = 8, + USB_DEVREQ_SET_CONFIGURATION = 9, + USB_DEVREQ_GET_INTERFACE = 10, + USB_DEVREQ_SET_INTERFACE = 11, + USB_DEVREQ_SYNCH_FRAME = 12, + USB_DEVREQ_LAST_STD +} usb_stddevreq_t; + +/** Device request setup packet. + * The setup packet describes the request. + */ +typedef struct { + /** Request type. + * The type combines transfer direction, request type and + * intended recipient. + */ + uint8_t request_type; + /** Request identification. */ + uint8_t request; + /** Main parameter to the request. */ + union { + /* FIXME: add #ifdefs according to host endianess */ + struct { + uint8_t value_low; + uint8_t value_high; + }; + uint16_t value; + }; + /** Auxiliary parameter to the request. + * Typically, it is offset to something. + */ + uint16_t index; + /** Length of extra data. */ + uint16_t length; +} __attribute__ ((packed)) usb_device_request_setup_packet_t; + +int usb_drv_req_set_address(int, usb_address_t, usb_address_t); +int usb_drv_req_get_device_descriptor(int, usb_address_t, + usb_standard_device_descriptor_t *); +int usb_drv_req_get_bare_configuration_descriptor(int, usb_address_t, int, + usb_standard_configuration_descriptor_t *); +int usb_drv_req_get_full_configuration_descriptor(int, usb_address_t, int, + void *, size_t, size_t *); + + +#endif +/** + * @} + */ Index: uspace/lib/usb/include/usb/hcd.h =================================================================== --- uspace/lib/usb/include/usb/hcd.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/lib/usb/include/usb/hcd.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,84 @@ +/* + * 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 libusb usb + * @{ + */ +/** @file + * @brief HC driver. + */ +#ifndef LIBUSB_HCD_H_ +#define LIBUSB_HCD_H_ + +#include +#include +#include + +/** Info about used address. */ +typedef struct { + /** Linked list member. */ + link_t link; + /** Address. */ + usb_address_t address; + /** Corresponding devman handle. */ + devman_handle_t devman_handle; +} usb_address_keeping_used_t; + +/** Structure for keeping track of free and used USB addresses. */ +typedef struct { + /** Head of list of used addresses. */ + link_t used_addresses; + /** Upper bound for USB addresses. */ + usb_address_t max_address; + /** Mutex protecting used address. */ + fibril_mutex_t used_addresses_guard; + /** Condition variable for used addresses. */ + fibril_condvar_t used_addresses_condvar; + + /** Condition variable mutex for default address. */ + fibril_mutex_t default_condvar_guard; + /** Condition variable for default address. */ + fibril_condvar_t default_condvar; + /** Whether is default address available. */ + bool default_available; +} usb_address_keeping_t; + +void usb_address_keeping_init(usb_address_keeping_t *, usb_address_t); + +void usb_address_keeping_reserve_default(usb_address_keeping_t *); +void usb_address_keeping_release_default(usb_address_keeping_t *); + +usb_address_t usb_address_keeping_request(usb_address_keeping_t *); +int usb_address_keeping_release(usb_address_keeping_t *, usb_address_t); +void usb_address_keeping_devman_bind(usb_address_keeping_t *, usb_address_t, + devman_handle_t); +usb_address_t usb_address_keeping_find(usb_address_keeping_t *, + devman_handle_t); + + +#endif Index: uspace/lib/usb/include/usb/hcdhubd.h =================================================================== --- uspace/lib/usb/include/usb/hcdhubd.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/lib/usb/include/usb/hcdhubd.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,214 @@ +/* + * 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 libusb usb + * @{ + */ +/** @file + * @brief HC driver and hub driver. + */ +#ifndef LIBUSB_HCDHUBD_H_ +#define LIBUSB_HCDHUBD_H_ + +#include +#include +#include +#include + +/** Endpoint properties. */ +typedef struct { + /** Endpoint number. */ + usb_endpoint_t endpoint; + /** Transfer type. */ + usb_transfer_type_t transfer_type; + /** Endpoint direction. */ + usb_direction_t direction; + /** Data toggle bit. */ + int data_toggle; +} usb_hc_endpoint_info_t; + +/** Information about attached USB device. */ +typedef struct { + /** Assigned address. */ + usb_address_t address; + /** Number of endpoints. */ + size_t endpoint_count; + /** Endpoint properties. */ + usb_hc_endpoint_info_t *endpoints; + /** Link to other attached devices of the same HC. */ + link_t link; +} usb_hcd_attached_device_info_t; + + +/** Host controller device. */ +typedef struct usb_hc_device usb_hc_device_t; + +/** Callback for OUT transfers. */ +typedef void (*usb_hcd_transfer_callback_out_t) + (usb_hc_device_t *, usb_transaction_outcome_t, void *); + +/** Callback for IN transfers. */ +typedef void (*usb_hcd_transfer_callback_in_t) + (usb_hc_device_t *, size_t, usb_transaction_outcome_t, void *); + + +/** Transfer functions provided by each USB host controller driver. */ +typedef struct { + /** OUT transfer. + * @param hc Host controller that shall enqueue the transfer. + * @param dev Target device. + * @param ep Target endpoint. + * @param buffer Buffer to be sent. + * @param size Buffer size. + * @param callback Callback after transfer was processed by hardware. + * @param arg Callback argument. + */ + int (*transfer_out)(usb_hc_device_t *hc, + usb_hcd_attached_device_info_t *dev, usb_hc_endpoint_info_t *ep, + void *buffer, size_t size, + usb_hcd_transfer_callback_out_t callback, void *arg); + + /** SETUP transfer. */ + int (*transfer_setup)(usb_hc_device_t *, + usb_hcd_attached_device_info_t *, usb_hc_endpoint_info_t *, + void *, size_t, + usb_hcd_transfer_callback_out_t, void *); + + /** IN transfer. */ + int (*transfer_in)(usb_hc_device_t *, + usb_hcd_attached_device_info_t *, usb_hc_endpoint_info_t *, + void *, size_t, + usb_hcd_transfer_callback_in_t, void *); +} usb_hcd_transfer_ops_t; + +/** + * @brief structure holding information about free and used addresses + * + * This structure should not be used outside usb hcd driver. + * You better consider it to be 'private'. + */ +typedef struct { + /** lower bound included in the interval */ + usb_address_t lower_bound; + + /** upper bound, excluded from the interval */ + usb_address_t upper_bound; + + /** */ + link_t link; +}usb_address_list_t; + +struct usb_hc_device { + /** Transfer operations. */ + usb_hcd_transfer_ops_t *transfer_ops; + + /** Custom HC data. */ + void *data; + + /** Generic device entry (read-only). */ + device_t *generic; + + /** List of attached devices. */ + link_t attached_devices; + + /** List of hubs operating from this HC. */ + link_t hubs; + + /** Structure with free and used addresses */ + link_t addresses; + + /** Link to other driven HCs. */ + link_t link; +}; + +/** Host controller driver. */ +typedef struct { + /** Driver name. */ + const char *name; + /** Callback when device (host controller) is added. */ + int (*add_hc)(usb_hc_device_t *device); +} usb_hc_driver_t; + + +int usb_hcd_main(usb_hc_driver_t *); +int usb_hcd_add_root_hub(device_t *dev); + +/** + * find first not yet used address on this host controller and use it + * @param this_hcd + * @return number in the range of allowed usb addresses or + * a negative number if not succesful + */ +usb_address_t usb_use_free_address(usb_hc_device_t * this_hcd); + +/** + * @brief free the address in the address space of this hcd. + * + * if address is not used, nothing happens + * @param this_hcd + * @param addr + */ +void usb_free_used_address(usb_hc_device_t * this_hcd, usb_address_t addr ); + + +/* + * Functions to be used by drivers within same task as the HC driver. + * This will probably include only hub drivers. + */ + +device_t *usb_hc_connect(device_t *); + +int usb_hc_async_interrupt_out(usb_hc_device_t *, usb_target_t, + void *, size_t, usb_handle_t *); +int usb_hc_async_interrupt_in(usb_hc_device_t *, usb_target_t, + void *, size_t, size_t *, usb_handle_t *); + +int usb_hc_async_control_write_setup(usb_hc_device_t *, usb_target_t, + void *, size_t, usb_handle_t *); +int usb_hc_async_control_write_data(usb_hc_device_t *, usb_target_t, + void *, size_t, usb_handle_t *); +int usb_hc_async_control_write_status(usb_hc_device_t *, usb_target_t, + usb_handle_t *); + +int usb_hc_async_control_read_setup(usb_hc_device_t *, usb_target_t, + void *, size_t, usb_handle_t *); +int usb_hc_async_control_read_data(usb_hc_device_t *, usb_target_t, + void *, size_t, size_t *, usb_handle_t *); +int usb_hc_async_control_read_status(usb_hc_device_t *, usb_target_t, + usb_handle_t *); + +int usb_hc_async_wait_for(usb_handle_t); + +int usb_hc_add_child_device(device_t *, const char *, const char *, bool); + + +/** + * @} + */ + +#endif Index: uspace/lib/usb/include/usb/usb.h =================================================================== --- uspace/lib/usb/include/usb/usb.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/lib/usb/include/usb/usb.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,135 @@ +/* + * 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 libusb usb + * @{ + */ +/** @file + * @brief Base USB types. + */ +#ifndef LIBUSB_USB_H_ +#define LIBUSB_USB_H_ + +#include +#include + +/** USB transfer type. */ +typedef enum { + USB_TRANSFER_CONTROL = 0, + USB_TRANSFER_ISOCHRONOUS = 1, + USB_TRANSFER_BULK = 2, + USB_TRANSFER_INTERRUPT = 3 +} usb_transfer_type_t; + +const char * usb_str_transfer_type(usb_transfer_type_t t); + +/** USB data transfer direction. */ +typedef enum { + USB_DIRECTION_IN, + USB_DIRECTION_OUT +} usb_direction_t; + +/** USB transaction outcome. */ +typedef enum { + USB_OUTCOME_OK, + USB_OUTCOME_CRCERROR, + USB_OUTCOME_BABBLE +} usb_transaction_outcome_t; + +const char * usb_str_transaction_outcome(usb_transaction_outcome_t o); + +/** USB address type. + * Negative values could be used to indicate error. + */ +typedef int usb_address_t; + +/** Default USB address. */ +#define USB_ADDRESS_DEFAULT 0 +/** Maximum address number in USB 1.1. */ +#define USB11_ADDRESS_MAX 128 + +/** USB endpoint number type. + * Negative values could be used to indicate error. + */ +typedef int usb_endpoint_t; + +/** Maximum endpoint number in USB 1.1. + */ +#define USB11_ENDPOINT_MAX 16 + + +/** USB complete address type. + * Pair address + endpoint is identification of transaction recipient. + */ +typedef struct { + usb_address_t address; + usb_endpoint_t endpoint; +} usb_target_t; + +static inline int usb_target_same(usb_target_t a, usb_target_t b) +{ + return (a.address == b.address) + && (a.endpoint == b.endpoint); +} + +/** General handle type. + * Used by various USB functions as opaque handle. + */ +typedef sysarg_t usb_handle_t; + +/** USB packet identifier. */ +typedef enum { +#define _MAKE_PID_NIBBLE(tag, type) \ + ((uint8_t)(((tag) << 2) | (type))) +#define _MAKE_PID(tag, type) \ + ( \ + _MAKE_PID_NIBBLE(tag, type) \ + | ((~_MAKE_PID_NIBBLE(tag, type)) << 4) \ + ) + USB_PID_OUT = _MAKE_PID(0, 1), + USB_PID_IN = _MAKE_PID(2, 1), + USB_PID_SOF = _MAKE_PID(1, 1), + USB_PID_SETUP = _MAKE_PID(3, 1), + + USB_PID_DATA0 = _MAKE_PID(0 ,3), + USB_PID_DATA1 = _MAKE_PID(2 ,3), + + USB_PID_ACK = _MAKE_PID(0 ,2), + USB_PID_NAK = _MAKE_PID(2 ,2), + USB_PID_STALL = _MAKE_PID(3 ,2), + + USB_PID_PRE = _MAKE_PID(3 ,0), + /* USB_PID_ = _MAKE_PID( ,), */ +#undef _MAKE_PID +#undef _MAKE_PID_NIBBLE +} usb_packet_id; + +#endif +/** + * @} + */ Index: uspace/lib/usb/include/usb/usbdrv.h =================================================================== --- uspace/lib/usb/include/usb/usbdrv.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/lib/usb/include/usb/usbdrv.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,104 @@ +/* + * 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 libusb usb + * @{ + */ +/** @file + * @brief USB driver. + */ +#ifndef LIBUSB_USBDRV_H_ +#define LIBUSB_USBDRV_H_ + +#include +#include +#include +#include + +int usb_drv_hc_connect(device_t *, unsigned int); + +int usb_drv_reserve_default_address(int); +int usb_drv_release_default_address(int); +usb_address_t usb_drv_request_address(int); +int usb_drv_bind_address(int, usb_address_t, devman_handle_t); +int usb_drv_release_address(int, usb_address_t); + +usb_address_t usb_drv_get_my_address(int, device_t *); + +int usb_drv_async_interrupt_out(int, usb_target_t, + void *, size_t, usb_handle_t *); +int usb_drv_async_interrupt_in(int, usb_target_t, + void *, size_t, size_t *, usb_handle_t *); + +int usb_drv_psync_interrupt_out(int, usb_target_t, void *, size_t); +int usb_drv_psync_interrupt_in(int, usb_target_t, void *, size_t, size_t *); + + + +int usb_drv_async_control_write_setup(int, usb_target_t, + void *, size_t, usb_handle_t *); +int usb_drv_async_control_write_data(int, usb_target_t, + void *, size_t, usb_handle_t *); +int usb_drv_async_control_write_status(int, usb_target_t, + usb_handle_t *); + +int usb_drv_psync_control_write_setup(int, usb_target_t, void *, size_t); +int usb_drv_psync_control_write_data(int, usb_target_t, void *, size_t); +int usb_drv_psync_control_write_status(int, usb_target_t); + +int usb_drv_psync_control_write(int, usb_target_t, + void *, size_t, void *, size_t); + + +int usb_drv_async_control_read_setup(int, usb_target_t, + void *, size_t, usb_handle_t *); +int usb_drv_async_control_read_data(int, usb_target_t, + void *, size_t, size_t *, usb_handle_t *); +int usb_drv_async_control_read_status(int, usb_target_t, + usb_handle_t *); + +int usb_drv_psync_control_read_setup(int, usb_target_t, void *, size_t); +int usb_drv_psync_control_read_data(int, usb_target_t, void *, size_t, size_t *); +int usb_drv_psync_control_read_status(int, usb_target_t); + +int usb_drv_psync_control_read(int, usb_target_t, + void *, size_t, void *, size_t, size_t *); + + + +int usb_drv_async_wait_for(usb_handle_t); + +int usb_drv_create_device_match_ids(int, match_id_list_t *, usb_address_t); +int usb_drv_register_child_in_devman(int, device_t *, usb_address_t, + devman_handle_t *); + + +#endif +/** + * @} + */ Index: uspace/lib/usb/src/addrkeep.c =================================================================== --- uspace/lib/usb/src/addrkeep.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/lib/usb/src/addrkeep.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,341 @@ +/* + * 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 libusb usb + * @{ + */ +/** @file + * @brief Address keeping. + */ +#include +#include +#include + +/** For loop over all used addresses in address keeping. + * + * @param link Iterator. + * @param addresses Addresses keeping structure to iterate. + */ +#define for_all_used_addresses(link, addresses) \ + for (link = (addresses)->used_addresses.next; \ + link != &(addresses)->used_addresses; \ + link = link->next) + +/** Get instance of usb_address_keeping_used_t. */ +#define used_address_get_instance(lnk) \ + list_get_instance(lnk, usb_address_keeping_used_t, link) + +/** Invalid value of devman handle. */ +#define INVALID_DEVMAN_HANDLE \ + ((devman_handle_t)-1) + +/** Creates structure for used USB address. + * + * @param address USB address. + * @return Initialized structure. + * @retval NULL Out of memory. + */ +static usb_address_keeping_used_t *usb_address_keeping_used_create( + usb_address_t address) +{ + usb_address_keeping_used_t *info + = malloc(sizeof(usb_address_keeping_used_t)); + if (info == NULL) { + return NULL; + } + + info->address = address; + info->devman_handle = INVALID_DEVMAN_HANDLE; + list_initialize(&info->link); + return info; +} + +/** Destroys structure for used USB address. + * + * @param info Structure to be destroyed. + */ +static void usb_address_keeping_used_destroy(usb_address_keeping_used_t *info) +{ + free(info); +} + +/** Find used USB address structure by USB address. + * + * It is expected that guard mutex is already locked. + * + * @param addresses Address keeping info. + * @param address Address to be found. + * @return Structure describing looked for address. + * @retval NULL Address not found. + */ +static usb_address_keeping_used_t *usb_address_keeping_used_find_no_lock( + usb_address_keeping_t *addresses, usb_address_t address) +{ + link_t *link; + for_all_used_addresses(link, addresses) { + usb_address_keeping_used_t *info + = used_address_get_instance(link); + + if (info->address == address) { + return info; + } + } + + return NULL; +} + +/** Initialize address keeping structure. + * + * @param addresses Address keeping info. + * @param max_address Maximum USB address (exclusive bound). + */ +void usb_address_keeping_init(usb_address_keeping_t *addresses, + usb_address_t max_address) +{ + /* + * Items related with used addresses. + */ + addresses->max_address = max_address; + list_initialize(&addresses->used_addresses); + fibril_mutex_initialize(&addresses->used_addresses_guard); + fibril_condvar_initialize(&addresses->used_addresses_condvar); + + /* + * Items related with default address. + */ + addresses->default_available = true; + fibril_condvar_initialize(&addresses->default_condvar); + fibril_mutex_initialize(&addresses->default_condvar_guard); +} + +/** Reserved default USB address. + * + * This function blocks until reserved address is available. + * + * @see usb_address_keeping_release_default + * + * @param addresses Address keeping info. + */ +void usb_address_keeping_reserve_default(usb_address_keeping_t *addresses) +{ + fibril_mutex_lock(&addresses->default_condvar_guard); + while (!addresses->default_available) { + fibril_condvar_wait(&addresses->default_condvar, + &addresses->default_condvar_guard); + } + fibril_mutex_unlock(&addresses->default_condvar_guard); +} + +/** Releases default USB address. + * + * @see usb_address_keeping_reserve_default + * + * @param addresses Address keeping info. + */ +void usb_address_keeping_release_default(usb_address_keeping_t *addresses) +{ + fibril_mutex_lock(&addresses->default_condvar_guard); + addresses->default_available = true; + fibril_condvar_signal(&addresses->default_condvar); + fibril_mutex_unlock(&addresses->default_condvar_guard); +} + +/** Request free address assignment. + * + * This function does not block when there are not free addresses to be + * assigned. + * + * @param addresses Address keeping info. + * @return USB address that could be used or negative error code. + * @retval ELIMIT No more addresses to assign. + * @retval ENOMEM Out of memory. + */ +usb_address_t usb_address_keeping_request(usb_address_keeping_t *addresses) +{ + usb_address_t previous_address = 0; + usb_address_t free_address = 0; + + fibril_mutex_lock(&addresses->used_addresses_guard); + link_t *new_address_position; + if (list_empty(&addresses->used_addresses)) { + free_address = 1; + new_address_position = addresses->used_addresses.next; + } else { + for_all_used_addresses(new_address_position, addresses) { + usb_address_keeping_used_t *info + = used_address_get_instance(new_address_position); + if (info->address > previous_address + 1) { + free_address = previous_address + 1; + break; + } + } + + if (free_address == 0) { + usb_address_keeping_used_t *last + = used_address_get_instance(addresses->used_addresses.next); + free_address = last->address + 1; + } + } + + if (free_address >= addresses->max_address) { + free_address = ELIMIT; + goto leave; + } + + usb_address_keeping_used_t *used + = usb_address_keeping_used_create(free_address); + if (used == NULL) { + free_address = ENOMEM; + goto leave; + } + + list_prepend(&used->link, new_address_position); + +leave: + fibril_mutex_unlock(&addresses->used_addresses_guard); + + return free_address; +} + +/** Release USB address. + * + * @param addresses Address keeping info. + * @param address Address to be released. + * @return Error code. + * @retval ENOENT Address is not in use. + */ +int usb_address_keeping_release(usb_address_keeping_t *addresses, + usb_address_t address) +{ + int rc = ENOENT; + + fibril_mutex_lock(&addresses->used_addresses_guard); + + usb_address_keeping_used_t *info + = usb_address_keeping_used_find_no_lock(addresses, address); + + if (info != NULL) { + rc = EOK; + list_remove(&info->link); + usb_address_keeping_used_destroy(info); + } + + fibril_mutex_unlock(&addresses->used_addresses_guard); + + return rc; +} + +/** Bind devman handle with USB address. + * + * When the @p address is invalid (e.g. no such entry), the request + * is silently ignored. + * + * @param addresses Address keeping info. + * @param address USB address. + * @param handle Devman handle. + */ +void usb_address_keeping_devman_bind(usb_address_keeping_t *addresses, + usb_address_t address, devman_handle_t handle) +{ + fibril_mutex_lock(&addresses->used_addresses_guard); + + usb_address_keeping_used_t *info + = usb_address_keeping_used_find_no_lock(addresses, address); + if (info == NULL) { + goto leave; + } + + assert(info->address == address); + info->devman_handle = handle; + + /* + * Inform that new handle was added. + */ + fibril_condvar_broadcast(&addresses->used_addresses_condvar); + +leave: + fibril_mutex_unlock(&addresses->used_addresses_guard); +} + +/** Find address by its devman handle. + * + * @param addresses Address keeping info. + * @param handle Devman handle. + * @return USB address or negative error code. + * @retval ENOENT No such address. + */ +static usb_address_t usb_address_keeping_find_no_lock( + usb_address_keeping_t *addresses, devman_handle_t handle) +{ + usb_address_t address = ENOENT; + + link_t *link; + for_all_used_addresses(link, addresses) { + usb_address_keeping_used_t *info + = used_address_get_instance(link); + + if (info->devman_handle == handle) { + address = info->address; + break; + } + } + + return address; +} + +/** Find USB address by its devman handle. + * + * This function blocks until corresponding address is found. + * + * @param addresses Address keeping info. + * @param handle Devman handle. + * @return USB address or negative error code. + */ +usb_address_t usb_address_keeping_find(usb_address_keeping_t *addresses, + devman_handle_t handle) +{ + usb_address_t address = ENOENT; + + fibril_mutex_lock(&addresses->used_addresses_guard); + while (true) { + address = usb_address_keeping_find_no_lock(addresses, handle); + if (address != ENOENT) { + break; + } + fibril_condvar_wait(&addresses->used_addresses_condvar, + &addresses->used_addresses_guard); + } + + fibril_mutex_unlock(&addresses->used_addresses_guard); + + return address; +} + +/** + * @} + */ Index: uspace/lib/usb/src/class.c =================================================================== --- uspace/lib/usb/src/class.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/lib/usb/src/class.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -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 libusb usb + * @{ + */ +/** @file + * @brief Class related functions. + */ +#include +#include + +/** Tell string representation of USB class. + * + * @param cls Class code. + * @return String representation. + */ +const char *usb_str_class(usb_class_t cls) +{ + switch (cls) { + case USB_CLASS_USE_INTERFACE: + return "use-interface"; + case USB_CLASS_AUDIO: + return "audio"; + case USB_CLASS_COMMUNICATIONS_CDC_CONTROL: + return "communications"; + case USB_CLASS_HID: + return "HID"; + case USB_CLASS_PHYSICAL: + return "physical"; + case USB_CLASS_IMAGE: + return "image"; + case USB_CLASS_PRINTER: + return "printer"; + case USB_CLASS_MASS_STORAGE: + return "mass-storage"; + case USB_CLASS_HUB: + return "hub"; + case USB_CLASS_CDC_DATA: + return "CDC"; + case USB_CLASS_SMART_CARD: + return "smart-card"; + case USB_CLASS_CONTENT_SECURITY: + return "security"; + case USB_CLASS_VIDEO: + return "video"; + case USB_CLASS_PERSONAL_HEALTHCARE: + return "healthcare"; + case USB_CLASS_DIAGNOSTIC: + return "diagnostic"; + case USB_CLASS_WIRELESS_CONTROLLER: + return "wireless"; + case USB_CLASS_MISCELLANEOUS: + return "misc"; + case USB_CLASS_APPLICATION_SPECIFIC: + return "application"; + case USB_CLASS_VENDOR_SPECIFIC: + return "vendor"; + default: + return "unknown"; + } +} + + +/** + * @} + */ Index: uspace/lib/usb/src/debug.c =================================================================== --- uspace/lib/usb/src/debug.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/lib/usb/src/debug.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,160 @@ +/* + * 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 libusb usb + * @{ + */ +/** @file + * @brief Debugging support. + */ +#include +#include +#include +#include +#include +#include + +/** Debugging tag. */ +typedef struct { + /** Linked list member. */ + link_t link; + /** Tag name. + * We always have a private copy of the name. + */ + char *tag; + /** Enabled level of debugging. */ + int level; +} usb_debug_tag_t; + +/** Get instance of usb_debug_tag_t from link_t. */ +#define USB_DEBUG_TAG_INSTANCE(iterator) \ + list_get_instance(iterator, usb_debug_tag_t, link) + +/** List of all known tags. */ +static LIST_INITIALIZE(tag_list); +/** Mutex guard for the list of all tags. */ +static FIBRIL_MUTEX_INITIALIZE(tag_list_guard); + +/** Find or create new tag with given name. + * + * @param tagname Tag name. + * @return Debug tag structure. + * @retval NULL Out of memory. + */ +static usb_debug_tag_t *get_tag(const char *tagname) +{ + link_t *link; + for (link = tag_list.next; \ + link != &tag_list; \ + link = link->next) { + usb_debug_tag_t *tag = USB_DEBUG_TAG_INSTANCE(link); + if (str_cmp(tag->tag, tagname) == 0) { + return tag; + } + } + + /* + * Tag not found, we will create a new one. + */ + usb_debug_tag_t *new_tag = malloc(sizeof(usb_debug_tag_t)); + int rc = asprintf(&new_tag->tag, "%s", tagname); + if (rc < 0) { + free(new_tag); + return NULL; + } + list_initialize(&new_tag->link); + new_tag->level = 1; + + /* + * Append it to the end of known tags. + */ + list_append(&new_tag->link, &tag_list); + + return new_tag; +} + +/** Print debugging information. + * If the tag is used for the first time, its structures are automatically + * created and initial verbosity level is set to 1. + * + * @param tagname Tag name. + * @param level Level (verbosity) of the message. + * @param format Formatting string for printf(). + */ +void usb_dprintf(const char *tagname, int level, const char *format, ...) +{ + fibril_mutex_lock(&tag_list_guard); + usb_debug_tag_t *tag = get_tag(tagname); + if (tag == NULL) { + printf("USB debug: FATAL ERROR - failed to create tag.\n"); + goto leave; + } + + if (tag->level < level) { + goto leave; + } + + va_list args; + va_start(args, format); + + printf("[%s:%d]: ", tagname, level); + vprintf(format, args); + + va_end(args); + +leave: + fibril_mutex_unlock(&tag_list_guard); +} + +/** Enable debugging prints for given tag. + * + * Setting level to n will cause that only printing messages + * with level lower or equal to n will be printed. + * + * @param tagname Tag name. + * @param level Enabled level. + */ +void usb_dprintf_enable(const char *tagname, int level) +{ + fibril_mutex_lock(&tag_list_guard); + usb_debug_tag_t *tag = get_tag(tagname); + if (tag == NULL) { + printf("USB debug: FATAL ERROR - failed to create tag.\n"); + goto leave; + } + + tag->level = level; + +leave: + fibril_mutex_unlock(&tag_list_guard); +} + + +/** + * @} + */ Index: uspace/lib/usb/src/drvpsync.c =================================================================== --- uspace/lib/usb/src/drvpsync.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/lib/usb/src/drvpsync.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,218 @@ +/* + * 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 libusb usb + * @{ + */ +/** @file + * @brief Implementation of pseudo-synchronous transfers. + */ +#include +#include +#include + +int usb_drv_psync_interrupt_out(int phone, usb_target_t target, + void *buffer, size_t size) +{ + usb_handle_t h; + int rc; + rc = usb_drv_async_interrupt_out(phone, target, buffer, size, &h); + if (rc != EOK) { + return rc; + } + return usb_drv_async_wait_for(h); +} + +int usb_drv_psync_interrupt_in(int phone, usb_target_t target, + void *buffer, size_t size, size_t *actual_size) +{ + usb_handle_t h; + int rc; + rc = usb_drv_async_interrupt_in(phone, target, buffer, size, + actual_size, &h); + if (rc != EOK) { + return rc; + } + return usb_drv_async_wait_for(h); +} + + + +int usb_drv_psync_control_write_setup(int phone, usb_target_t target, + void *buffer, size_t size) +{ + usb_handle_t h; + int rc; + rc = usb_drv_async_control_write_setup(phone, target, buffer, size, &h); + if (rc != EOK) { + return rc; + } + return usb_drv_async_wait_for(h); +} + +int usb_drv_psync_control_write_data(int phone, usb_target_t target, + void *buffer, size_t size) +{ + usb_handle_t h; + int rc; + rc = usb_drv_async_control_write_data(phone, target, buffer, size, &h); + if (rc != EOK) { + return rc; + } + return usb_drv_async_wait_for(h); +} + +int usb_drv_psync_control_write_status(int phone, usb_target_t target) +{ + usb_handle_t h; + int rc; + rc = usb_drv_async_control_write_status(phone, target, &h); + if (rc != EOK) { + return rc; + } + return usb_drv_async_wait_for(h); +} + + +/** Perform complete control write transaction over USB. + * + * The DATA stage is performed only when @p data is not NULL and + * @p data_size is greater than zero. + * + * @param phone Open phone to host controller. + * @param target Target device and endpoint. + * @param setup_packet Setup packet data. + * @param setup_packet_size Size of the setup packet. + * @param data Data to be sent. + * @param data_size Size of the @p data buffer. + * @return Error code. + */ +int usb_drv_psync_control_write(int phone, usb_target_t target, + void *setup_packet, size_t setup_packet_size, + void *data, size_t data_size) +{ + int rc; + + rc = usb_drv_psync_control_write_setup(phone, target, + setup_packet, setup_packet_size); + if (rc != EOK) { + return rc; + } + + if ((data != NULL) && (data_size > 0)) { + rc = usb_drv_psync_control_write_data(phone, target, + data, data_size); + if (rc != EOK) { + return rc; + } + } + + rc = usb_drv_psync_control_write_status(phone, target); + + return rc; +} + + +int usb_drv_psync_control_read_setup(int phone, usb_target_t target, + void *buffer, size_t size) +{ + usb_handle_t h; + int rc; + rc = usb_drv_async_control_read_setup(phone, target, buffer, size, &h); + if (rc != EOK) { + return rc; + } + return usb_drv_async_wait_for(h); +} + +int usb_drv_psync_control_read_data(int phone, usb_target_t target, + void *buffer, size_t size, size_t *actual_size) +{ + usb_handle_t h; + int rc; + rc = usb_drv_async_control_read_data(phone, target, buffer, size, + actual_size, &h); + if (rc != EOK) { + return rc; + } + return usb_drv_async_wait_for(h); +} + +int usb_drv_psync_control_read_status(int phone, usb_target_t target) +{ + usb_handle_t h; + int rc; + rc = usb_drv_async_control_read_status(phone, target, &h); + if (rc != EOK) { + return rc; + } + return usb_drv_async_wait_for(h); +} + + +/** Perform complete control read transaction over USB. + * + * @param phone Open phone to host controller. + * @param target Target device and endpoint. + * @param setup_packet Setup packet data. + * @param setup_packet_size Size of the setup packet. + * @param data Storage for read data. + * @param data_size Size of the @p data buffer. + * @param actual_data_size Storage for number of actually transferred data from + * device. + * @return Error code. + */ +int usb_drv_psync_control_read(int phone, usb_target_t target, + void *setup_packet, size_t setup_packet_size, + void *data, size_t data_size, size_t *actual_data_size) +{ + int rc; + + rc = usb_drv_psync_control_read_setup(phone, target, + setup_packet, setup_packet_size); + if (rc != EOK) { + return rc; + } + + rc = usb_drv_psync_control_read_data(phone, target, + data, data_size, actual_data_size); + if (rc != EOK) { + return rc; + } + + rc = usb_drv_psync_control_read_status(phone, target); + + return rc; +} + + + + +/** + * @} + */ Index: uspace/lib/usb/src/hcdhubd.c =================================================================== --- uspace/lib/usb/src/hcdhubd.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/lib/usb/src/hcdhubd.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,309 @@ +/* + * 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 libusb usb + * @{ + */ +/** @file + * @brief Common stuff for both HC driver and hub driver. + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "hcdhubd_private.h" + +/** Callback when new device is detected and must be handled by this driver. + * + * @param dev New device. + * @return Error code. + */ +static int add_device(device_t *dev) { + return ENOTSUP; +} + +/** Operations for combined HC and HUB driver. */ +static driver_ops_t hc_driver_generic_ops = { + .add_device = add_device +}; + +/** Combined HC and HUB driver. */ +static driver_t hc_driver_generic = { + .driver_ops = &hc_driver_generic_ops +}; + +/** Main USB host controller driver routine. + * + * @see driver_main + * + * @param hc Host controller driver. + * @return Error code. + */ +int usb_hcd_main(usb_hc_driver_t *hc) { + hc_driver = hc; + hc_driver_generic.name = hc->name; + + /* + * Run the device driver framework. + */ + return driver_main(&hc_driver_generic); +} + +/** Add a root hub for given host controller. + * This function shall be called only once for each host controller driven + * by this driver. + * It takes care of creating child device - hub - that will be driven by + * this task. + * + * @param dev Host controller device. + * @return Error code. + */ +int usb_hcd_add_root_hub(device_t *dev) +{ + char *id; + int rc = asprintf(&id, "usb&hub"); + if (rc <= 0) { + return rc; + } + + rc = usb_hc_add_child_device(dev, USB_HUB_DEVICE_NAME, id, true); + if (rc != EOK) { + free(id); + } + + return rc; +} + +/** Info about child device. */ +struct child_device_info { + device_t *parent; + const char *name; + const char *match_id; +}; + +/** Adds a child device fibril worker. */ +static int fibril_add_child_device(void *arg) { + struct child_device_info *child_info + = (struct child_device_info *) arg; + int rc; + + async_usleep(1000); + + device_t *child = create_device(); + match_id_t *match_id = NULL; + + if (child == NULL) { + rc = ENOMEM; + goto failure; + } + child->name = child_info->name; + + match_id = create_match_id(); + if (match_id == NULL) { + rc = ENOMEM; + goto failure; + } + match_id->id = child_info->match_id; + match_id->score = 10; + add_match_id(&child->match_ids, match_id); + + printf("%s: adding child device `%s' with match \"%s\"\n", + hc_driver->name, child->name, match_id->id); + rc = child_device_register(child, child_info->parent); + printf("%s: child device `%s' registration: %s\n", + hc_driver->name, child->name, str_error(rc)); + + if (rc != EOK) { + goto failure; + } + + goto leave; + +failure: + if (child != NULL) { + child->name = NULL; + delete_device(child); + } + + if (match_id != NULL) { + match_id->id = NULL; + delete_match_id(match_id); + } + +leave: + free(arg); + return EOK; +} + +/** Adds a child. + * Due to deadlock in devman when parent registers child that oughts to be + * driven by the same task, the child adding is done in separate fibril. + * Not optimal, but it works. + * Update: not under all circumstances the new fibril is successful either. + * Thus the last parameter to let the caller choose. + * + * @param parent Parent device. + * @param name Device name. + * @param match_id Match id. + * @param create_fibril Whether to run the addition in new fibril. + * @return Error code. + */ +int usb_hc_add_child_device(device_t *parent, const char *name, + const char *match_id, bool create_fibril) { + printf("%s: about to add child device `%s' (%s)\n", hc_driver->name, + name, match_id); + + /* + * Seems that creating fibril which postpones the action + * is the best solution. + */ + create_fibril = true; + + struct child_device_info *child_info + = malloc(sizeof (struct child_device_info)); + + child_info->parent = parent; + child_info->name = name; + child_info->match_id = match_id; + + if (create_fibril) { + fid_t fibril = fibril_create(fibril_add_child_device, child_info); + if (!fibril) { + return ENOMEM; + } + fibril_add_ready(fibril); + } else { + fibril_add_child_device(child_info); + } + + return EOK; +} + +/** Tell USB address of given device. + * + * @param handle Devman handle of the device. + * @return USB device address or error code. + */ +usb_address_t usb_get_address_by_handle(devman_handle_t handle) { + /* TODO: search list of attached devices. */ + return ENOENT; +} + +usb_address_t usb_use_free_address(usb_hc_device_t * this_hcd) { + //is there free address? + link_t * addresses = &this_hcd->addresses; + if (list_empty(addresses)) return -1; + link_t * link_addr = addresses; + bool found = false; + usb_address_list_t * range = NULL; + while (!found) { + link_addr = link_addr->next; + if (link_addr == addresses) return -2; + range = list_get_instance(link_addr, + usb_address_list_t, link); + if (range->upper_bound - range->lower_bound > 0) { + found = true; + } + } + //now we have interval + int result = range->lower_bound; + ++(range->lower_bound); + if (range->upper_bound - range->lower_bound == 0) { + list_remove(&range->link); + free(range); + } + return result; +} + +void usb_free_used_address(usb_hc_device_t * this_hcd, usb_address_t addr) { + //check range + if (addr < usb_lowest_address || addr > usb_highest_address) + return; + link_t * addresses = &this_hcd->addresses; + link_t * link_addr = addresses; + //find 'good' interval + usb_address_list_t * found_range = NULL; + bool found = false; + while (!found) { + link_addr = link_addr->next; + if (link_addr == addresses) { + found = true; + } else { + usb_address_list_t * range = list_get_instance(link_addr, + usb_address_list_t, link); + if ( (range->lower_bound - 1 == addr) || + (range->upper_bound == addr)) { + found = true; + found_range = range; + } + if (range->lower_bound - 1 > addr) { + found = true; + } + + } + } + if (found_range == NULL) { + //no suitable range found + usb_address_list_t * result_range = + (usb_address_list_t*) malloc(sizeof (usb_address_list_t)); + result_range->lower_bound = addr; + result_range->upper_bound = addr + 1; + list_insert_before(&result_range->link, link_addr); + } else { + //we have good range + if (found_range->lower_bound - 1 == addr) { + --found_range->lower_bound; + } else { + //only one possible case + ++found_range->upper_bound; + if (found_range->link.next != addresses) { + usb_address_list_t * next_range = + list_get_instance( &found_range->link.next, + usb_address_list_t, link); + //check neighbour range + if (next_range->lower_bound == addr + 1) { + //join ranges + found_range->upper_bound = next_range->upper_bound; + list_remove(&next_range->link); + free(next_range); + } + } + } + } + +} + +/** + * @} + */ Index: uspace/lib/usb/src/hcdhubd_private.h =================================================================== --- uspace/lib/usb/src/hcdhubd_private.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/lib/usb/src/hcdhubd_private.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,77 @@ +/* + * 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 libusb usb + * @{ + */ +/** @file + * @brief Common definitions for both HC driver and hub driver. + */ +#ifndef LIBUSB_HCDHUBD_PRIVATE_H_ +#define LIBUSB_HCDHUBD_PRIVATE_H_ + +#define USB_HUB_DEVICE_NAME "usbhub" +#define USB_KBD_DEVICE_NAME "hid" + +extern link_t hc_list; +extern usb_hc_driver_t *hc_driver; + +extern usbhc_iface_t usbhc_interface; + +usb_address_t usb_get_address_by_handle(devman_handle_t); +int usb_add_hc_device(device_t *); + +/** lowest allowed usb address */ +extern int usb_lowest_address; + +/** highest allowed usb address */ +extern int usb_highest_address; + +/** + * @brief initialize address list of given hcd + * + * This function should be used only for hcd initialization. + * It creates interval list of free addresses, thus it is initialized as + * list with one interval with whole address space. Using an address shrinks + * the interval, freeing an address extends an interval or creates a + * new one. + * + * @param hcd + * @return + */ +void usb_create_address_list(usb_hc_device_t * hcd); + + + + + + +#endif +/** + * @} + */ Index: uspace/lib/usb/src/hcdrv.c =================================================================== --- uspace/lib/usb/src/hcdrv.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/lib/usb/src/hcdrv.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,127 @@ +/* + * 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 libusb usb + * @{ + */ +/** @file + * @brief HC driver. + */ +#include +#include +#include +#include +#include +#include +#include +#include + +#include "hcdhubd_private.h" + +/** List of handled host controllers. */ +LIST_INITIALIZE(hc_list); + +/* Fake driver to have the name item initialized. */ +static usb_hc_driver_t hc_driver_fake = { + .name = "HCD", +}; + +/** Our HC driver. */ +usb_hc_driver_t *hc_driver = &hc_driver_fake; + +int usb_lowest_address = 1; + +int usb_highest_address = 255; + +static device_ops_t usb_device_ops = { + .interfaces[USBHC_DEV_IFACE] = &usbhc_interface +}; + + +void usb_create_address_list(usb_hc_device_t * hcd){ + list_initialize(&hcd->addresses); + usb_address_list_t * range = + (usb_address_list_t*)malloc(sizeof(usb_address_list_t)); + range->lower_bound = usb_lowest_address; + range->upper_bound = usb_highest_address + 1; + list_append(&range->link, &hcd->addresses); +} + +static usb_hc_device_t *usb_hc_device_create(device_t *dev) { + usb_hc_device_t *hc_dev = malloc(sizeof (usb_hc_device_t)); + + list_initialize(&hc_dev->link); + list_initialize(&hc_dev->hubs); + usb_create_address_list(hc_dev); + list_initialize(&hc_dev->attached_devices); + hc_dev->transfer_ops = NULL; + + hc_dev->generic = dev; + dev->ops = &usb_device_ops; + hc_dev->generic->driver_data = hc_dev; + + return hc_dev; +} + +int usb_add_hc_device(device_t *dev) +{ + return ENOTSUP; + usb_hc_device_t *hc_dev = usb_hc_device_create(dev); + + int rc = hc_driver->add_hc(hc_dev); + if (rc != EOK) { + free(hc_dev); + return rc; + } + + /* + * FIXME: The following line causes devman to hang. + * Will investigate later why. + */ + // add_device_to_class(dev, "usbhc"); + + list_append(&hc_dev->link, &hc_list); + + /* + * FIXME: the following is a workaround to force loading of USB + * keyboard driver. + * Will be removed as soon as the hub driver is completed and + * can detect connected devices. + */ + printf("%s: trying to add USB HID child device...\n", hc_driver->name); + rc = usb_hc_add_child_device(dev, USB_KBD_DEVICE_NAME, "usb&hid", false); + if (rc != EOK) { + printf("%s: adding USB HID child failed...\n", hc_driver->name); + } + + return EOK; +} + +/** + * @} + */ Index: uspace/lib/usb/src/hidparser.c =================================================================== --- uspace/lib/usb/src/hidparser.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/lib/usb/src/hidparser.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,84 @@ +/* + * 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 libusb usb + * @{ + */ +/** @file + * @brief HID parser implementation. + */ +#include +#include + +/** Parse HID report descriptor. + * + * @param parser Opaque HID report parser structure. + * @param data Data describing the report. + * @param size Size of the descriptor in bytes. + * @return Error code. + */ +int usb_hid_parse_report_descriptor(usb_hid_report_parser_t *parser, + const uint8_t *data, size_t size) +{ + return ENOTSUP; +} + +/** Parse and act upon a HID report. + * + * @see usb_hid_parse_report_descriptor + * + * @param parser Opaque HID report parser structure. + * @param data Data for the report. + * @param size Size of the data in bytes. + * @param callbacks Callbacks for report actions. + * @param arg Custom argument (passed through to the callbacks). + * @return Error code. + */ +int usb_hid_parse_report(const usb_hid_report_parser_t *parser, + const uint8_t *data, size_t size, + const usb_hid_report_in_callbacks_t *callbacks, void *arg) +{ + int i; + + // TODO: parse report + + uint16_t keys[6]; + + for (i = 0; i < 6; ++i) { + keys[i] = data[i]; + } + + callbacks->keyboard(keys, 6, arg); + + return EOK; +} + + +/** + * @} + */ Index: uspace/lib/usb/src/localdrv.c =================================================================== --- uspace/lib/usb/src/localdrv.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/lib/usb/src/localdrv.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,414 @@ +/* + * 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 libusb usb + * @{ + */ +/** @file + * @brief Driver communication for local drivers (hubs). + */ +#include +#include +#include +#include +#include + +/** Find host controller when handled by current task. + * + * @param dev Device asking for connection. + * @return Device structure corresponding to parent host controller. + * @retval NULL Corresponding host controller not found. + */ +device_t *usb_hc_connect(device_t *dev) +{ + /* + * FIXME: this will not work when some hub on the path is + * not driven by the same task. + */ + device_t *parent = dev; + while (parent->parent != NULL) { + parent = parent->parent; + } + + if (dev == parent) { + printf("FIXME in %s:%d encountered!\n", __FILE__, __LINE__); + parent = NULL; + } + + return parent; +} + +/** Information about pending transaction on HC. */ +typedef struct { + /** Storage for actual number of bytes transferred. */ + size_t *size_transferred; + + /** Target device. */ + usb_hcd_attached_device_info_t *device; + /** Target endpoint. */ + usb_hc_endpoint_info_t *endpoint; + + /** Guard for the condition variable. */ + fibril_mutex_t condvar_guard; + /** Condition variable for waiting for done. */ + fibril_condvar_t condvar; + + /** Flag whether the transfer is done. */ + bool done; +} transfer_info_t; + +/** Create new transfer info. + * + * @param device Attached device. + * @param endpoint Endpoint. + * @return Transfer info with pre-filled values. + */ +static transfer_info_t *transfer_info_create( + usb_hcd_attached_device_info_t *device, usb_hc_endpoint_info_t *endpoint) +{ + transfer_info_t *transfer = malloc(sizeof(transfer_info_t)); + + transfer->size_transferred = NULL; + fibril_condvar_initialize(&transfer->condvar); + fibril_mutex_initialize(&transfer->condvar_guard); + transfer->done = false; + + transfer->device = device; + transfer->endpoint = endpoint; + + return transfer; +} + +/** Destroy transfer info. + * + * @param transfer Transfer to be destroyed. + */ +static void transfer_info_destroy(transfer_info_t *transfer) +{ + free(transfer->device); + free(transfer->endpoint); + free(transfer); +} + +/** Create info about attached device. + * + * @param address Device address. + * @return Device info structure. + */ +static usb_hcd_attached_device_info_t *create_attached_device_info( + usb_address_t address) +{ + usb_hcd_attached_device_info_t *dev + = malloc(sizeof(usb_hcd_attached_device_info_t)); + + dev->address = address; + dev->endpoint_count = 0; + dev->endpoints = NULL; + list_initialize(&dev->link); + + return dev; +} + +/** Create info about device endpoint. + * + * @param endpoint Endpoint number. + * @param direction Endpoint data direction. + * @param transfer_type Transfer type of the endpoint. + * @return Endpoint info structure. + */ +static usb_hc_endpoint_info_t *create_endpoint_info(usb_endpoint_t endpoint, + usb_direction_t direction, usb_transfer_type_t transfer_type) +{ + usb_hc_endpoint_info_t *ep = malloc(sizeof(usb_hc_endpoint_info_t)); + ep->data_toggle = 0; + ep->direction = direction; + ep->transfer_type = transfer_type; + ep->endpoint = endpoint; + + return ep; +} + +/** Marks given transfer as done. + * + * @param transfer Transfer to be completed. + */ +static void transfer_mark_complete(transfer_info_t *transfer) +{ + fibril_mutex_lock(&transfer->condvar_guard); + transfer->done = true; + fibril_condvar_signal(&transfer->condvar); + fibril_mutex_unlock(&transfer->condvar_guard); +} + +/** Callback for OUT transfers. + * + * @param hc Host controller that processed the transfer. + * @param outcome Transfer outcome. + * @param arg Custom argument. + */ +static void callback_out(usb_hc_device_t *hc, + usb_transaction_outcome_t outcome, void *arg) +{ + transfer_info_t *transfer = (transfer_info_t *) arg; + + /* + * For out transfers, marking them complete is enough. + * No other processing is necessary. + */ + transfer_mark_complete(transfer); +} + +/** Callback for IN transfers. + * + * @param hc Host controller that processed the transfer. + * @param actual_size Number of actually transferred bytes. + * @param outcome Transfer outcome. + * @param arg Custom argument. + */ +static void callback_in(usb_hc_device_t *hc, + size_t actual_size, usb_transaction_outcome_t outcome, void *arg) +{ + transfer_info_t *transfer = (transfer_info_t *) arg; + + /* + * Set the number of actually transferred bytes and + * mark the transfer as complete. + */ + if (transfer->size_transferred != NULL) { + *transfer->size_transferred = actual_size; + } + + transfer_mark_complete(transfer); +} + +static int async_transfer_out(usb_hc_device_t *hc, + usb_target_t target, usb_transfer_type_t transfer_type, + void *data, size_t size, + usb_handle_t *handle) +{ + if ((hc->transfer_ops == NULL) + || (hc->transfer_ops->transfer_out == NULL)) { + return ENOTSUP; + } + + /* This creation of the device on the fly is just a workaround. */ + + transfer_info_t *transfer = transfer_info_create( + create_attached_device_info(target.address), + create_endpoint_info(target.endpoint, + USB_DIRECTION_OUT, transfer_type)); + + int rc = hc->transfer_ops->transfer_out(hc, + transfer->device, transfer->endpoint, + data, size, + callback_out, transfer); + + if (rc != EOK) { + transfer_info_destroy(transfer); + return rc; + } + + *handle = (usb_handle_t)transfer; + + return EOK; +} + +static int async_transfer_setup(usb_hc_device_t *hc, + usb_target_t target, usb_transfer_type_t transfer_type, + void *data, size_t size, + usb_handle_t *handle) +{ + if ((hc->transfer_ops == NULL) + || (hc->transfer_ops->transfer_setup == NULL)) { + return ENOTSUP; + } + + /* This creation of the device on the fly is just a workaround. */ + + transfer_info_t *transfer = transfer_info_create( + create_attached_device_info(target.address), + create_endpoint_info(target.endpoint, + USB_DIRECTION_OUT, transfer_type)); + + int rc = hc->transfer_ops->transfer_setup(hc, + transfer->device, transfer->endpoint, + data, size, + callback_out, transfer); + + if (rc != EOK) { + transfer_info_destroy(transfer); + return rc; + } + + *handle = (usb_handle_t)transfer; + + return EOK; +} + +static int async_transfer_in(usb_hc_device_t *hc, usb_target_t target, + usb_transfer_type_t transfer_type, + void *buffer, size_t size, size_t *actual_size, + usb_handle_t *handle) +{ + if ((hc->transfer_ops == NULL) + || (hc->transfer_ops->transfer_in == NULL)) { + return ENOTSUP; + } + + /* This creation of the device on the fly is just a workaround. */ + + transfer_info_t *transfer = transfer_info_create( + create_attached_device_info(target.address), + create_endpoint_info(target.endpoint, + USB_DIRECTION_IN, transfer_type)); + transfer->size_transferred = actual_size; + + int rc = hc->transfer_ops->transfer_in(hc, + transfer->device, transfer->endpoint, + buffer, size, + callback_in, transfer); + + if (rc != EOK) { + transfer_info_destroy(transfer); + return rc; + } + + *handle = (usb_handle_t)transfer; + + return EOK; +} + + +/** Issue interrupt OUT transfer to HC driven by current task. + * + * @param hc Host controller to handle the transfer. + * @param target Target device address. + * @param buffer Data buffer. + * @param size Buffer size. + * @param handle Transfer handle. + * @return Error code. + */ +int usb_hc_async_interrupt_out(usb_hc_device_t *hc, usb_target_t target, + void *buffer, size_t size, + usb_handle_t *handle) +{ + return async_transfer_out(hc, target, + USB_TRANSFER_INTERRUPT, buffer, size, handle); +} + + +/** Issue interrupt IN transfer to HC driven by current task. + * + * @warning The @p buffer and @p actual_size parameters shall not be + * touched until this transfer is waited for by usb_hc_async_wait_for(). + * + * @param hc Host controller to handle the transfer. + * @param target Target device address. + * @param buffer Data buffer. + * @param size Buffer size. + * @param actual_size Size of actually transferred data. + * @param handle Transfer handle. + * @return Error code. + */ +int usb_hc_async_interrupt_in(usb_hc_device_t *hc, usb_target_t target, + void *buffer, size_t size, size_t *actual_size, + usb_handle_t *handle) +{ + return async_transfer_in(hc, target, + USB_TRANSFER_INTERRUPT, buffer, size, actual_size, handle); +} + +int usb_hc_async_control_write_setup(usb_hc_device_t *hc, usb_target_t target, + void *data, size_t size, usb_handle_t *handle) +{ + return async_transfer_setup(hc, target, + USB_TRANSFER_CONTROL, data, size, handle); +} + +int usb_hc_async_control_write_data(usb_hc_device_t *hc, usb_target_t target, + void *data, size_t size, usb_handle_t *handle) +{ + return async_transfer_out(hc, target, + USB_TRANSFER_CONTROL, data, size, handle); +} + +int usb_hc_async_control_write_status(usb_hc_device_t *hc, usb_target_t target, + usb_handle_t *handle) +{ + return async_transfer_in(hc, target, + USB_TRANSFER_CONTROL, NULL, 0, NULL, handle); +} + +int usb_hc_async_control_read_setup(usb_hc_device_t *hc, usb_target_t target, + void *data, size_t size, usb_handle_t *handle) +{ + return async_transfer_setup(hc, target, + USB_TRANSFER_CONTROL, data, size, handle); +} + +int usb_hc_async_control_read_data(usb_hc_device_t *hc, usb_target_t target, + void *buffer, size_t size, size_t *actual_size, + usb_handle_t *handle) +{ + return async_transfer_in(hc, target, + USB_TRANSFER_CONTROL, buffer, size, actual_size, handle); +} + +int usb_hc_async_control_read_status(usb_hc_device_t *hc, usb_target_t target, + usb_handle_t *handle) +{ + return async_transfer_out(hc, target, + USB_TRANSFER_CONTROL, NULL, 0, handle); +} + +/** Wait for transfer to complete. + * + * @param handle Transfer handle. + * @return Error code. + */ +int usb_hc_async_wait_for(usb_handle_t handle) +{ + transfer_info_t *transfer = (transfer_info_t *) handle; + if (transfer == NULL) { + return ENOENT; + } + + fibril_mutex_lock(&transfer->condvar_guard); + while (!transfer->done) { + fibril_condvar_wait(&transfer->condvar, &transfer->condvar_guard); + } + fibril_mutex_unlock(&transfer->condvar_guard); + + transfer_info_destroy(transfer); + + return EOK; +} + +/** + * @} + */ Index: uspace/lib/usb/src/recognise.c =================================================================== --- uspace/lib/usb/src/recognise.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/lib/usb/src/recognise.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,322 @@ +/* + * 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 libusb usb + * @{ + */ +/** @file + * @brief Functions for recognising kind of attached devices. + */ +#include +#include +#include +#include + + +#define BCD_INT(a) (((unsigned int)(a)) / 256) +#define BCD_FRAC(a) (((unsigned int)(a)) % 256) + +#define BCD_FMT "%x.%x" +#define BCD_ARGS(a) BCD_INT((a)), BCD_FRAC((a)) + +/* FIXME: make this dynamic */ +#define MATCH_STRING_MAX 256 + +/** Add formatted match id. + * + * @param matches List of match ids where to add to. + * @param score Score of the match. + * @param format Printf-like format + * @return Error code. + */ +static int usb_add_match_id(match_id_list_t *matches, int score, + const char *format, ...) +{ + char *match_str = NULL; + match_id_t *match_id = NULL; + int rc; + + match_str = malloc(MATCH_STRING_MAX + 1); + if (match_str == NULL) { + rc = ENOMEM; + goto failure; + } + + /* + * FIXME: replace with dynamic allocation of exact size + */ + va_list args; + va_start(args, format ); + vsnprintf(match_str, MATCH_STRING_MAX, format, args); + match_str[MATCH_STRING_MAX] = 0; + va_end(args); + + match_id = create_match_id(); + if (match_id == NULL) { + rc = ENOMEM; + goto failure; + } + + match_id->id = match_str; + match_id->score = score; + add_match_id(matches, match_id); + + return EOK; + +failure: + if (match_str != NULL) { + free(match_str); + } + if (match_id != NULL) { + match_id->id = NULL; + delete_match_id(match_id); + } + + return rc; +} + +/** Add match ids based on configuration descriptor. + * + * @param hc Open phone to host controller. + * @param matches Match ids list to add matches to. + * @param address USB address of the attached device. + * @return Error code. + */ +static int usb_add_config_descriptor_match_ids(int hc, + match_id_list_t *matches, usb_address_t address, + int config_count) +{ + int final_rc = EOK; + + int config_index; + for (config_index = 0; config_index < config_count; config_index++) { + int rc; + usb_standard_configuration_descriptor_t config_descriptor; + rc = usb_drv_req_get_bare_configuration_descriptor(hc, + address, config_index, &config_descriptor); + if (rc != EOK) { + final_rc = rc; + continue; + } + + size_t full_config_descriptor_size; + void *full_config_descriptor + = malloc(config_descriptor.total_length); + rc = usb_drv_req_get_full_configuration_descriptor(hc, + address, config_index, + full_config_descriptor, config_descriptor.total_length, + &full_config_descriptor_size); + if (rc != EOK) { + final_rc = rc; + continue; + } + if (full_config_descriptor_size + != config_descriptor.total_length) { + final_rc = ERANGE; + continue; + } + + /* + * Iterate through config descriptor to find the interface + * descriptors. + */ + size_t position = sizeof(config_descriptor); + while (position + 1 < full_config_descriptor_size) { + uint8_t *current_descriptor + = ((uint8_t *) full_config_descriptor) + position; + uint8_t cur_descr_len = current_descriptor[0]; + uint8_t cur_descr_type = current_descriptor[1]; + + position += cur_descr_len; + + if (cur_descr_type != USB_DESCTYPE_INTERFACE) { + continue; + } + /* + * Finally, we found an interface descriptor. + */ + usb_standard_interface_descriptor_t *interface + = (usb_standard_interface_descriptor_t *) + current_descriptor; + + rc = usb_add_match_id(matches, 50, + "usb&interface&class=%s", + usb_str_class(interface->interface_class)); + if (rc != EOK) { + final_rc = rc; + break; + } + } + } + + return final_rc; +} + +/** Create match ids describing attached device. + * + * @warning The list of match ids @p matches may change even when + * function exits with error. + * + * @param hc Open phone to host controller. + * @param matches Initialized list of match ids. + * @param address USB address of the attached device. + * @return Error code. + */ +int usb_drv_create_device_match_ids(int hc, match_id_list_t *matches, + usb_address_t address) +{ + int rc; + usb_standard_device_descriptor_t device_descriptor; + + rc = usb_drv_req_get_device_descriptor(hc, address, + &device_descriptor); + if (rc != EOK) { + return rc; + } + + /* + * Unless the vendor id is 0, the pair idVendor-idProduct + * quite uniquely describes the device. + */ + if (device_descriptor.vendor_id != 0) { + /* First, with release number. */ + rc = usb_add_match_id(matches, 100, + "usb&vendor=%d&product=%d&release=" BCD_FMT, + (int) device_descriptor.vendor_id, + (int) device_descriptor.product_id, + BCD_ARGS(device_descriptor.device_version)); + if (rc != EOK) { + return rc; + } + + /* Next, without release number. */ + rc = usb_add_match_id(matches, 90, "usb&vendor=%d&product=%d", + (int) device_descriptor.vendor_id, + (int) device_descriptor.product_id); + if (rc != EOK) { + return rc; + } + + } + + /* + * If the device class points to interface we skip adding + * class directly. + */ + if (device_descriptor.device_class != USB_CLASS_USE_INTERFACE) { + rc = usb_add_match_id(matches, 50, "usb&class=%s", + usb_str_class(device_descriptor.device_class)); + if (rc != EOK) { + return rc; + } + } + /* + * Go through all configurations and add matches + * based on interface class. + */ + rc = usb_add_config_descriptor_match_ids(hc, matches, + address, device_descriptor.configuration_count); + if (rc != EOK) { + return rc; + } + + /* + * As a fallback, provide the simplest match id possible. + */ + rc = usb_add_match_id(matches, 1, "usb&fallback"); + if (rc != EOK) { + return rc; + } + + return EOK; +} + + +/** Probe for device kind and register it in devman. + * + * @param hc Open phone to the host controller. + * @param parent Parent device. + * @param address Address of the (unknown) attached device. + * @return Error code. + */ +int usb_drv_register_child_in_devman(int hc, device_t *parent, + usb_address_t address, devman_handle_t *child_handle) +{ + device_t *child = NULL; + char *child_name = NULL; + int rc; + + child = create_device(); + if (child == NULL) { + rc = ENOMEM; + goto failure; + } + + /* + * TODO: some better child naming + */ + rc = asprintf(&child_name, "usb%p", child); + if (rc < 0) { + goto failure; + } + child->name = child_name; + + rc = usb_drv_create_device_match_ids(hc, &child->match_ids, address); + if (rc != EOK) { + goto failure; + } + + rc = child_device_register(child, parent); + if (rc != EOK) { + goto failure; + } + + if (child_handle != NULL) { + *child_handle = child->handle; + } + + return EOK; + +failure: + if (child != NULL) { + child->name = NULL; + /* This takes care of match_id deallocation as well. */ + delete_device(child); + } + if (child_name != NULL) { + free(child_name); + } + + return rc; + +} + + +/** + * @} + */ Index: uspace/lib/usb/src/remotedrv.c =================================================================== --- uspace/lib/usb/src/remotedrv.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/lib/usb/src/remotedrv.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,437 @@ +/* + * 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 libusb usb + * @{ + */ +/** @file + * @brief Driver communication for remote drivers (interface implementation). + */ +#include +#include +#include +#include +#include + +#include "hcdhubd_private.h" + +static int remote_get_address(device_t *, devman_handle_t, usb_address_t *); + +static int remote_interrupt_out(device_t *, usb_target_t, void *, size_t, + usbhc_iface_transfer_out_callback_t, void *); +static int remote_interrupt_in(device_t *, usb_target_t, void *, size_t, + usbhc_iface_transfer_in_callback_t, void *); + +static int remote_control_write_setup(device_t *, usb_target_t, + void *, size_t, + usbhc_iface_transfer_out_callback_t, void *); +static int remote_control_write_data(device_t *, usb_target_t, + void *, size_t, + usbhc_iface_transfer_out_callback_t, void *); +static int remote_control_write_status(device_t *, usb_target_t, + usbhc_iface_transfer_in_callback_t, void *); + +static int remote_control_read_setup(device_t *, usb_target_t, + void *, size_t, + usbhc_iface_transfer_out_callback_t, void *); +static int remote_control_read_data(device_t *, usb_target_t, + void *, size_t, + usbhc_iface_transfer_in_callback_t, void *); +static int remote_control_read_status(device_t *, usb_target_t, + usbhc_iface_transfer_out_callback_t, void *); + +/** Implementation of USB HC interface. */ +usbhc_iface_t usbhc_interface = { + .tell_address = remote_get_address, + .interrupt_out = remote_interrupt_out, + .interrupt_in = remote_interrupt_in, + .control_write_setup = remote_control_write_setup, + .control_write_data = remote_control_write_data, + .control_write_status = remote_control_write_status, + .control_read_setup = remote_control_read_setup, + .control_read_data = remote_control_read_data, + .control_read_status = remote_control_read_status +}; + +/** Get USB address for remote USBHC interface. + * + * @param dev Device asked for the information. + * @param handle Devman handle of the USB device. + * @param address Storage for obtained address. + * @return Error code. + */ +int remote_get_address(device_t *dev, devman_handle_t handle, + usb_address_t *address) +{ + usb_address_t addr = usb_get_address_by_handle(handle); + if (addr < 0) { + return addr; + } + + *address = addr; + + return EOK; +} + +/** Information about pending transaction on HC. */ +typedef struct { + /** Target device. */ + usb_hcd_attached_device_info_t *device; + /** Target endpoint. */ + usb_hc_endpoint_info_t *endpoint; + + /** Callbacks. */ + union { + /** Callback for outgoing transfers. */ + usbhc_iface_transfer_out_callback_t out_callback; + /** Callback for incoming transfers. */ + usbhc_iface_transfer_in_callback_t in_callback; + }; + + /** Custom argument for the callback. */ + void *arg; +} transfer_info_t; + +/** Create new transfer info. + * + * @param device Attached device. + * @param endpoint Endpoint. + * @param custom_arg Custom argument. + * @return Transfer info with pre-filled values. + */ +static transfer_info_t *transfer_info_create( + usb_hcd_attached_device_info_t *device, usb_hc_endpoint_info_t *endpoint, + void *custom_arg) +{ + transfer_info_t *transfer = malloc(sizeof(transfer_info_t)); + + transfer->device = device; + transfer->endpoint = endpoint; + transfer->arg = custom_arg; + transfer->out_callback = NULL; + transfer->in_callback = NULL; + + return transfer; +} + +/** Destroy transfer info. + * + * @param transfer Transfer to be destroyed. + */ +static void transfer_info_destroy(transfer_info_t *transfer) +{ + free(transfer->device); + free(transfer->endpoint); + free(transfer); +} + +/** Create info about attached device. + * + * @param address Device address. + * @return Device info structure. + */ +static usb_hcd_attached_device_info_t *create_attached_device_info( + usb_address_t address) +{ + usb_hcd_attached_device_info_t *dev + = malloc(sizeof(usb_hcd_attached_device_info_t)); + + dev->address = address; + dev->endpoint_count = 0; + dev->endpoints = NULL; + list_initialize(&dev->link); + + return dev; +} + +/** Create info about device endpoint. + * + * @param endpoint Endpoint number. + * @param direction Endpoint data direction. + * @param transfer_type Transfer type of the endpoint. + * @return Endpoint info structure. + */ +static usb_hc_endpoint_info_t *create_endpoint_info(usb_endpoint_t endpoint, + usb_direction_t direction, usb_transfer_type_t transfer_type) +{ + usb_hc_endpoint_info_t *ep = malloc(sizeof(usb_hc_endpoint_info_t)); + ep->data_toggle = 0; + ep->direction = direction; + ep->transfer_type = transfer_type; + ep->endpoint = endpoint; + + return ep; +} + + + +/** Callback for OUT transfers. + * This callback is called by implementation of HC operations. + * + * @param hc Host controller that processed the transfer. + * @param outcome Transfer outcome. + * @param arg Custom argument. + */ +static void remote_out_callback(usb_hc_device_t *hc, + usb_transaction_outcome_t outcome, void *arg) +{ + transfer_info_t *transfer = (transfer_info_t *) arg; + transfer->out_callback(hc->generic, outcome, transfer->arg); + + transfer_info_destroy(transfer); +} + +/** Start an OUT transfer. + * + * @param dev Device that shall process the transfer. + * @param target Target device for the data. + * @param transfer_type Transfer type. + * @param data Data buffer. + * @param size Size of data buffer. + * @param callback Callback after transfer is complete. + * @param arg Custom argument to the callback. + * @return Error code. + */ +static int remote_out_transfer(device_t *dev, usb_target_t target, + usb_transfer_type_t transfer_type, void *data, size_t size, + usbhc_iface_transfer_out_callback_t callback, void *arg) +{ + usb_hc_device_t *hc = (usb_hc_device_t *) dev->driver_data; + + if ((hc->transfer_ops == NULL) + || (hc->transfer_ops->transfer_out == NULL)) { + return ENOTSUP; + } + + transfer_info_t *transfer = transfer_info_create( + create_attached_device_info(target.address), + create_endpoint_info(target.endpoint, + USB_DIRECTION_OUT, transfer_type), + arg); + transfer->out_callback = callback; + + int rc = hc->transfer_ops->transfer_out(hc, + transfer->device, transfer->endpoint, + data, size, + remote_out_callback, transfer); + + if (rc != EOK) { + transfer_info_destroy(transfer); + return rc; + } + + return EOK; +} + +/** Start a SETUP transfer. + * + * @param dev Device that shall process the transfer. + * @param target Target device for the data. + * @param transfer_type Transfer type. + * @param data Data buffer. + * @param size Size of data buffer. + * @param callback Callback after transfer is complete. + * @param arg Custom argument to the callback. + * @return Error code. + */ +static int remote_setup_transfer(device_t *dev, usb_target_t target, + usb_transfer_type_t transfer_type, void *data, size_t size, + usbhc_iface_transfer_out_callback_t callback, void *arg) +{ + usb_hc_device_t *hc = (usb_hc_device_t *) dev->driver_data; + + if ((hc->transfer_ops == NULL) + || (hc->transfer_ops->transfer_setup == NULL)) { + return ENOTSUP; + } + + transfer_info_t *transfer = transfer_info_create( + create_attached_device_info(target.address), + create_endpoint_info(target.endpoint, + USB_DIRECTION_OUT, transfer_type), + arg); + transfer->out_callback = callback; + + int rc = hc->transfer_ops->transfer_setup(hc, + transfer->device, transfer->endpoint, + data, size, + remote_out_callback, transfer); + + if (rc != EOK) { + transfer_info_destroy(transfer); + return rc; + } + + return EOK; +} + +/** Callback for IN transfers. + * This callback is called by implementation of HC operations. + * + * @param hc Host controller that processed the transfer. + * @param outcome Transfer outcome. + * @param actual_size Size of actually received data. + * @param arg Custom argument. + */ +static void remote_in_callback(usb_hc_device_t *hc, + size_t actual_size, usb_transaction_outcome_t outcome, void *arg) +{ + transfer_info_t *transfer = (transfer_info_t *) arg; + transfer->in_callback(hc->generic, outcome, actual_size, transfer->arg); + + transfer_info_destroy(transfer); +} + +/** Start an IN transfer. + * + * @param dev Device that shall process the transfer. + * @param target Target device for the data. + * @param transfer_type Transfer type. + * @param data Data buffer. + * @param size Size of data buffer. + * @param callback Callback after transfer is complete. + * @param arg Custom argument to the callback. + * @return Error code. + */ +static int remote_in_transfer(device_t *dev, usb_target_t target, + usb_transfer_type_t transfer_type, void *data, size_t size, + usbhc_iface_transfer_in_callback_t callback, void *arg) +{ + usb_hc_device_t *hc = (usb_hc_device_t *) dev->driver_data; + + if ((hc->transfer_ops == NULL) + || (hc->transfer_ops->transfer_in == NULL)) { + return ENOTSUP; + } + + transfer_info_t *transfer = transfer_info_create( + create_attached_device_info(target.address), + create_endpoint_info(target.endpoint, + USB_DIRECTION_OUT, transfer_type), + arg); + transfer->in_callback = callback; + + int rc = hc->transfer_ops->transfer_in(hc, + transfer->device, transfer->endpoint, + data, size, + remote_in_callback, transfer); + + if (rc != EOK) { + transfer_info_destroy(transfer); + return rc; + } + + return EOK; +} + +/** Start outgoing interrupt transfer (USBHC remote interface). + * + * @param dev Host controller device processing the transfer. + * @param target Target USB device. + * @param buffer Data buffer. + * @param size Data buffer size. + * @param callback Callback after the transfer is completed. + * @param arg Custom argument to the callback. + * @return Error code. + */ +int remote_interrupt_out(device_t *dev, usb_target_t target, + void *buffer, size_t size, + usbhc_iface_transfer_out_callback_t callback, void *arg) +{ + return remote_out_transfer(dev, target, USB_TRANSFER_INTERRUPT, + buffer, size, callback, arg); +} + +/** Start incoming interrupt transfer (USBHC remote interface). + * + * @param dev Host controller device processing the transfer. + * @param target Target USB device. + * @param buffer Data buffer. + * @param size Data buffer size. + * @param callback Callback after the transfer is completed. + * @param arg Custom argument to the callback. + * @return Error code. + */ +int remote_interrupt_in(device_t *dev, usb_target_t target, + void *buffer, size_t size, + usbhc_iface_transfer_in_callback_t callback, void *arg) +{ + return remote_in_transfer(dev, target, USB_TRANSFER_INTERRUPT, + buffer, size, callback, arg); +} + + +int remote_control_write_setup(device_t *device, usb_target_t target, + void *buffer, size_t size, + usbhc_iface_transfer_out_callback_t callback, void *arg) +{ + return remote_setup_transfer(device, target, USB_TRANSFER_CONTROL, + buffer, size, callback, arg); +} + +int remote_control_write_data(device_t *device, usb_target_t target, + void *buffer, size_t size, + usbhc_iface_transfer_out_callback_t callback, void *arg) +{ + return remote_out_transfer(device, target, USB_TRANSFER_CONTROL, + buffer, size, callback, arg); +} + +int remote_control_write_status(device_t *device, usb_target_t target, + usbhc_iface_transfer_in_callback_t callback, void *arg) +{ + return remote_in_transfer(device, target, USB_TRANSFER_CONTROL, + NULL, 0, callback, arg); +} + +int remote_control_read_setup(device_t *device, usb_target_t target, + void *buffer, size_t size, + usbhc_iface_transfer_out_callback_t callback, void *arg) +{ + return remote_setup_transfer(device, target, USB_TRANSFER_CONTROL, + buffer, size, callback, arg); +} + +int remote_control_read_data(device_t *dev, usb_target_t target, + void *buffer, size_t size, + usbhc_iface_transfer_in_callback_t callback, void *arg) +{ + return remote_in_transfer(dev, target, USB_TRANSFER_CONTROL, + buffer, size, callback, arg); +} + +int remote_control_read_status(device_t *device, usb_target_t target, + usbhc_iface_transfer_out_callback_t callback, void *arg) +{ + return remote_out_transfer(device, target, USB_TRANSFER_CONTROL, + NULL, 0, callback, arg); +} + +/** + * @} + */ Index: uspace/lib/usb/src/usb.c =================================================================== --- uspace/lib/usb/src/usb.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/lib/usb/src/usb.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,74 @@ +/* + * 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 libusb usb + * @{ + */ +/** @file + * @brief Base USB types. + */ +#include +#include + + +/** String representation for USB transfer type. */ +const char * usb_str_transfer_type(usb_transfer_type_t t) +{ + switch (t) { + case USB_TRANSFER_ISOCHRONOUS: + return "isochronous"; + case USB_TRANSFER_INTERRUPT: + return "interrupt"; + case USB_TRANSFER_CONTROL: + return "control"; + case USB_TRANSFER_BULK: + return "bulk"; + default: + return "unknown"; + } +} + +/** String representation of USB transaction outcome. */ +const char * usb_str_transaction_outcome(usb_transaction_outcome_t o) +{ + switch (o) { + case USB_OUTCOME_OK: + return "ok"; + case USB_OUTCOME_CRCERROR: + return "CRC error"; + case USB_OUTCOME_BABBLE: + return "babble"; + default: + return "unknown"; + } +} + + +/** + * @} + */ Index: uspace/lib/usb/src/usbdrv.c =================================================================== --- uspace/lib/usb/src/usbdrv.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/lib/usb/src/usbdrv.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,490 @@ +/* + * 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 libusb usb + * @{ + */ +/** @file + * @brief USB driver (implementation). + */ +#include +#include +#include +#include + +/** Information about pending transaction on HC. */ +typedef struct { + /** Phone to host controller driver. */ + int phone; + /** Data buffer. */ + void *buffer; + /** Buffer size. */ + size_t size; + /** Storage for actual number of bytes transferred. */ + size_t *size_transferred; + /** Initial call replay data. */ + ipc_call_t reply; + /** Initial call identifier. */ + aid_t request; +} transfer_info_t; + +/** Connect to host controller the device is physically attached to. + * + * @param dev Device asking for connection. + * @param flags Connection flags (blocking connection). + * @return Phone to corresponding HC or error code. + */ +int usb_drv_hc_connect(device_t *dev, unsigned int flags) +{ + /* + * Call parent hub to obtain device handle of respective HC. + */ + + /* + * FIXME: currently we connect always to virtual host controller. + */ + int rc; + devman_handle_t handle; + + rc = devman_device_get_handle("/virt/usbhc", &handle, flags); + if (rc != EOK) { + return rc; + } + + int phone = devman_device_connect(handle, flags); + + return phone; +} + +/** Tell USB address assigned to given device. + * + * @param phone Phone to my HC. + * @param dev Device in question. + * @return USB address or error code. + */ +usb_address_t usb_drv_get_my_address(int phone, device_t *dev) +{ + sysarg_t address; + int rc = async_req_2_1(phone, DEV_IFACE_ID(USBHC_DEV_IFACE), + IPC_M_USBHC_GET_ADDRESS, + dev->handle, &address); + + if (rc != EOK) { + printf("usb_drv_get_my_address over %d failed: %s\n", phone, str_error(rc)); + return rc; + } + + return (usb_address_t) address; +} + +/** Tell HC to reserve default address. + * + * @param phone Open phone to host controller driver. + * @return Error code. + */ +int usb_drv_reserve_default_address(int phone) +{ + return async_req_1_0(phone, DEV_IFACE_ID(USBHC_DEV_IFACE), + IPC_M_USBHC_RESERVE_DEFAULT_ADDRESS); +} + +/** Tell HC to release default address. + * + * @param phone Open phone to host controller driver. + * @return Error code. + */ +int usb_drv_release_default_address(int phone) +{ + return async_req_1_0(phone, DEV_IFACE_ID(USBHC_DEV_IFACE), + IPC_M_USBHC_RELEASE_DEFAULT_ADDRESS); +} + +/** Ask HC for free address assignment. + * + * @param phone Open phone to host controller driver. + * @return Assigned USB address or negative error code. + */ +usb_address_t usb_drv_request_address(int phone) +{ + sysarg_t address; + int rc = async_req_1_1(phone, DEV_IFACE_ID(USBHC_DEV_IFACE), + IPC_M_USBHC_REQUEST_ADDRESS, &address); + if (rc != EOK) { + return rc; + } else { + return (usb_address_t) address; + } +} + +/** Inform HC about binding address with devman handle. + * + * @param phone Open phone to host controller driver. + * @param address Address to be binded. + * @param handle Devman handle of the device. + * @return Error code. + */ +int usb_drv_bind_address(int phone, usb_address_t address, + devman_handle_t handle) +{ + int rc = async_req_3_0(phone, DEV_IFACE_ID(USBHC_DEV_IFACE), + IPC_M_USBHC_BIND_ADDRESS, + address, handle); + + return rc; +} + +/** Inform HC about address release. + * + * @param phone Open phone to host controller driver. + * @param address Address to be released. + * @return Error code. + */ +int usb_drv_release_address(int phone, usb_address_t address) +{ + return async_req_2_0(phone, DEV_IFACE_ID(USBHC_DEV_IFACE), + IPC_M_USBHC_RELEASE_ADDRESS, address); +} + +/** Send data to HCD. + * + * @param phone Phone to HC. + * @param method Method used for calling. + * @param target Targeted device. + * @param buffer Data buffer (NULL to skip data transfer phase). + * @param size Buffer size (must be zero when @p buffer is NULL). + * @param handle Storage for transaction handle (cannot be NULL). + * @return Error status. + * @retval EINVAL Invalid parameter. + * @retval ENOMEM Not enough memory to complete the operation. + */ +static int async_send_buffer(int phone, int method, + usb_target_t target, + void *buffer, size_t size, + usb_handle_t *handle) +{ + if (phone < 0) { + return EINVAL; + } + + if ((buffer == NULL) && (size > 0)) { + return EINVAL; + } + + if (handle == NULL) { + return EINVAL; + } + + transfer_info_t *transfer + = (transfer_info_t *) malloc(sizeof(transfer_info_t)); + if (transfer == NULL) { + return ENOMEM; + } + + transfer->size_transferred = NULL; + transfer->buffer = NULL; + transfer->size = 0; + transfer->phone = phone; + + int rc; + + transfer->request = async_send_4(phone, + DEV_IFACE_ID(USBHC_DEV_IFACE), + method, + target.address, target.endpoint, + size, + &transfer->reply); + + if (size > 0) { + rc = async_data_write_start(phone, buffer, size); + if (rc != EOK) { + async_wait_for(transfer->request, NULL); + return rc; + } + } + + *handle = (usb_handle_t) transfer; + + return EOK; +} + +/** Prepare data retrieval. + * + * @param phone Opened phone to HCD. + * @param method Method used for calling. + * @param target Targeted device. + * @param buffer Buffer where to store retrieved data + * (NULL to skip data transfer phase). + * @param size Buffer size (must be zero when @p buffer is NULL). + * @param actual_size Storage where actual number of bytes transferred will + * be stored. + * @param handle Storage for transaction handle (cannot be NULL). + * @return Error status. + * @retval EINVAL Invalid parameter. + * @retval ENOMEM Not enough memory to complete the operation. + */ +static int async_recv_buffer(int phone, int method, + usb_target_t target, + void *buffer, size_t size, size_t *actual_size, + usb_handle_t *handle) +{ + if (phone < 0) { + return EINVAL; + } + + if ((buffer == NULL) && (size > 0)) { + return EINVAL; + } + + if (handle == NULL) { + return EINVAL; + } + + transfer_info_t *transfer + = (transfer_info_t *) malloc(sizeof(transfer_info_t)); + if (transfer == NULL) { + return ENOMEM; + } + + transfer->size_transferred = actual_size; + transfer->buffer = buffer; + transfer->size = size; + transfer->phone = phone; + + transfer->request = async_send_4(phone, + DEV_IFACE_ID(USBHC_DEV_IFACE), + method, + target.address, target.endpoint, + size, + &transfer->reply); + + *handle = (usb_handle_t) transfer; + + return EOK; +} + +/** Read buffer from HCD. + * + * @param phone Opened phone to HCD. + * @param hash Buffer hash (obtained after completing IN transaction). + * @param buffer Buffer where to store data data. + * @param size Buffer size. + * @param actual_size Storage where actual number of bytes transferred will + * be stored. + * @return Error status. + */ +static int read_buffer_in(int phone, sysarg_t hash, + void *buffer, size_t size, size_t *actual_size) +{ + ipc_call_t answer_data; + sysarg_t answer_rc; + aid_t req; + int rc; + + req = async_send_2(phone, + DEV_IFACE_ID(USBHC_DEV_IFACE), + IPC_M_USBHC_GET_BUFFER, + hash, + &answer_data); + + rc = async_data_read_start(phone, buffer, size); + if (rc != EOK) { + async_wait_for(req, NULL); + return EINVAL; + } + + async_wait_for(req, &answer_rc); + rc = (int)answer_rc; + + if (rc != EOK) { + return rc; + } + + *actual_size = IPC_GET_ARG1(answer_data); + + return EOK; +} + +/** Blocks caller until given USB transaction is finished. + * After the transaction is finished, the user can access all output data + * given to initial call function. + * + * @param handle Transaction handle. + * @return Error status. + * @retval EOK No error. + * @retval EBADMEM Invalid handle. + * @retval ENOENT Data buffer associated with transaction does not exist. + */ +int usb_drv_async_wait_for(usb_handle_t handle) +{ + if (handle == 0) { + return EBADMEM; + } + + int rc = EOK; + + transfer_info_t *transfer = (transfer_info_t *) handle; + + sysarg_t answer_rc; + async_wait_for(transfer->request, &answer_rc); + + if (answer_rc != EOK) { + rc = (int) answer_rc; + goto leave; + } + + /* + * If the buffer is not NULL, we must accept some data. + */ + if ((transfer->buffer != NULL) && (transfer->size > 0)) { + /* + * The buffer hash identifies the data on the server + * side. + * We will use it when actually reading-in the data. + */ + sysarg_t buffer_hash = IPC_GET_ARG1(transfer->reply); + if (buffer_hash == 0) { + rc = ENOENT; + goto leave; + } + + size_t actual_size; + rc = read_buffer_in(transfer->phone, buffer_hash, + transfer->buffer, transfer->size, &actual_size); + + if (rc != EOK) { + goto leave; + } + + if (transfer->size_transferred) { + *(transfer->size_transferred) = actual_size; + } + } + +leave: + free(transfer); + + return rc; +} + +/** Send interrupt data to device. */ +int usb_drv_async_interrupt_out(int phone, usb_target_t target, + void *buffer, size_t size, + usb_handle_t *handle) +{ + return async_send_buffer(phone, + IPC_M_USBHC_INTERRUPT_OUT, + target, + buffer, size, + handle); +} + +/** Request interrupt data from device. */ +int usb_drv_async_interrupt_in(int phone, usb_target_t target, + void *buffer, size_t size, size_t *actual_size, + usb_handle_t *handle) +{ + return async_recv_buffer(phone, + IPC_M_USBHC_INTERRUPT_IN, + target, + buffer, size, actual_size, + handle); +} + +/** Start control write transfer. */ +int usb_drv_async_control_write_setup(int phone, usb_target_t target, + void *buffer, size_t size, + usb_handle_t *handle) +{ + return async_send_buffer(phone, + IPC_M_USBHC_CONTROL_WRITE_SETUP, + target, + buffer, size, + handle); +} + +/** Send data during control write transfer. */ +int usb_drv_async_control_write_data(int phone, usb_target_t target, + void *buffer, size_t size, + usb_handle_t *handle) +{ + return async_send_buffer(phone, + IPC_M_USBHC_CONTROL_WRITE_DATA, + target, + buffer, size, + handle); +} + +/** Finalize control write transfer. */ +int usb_drv_async_control_write_status(int phone, usb_target_t target, + usb_handle_t *handle) +{ + return async_recv_buffer(phone, + IPC_M_USBHC_CONTROL_WRITE_STATUS, + target, + NULL, 0, NULL, + handle); +} + +/** Start control read transfer. */ +int usb_drv_async_control_read_setup(int phone, usb_target_t target, + void *buffer, size_t size, + usb_handle_t *handle) +{ + return async_send_buffer(phone, + IPC_M_USBHC_CONTROL_READ_SETUP, + target, + buffer, size, + handle); +} + +/** Read data during control read transfer. */ +int usb_drv_async_control_read_data(int phone, usb_target_t target, + void *buffer, size_t size, size_t *actual_size, + usb_handle_t *handle) +{ + return async_recv_buffer(phone, + IPC_M_USBHC_CONTROL_READ_DATA, + target, + buffer, size, actual_size, + handle); +} + +/** Finalize control read transfer. */ +int usb_drv_async_control_read_status(int phone, usb_target_t target, + usb_handle_t *handle) +{ + return async_send_buffer(phone, + IPC_M_USBHC_CONTROL_READ_STATUS, + target, + NULL, 0, + handle); +} + +/** + * @} + */ Index: uspace/lib/usb/src/usbdrvreq.c =================================================================== --- uspace/lib/usb/src/usbdrvreq.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/lib/usb/src/usbdrvreq.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,243 @@ +/* + * 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 libusb usb + * @{ + */ +/** @file + * @brief USB driver - standard USB requests (implementation). + */ +#include +#include + +/** Change address of connected device. + * + * @see usb_drv_reserve_default_address + * @see usb_drv_release_default_address + * @see usb_drv_request_address + * @see usb_drv_release_address + * @see usb_drv_bind_address + * + * @param phone Open phone to HC driver. + * @param old_address Current address. + * @param address Address to be set. + * @return Error code. + */ +int usb_drv_req_set_address(int phone, usb_address_t old_address, + usb_address_t new_address) +{ + /* Prepare the target. */ + usb_target_t target = { + .address = old_address, + .endpoint = 0 + }; + + /* Prepare the setup packet. */ + usb_device_request_setup_packet_t setup_packet = { + .request_type = 0, + .request = USB_DEVREQ_SET_ADDRESS, + .index = 0, + .length = 0, + }; + setup_packet.value = new_address; + + int rc = usb_drv_psync_control_write(phone, target, + &setup_packet, sizeof(setup_packet), NULL, 0); + + return rc; +} + +/** Retrieve device descriptor of connected USB device. + * + * @param[in] phone Open phone to HC driver. + * @param[in] address Device USB address. + * @param[out] descriptor Storage for the device descriptor. + * @return Error code. + * @retval EBADMEM @p descriptor is NULL. + */ +int usb_drv_req_get_device_descriptor(int phone, usb_address_t address, + usb_standard_device_descriptor_t *descriptor) +{ + if (descriptor == NULL) { + return EBADMEM; + } + + /* Prepare the target. */ + usb_target_t target = { + .address = address, + .endpoint = 0 + }; + + /* Prepare the setup packet. */ + usb_device_request_setup_packet_t setup_packet = { + .request_type = 128, + .request = USB_DEVREQ_GET_DESCRIPTOR, + .index = 0, + .length = sizeof(usb_standard_device_descriptor_t) + }; + setup_packet.value_high = USB_DESCTYPE_DEVICE; + setup_packet.value_low = 0; + + /* Prepare local descriptor. */ + size_t actually_transferred = 0; + usb_standard_device_descriptor_t descriptor_tmp; + + /* Perform the control read transaction. */ + int rc = usb_drv_psync_control_read(phone, target, + &setup_packet, sizeof(setup_packet), + &descriptor_tmp, sizeof(descriptor_tmp), &actually_transferred); + + if (rc != EOK) { + return rc; + } + + /* Verify that all data has been transferred. */ + if (actually_transferred < sizeof(descriptor_tmp)) { + return ELIMIT; + } + + /* Everything is okay, copy the descriptor. */ + memcpy(descriptor, &descriptor_tmp, + sizeof(descriptor_tmp)); + + return EOK; +} + + +/** Retrieve configuration descriptor of connected USB device. + * + * The function does not retrieve additional data binded with configuration + * descriptor (such as its interface and endpoint descriptors) - use + * usb_drv_req_get_full_configuration_descriptor() instead. + * + * @param[in] phone Open phone to HC driver. + * @param[in] address Device USB address. + * @param[in] index Configuration descriptor index. + * @param[out] descriptor Storage for the configuration descriptor. + * @return Error code. + * @retval EBADMEM @p descriptor is NULL. + */ +int usb_drv_req_get_bare_configuration_descriptor(int phone, + usb_address_t address, int index, + usb_standard_configuration_descriptor_t *descriptor) +{ + if (descriptor == NULL) { + return EBADMEM; + } + + /* Prepare the target. */ + usb_target_t target = { + .address = address, + .endpoint = 0 + }; + + /* Prepare the setup packet. */ + usb_device_request_setup_packet_t setup_packet = { + .request_type = 128, + .request = USB_DEVREQ_GET_DESCRIPTOR, + .index = 0, + .length = sizeof(usb_standard_configuration_descriptor_t) + }; + setup_packet.value_high = USB_DESCTYPE_CONFIGURATION; + setup_packet.value_low = index; + + /* Prepare local descriptor. */ + size_t actually_transferred = 0; + usb_standard_configuration_descriptor_t descriptor_tmp; + + /* Perform the control read transaction. */ + int rc = usb_drv_psync_control_read(phone, target, + &setup_packet, sizeof(setup_packet), + &descriptor_tmp, sizeof(descriptor_tmp), &actually_transferred); + + if (rc != EOK) { + return rc; + } + + /* Verify that all data has been transferred. */ + if (actually_transferred < sizeof(descriptor_tmp)) { + return ELIMIT; + } + + /* Everything is okay, copy the descriptor. */ + memcpy(descriptor, &descriptor_tmp, + sizeof(descriptor_tmp)); + + return EOK; +} + +/** Retrieve full configuration descriptor of connected USB device. + * + * @warning The @p buffer might be touched (i.e. its contents changed) + * even when error occurres. + * + * @param[in] phone Open phone to HC driver. + * @param[in] address Device USB address. + * @param[in] index Configuration descriptor index. + * @param[out] buffer Buffer for the whole configuration descriptor. + * @param[in] buffer_size Size of the prepared @p buffer. + * @param[out] actual_buffer_size Bytes actually transfered. + * @return Error code. + * @retval EBADMEM @p descriptor is NULL. + */ +int usb_drv_req_get_full_configuration_descriptor(int phone, + usb_address_t address, int index, + void *buffer, size_t buffer_size, size_t *actual_buffer_size) +{ + if (buffer == NULL) { + return EBADMEM; + } + + /* Prepare the target. */ + usb_target_t target = { + .address = address, + .endpoint = 0 + }; + + /* Prepare the setup packet. */ + usb_device_request_setup_packet_t setup_packet = { + .request_type = 128, + .request = USB_DEVREQ_GET_DESCRIPTOR, + .index = 0, + .length = buffer_size + }; + setup_packet.value_high = USB_DESCTYPE_CONFIGURATION; + setup_packet.value_low = index; + + /* Perform the control read transaction. */ + int rc = usb_drv_psync_control_read(phone, target, + &setup_packet, sizeof(setup_packet), + buffer, buffer_size, actual_buffer_size); + + return rc; +} + + +/** + * @} + */ Index: uspace/lib/usbvirt/Makefile =================================================================== --- uspace/lib/usbvirt/Makefile (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/lib/usbvirt/Makefile (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -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 = ../.. +LIBRARY = libusbvirt + +LIBS = $(LIBUSB_PREFIX)/libusb.a +EXTRA_CFLAGS = -I$(LIBUSB_PREFIX)/include -Iinclude + +SOURCES = \ + src/callback.c \ + src/ctrlpipe.c \ + src/debug.c \ + src/main.c \ + src/stdreq.c \ + src/transaction.c + +include $(USPACE_PREFIX)/Makefile.common Index: uspace/lib/usbvirt/include/usbvirt/device.h =================================================================== --- uspace/lib/usbvirt/include/usbvirt/device.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/lib/usbvirt/include/usbvirt/device.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,285 @@ +/* + * 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 libusbvirt usb + * @{ + */ +/** @file + * @brief Virtual USB device. + */ +#ifndef LIBUSBVIRT_DEVICE_H_ +#define LIBUSBVIRT_DEVICE_H_ + +#include +#include +#include + +/** Request type of a control transfer. */ +typedef enum { + /** Standard USB request. */ + USBVIRT_REQUEST_TYPE_STANDARD = 0, + /** Standard class USB request. */ + USBVIRT_REQUEST_TYPE_CLASS = 1 +} usbvirt_request_type_t; + +/** Recipient of control request. */ +typedef enum { + /** Device is the recipient of the control request. */ + USBVIRT_REQUEST_RECIPIENT_DEVICE = 0, + /** Interface is the recipient of the control request. */ + USBVIRT_REQUEST_RECIPIENT_INTERFACE = 1, + /** Endpoint is the recipient of the control request. */ + USBVIRT_REQUEST_RECIPIENT_ENDPOINT = 2, + /** Other part of the device is the recipient of the control request. */ + USBVIRT_REQUEST_RECIPIENT_OTHER = 3 +} usbvirt_request_recipient_t; + +/** Possible states of virtual USB device. + * Notice that these are not 1:1 mappings to those in USB specification. + */ +typedef enum { + /** Default state, device listens at default address. */ + USBVIRT_STATE_DEFAULT, + /** Device has non-default address assigned. */ + USBVIRT_STATE_ADDRESS, + /** Device is configured. */ + USBVIRT_STATE_CONFIGURED +} usbvirt_device_state_t; + +typedef struct usbvirt_device usbvirt_device_t; +struct usbvirt_control_transfer; + +typedef int (*usbvirt_on_device_request_t)(usbvirt_device_t *dev, + usb_device_request_setup_packet_t *request, + uint8_t *data); + +/** Callback for control request over pipe zero. + * + * @param dev Virtual device answering the call. + * @param request Request setup packet. + * @param data Data when DATA stage is present. + * @return Error code. + */ +typedef int (*usbvirt_control_request_callback_t)(usbvirt_device_t *dev, + usb_device_request_setup_packet_t *request, + uint8_t *data); + +/** Handler for control transfer on endpoint zero. */ +typedef struct { + /** Request type bitmap. + * Use USBVIRT_MAKE_CONTROL_REQUEST_TYPE for creating the bitmap. + */ + uint8_t request_type; + /** Request code. */ + uint8_t request; + /** Request name for debugging. */ + const char *name; + /** Callback for the request. + * NULL value here announces end of a list. + */ + usbvirt_control_request_callback_t callback; +} usbvirt_control_transfer_handler_t; + +/** Create control request type bitmap. + * + * @param direction Transfer direction (use usb_direction_t). + * @param type Request type (use usbvirt_request_type_t). + * @param recipient Recipient of the request (use usbvirt_request_recipient_t). + * @return Request type bitmap. + */ +#define USBVIRT_MAKE_CONTROL_REQUEST_TYPE(direction, type, recipient) \ + ((((direction) == USB_DIRECTION_IN) ? 1 : 0) << 7) \ + | (((type) & 3) << 5) \ + | (((recipient) & 31)) + +/** Create last item in an array of control request handlers. */ +#define USBVIRT_CONTROL_TRANSFER_HANDLER_LAST { 0, 0, NULL, NULL } + +/** Device operations. */ +typedef struct { + /** Callbacks for transfers over control pipe zero. */ + usbvirt_control_transfer_handler_t *control_transfer_handlers; + + int (*on_control_transfer)(usbvirt_device_t *dev, + usb_endpoint_t endpoint, struct usbvirt_control_transfer *transfer); + + /** Callback for all other incoming data. */ + int (*on_data)(usbvirt_device_t *dev, + usb_endpoint_t endpoint, void *buffer, size_t size); + + /** Callback for host request for data. */ + int (*on_data_request)(usbvirt_device_t *dev, + usb_endpoint_t endpoint, void *buffer, size_t size, size_t *actual_size); + + /** Decides direction of control transfer. */ + usb_direction_t (*decide_control_transfer_direction)( + usb_endpoint_t endpoint, void *buffer, size_t size); + + /** Callback when device changes its state. + * + * It is correct that this function is called when both states + * are equal (e.g. this function is called during SET_CONFIGURATION + * request done on already configured device). + * + * @warning The value of dev->state before calling + * this function is not specified (i.e. can be @p old_state or + * @p new_state). + */ + void (*on_state_change)(usbvirt_device_t *dev, + usbvirt_device_state_t old_state, usbvirt_device_state_t new_state); +} usbvirt_device_ops_t; + +/** Extra configuration data for GET_CONFIGURATION request. */ +typedef struct { + /** Actual data. */ + uint8_t *data; + /** Data length. */ + size_t length; +} usbvirt_device_configuration_extras_t; + +/** Single device configuration. */ +typedef struct { + /** Standard configuration descriptor. */ + usb_standard_configuration_descriptor_t *descriptor; + /** Array of extra data. */ + usbvirt_device_configuration_extras_t *extra; + /** Length of @c extra array. */ + size_t extra_count; +} usbvirt_device_configuration_t; + +/** Standard USB descriptors. */ +typedef struct { + /** Standard device descriptor. + * There is always only one such descriptor for the device. + */ + usb_standard_device_descriptor_t *device; + + /** Configurations. */ + usbvirt_device_configuration_t *configuration; + /** Number of configurations. */ + size_t configuration_count; + /** Index of currently selected configuration. */ + uint8_t current_configuration; +} usbvirt_descriptors_t; + +/** Information about on-going control transfer. + */ +typedef struct usbvirt_control_transfer { + /** Transfer direction (read/write control transfer). */ + usb_direction_t direction; + /** Request data. */ + void *request; + /** Size of request data. */ + size_t request_size; + /** Payload. */ + void *data; + /** Size of payload. */ + size_t data_size; +} usbvirt_control_transfer_t; + +typedef enum { + USBVIRT_DEBUGTAG_BASE = 1, + USBVIRT_DEBUGTAG_TRANSACTION = 2, + USBVIRT_DEBUGTAG_CONTROL_PIPE_ZERO = 4, + USBVIRT_DEBUGTAG_ALL = 255 +} usbvirt_debug_tags_t; + +/** Virtual USB device. */ +struct usbvirt_device { + /** Callback device operations. */ + usbvirt_device_ops_t *ops; + + /** Custom device data. */ + void *device_data; + + /** Reply onto control transfer. + */ + int (*control_transfer_reply)(usbvirt_device_t *dev, + usb_endpoint_t endpoint, void *buffer, size_t size); + + /** Device name. + * Used in debug prints and sent to virtual host controller. + */ + const char *name; + + /** Standard descriptors. */ + usbvirt_descriptors_t *descriptors; + + /** Current device state. */ + usbvirt_device_state_t state; + + /** Device address. */ + usb_address_t address; + /** New device address. + * This field is used during SET_ADDRESS request. + * On all other occasions, it holds invalid address (e.g. -1). + */ + usb_address_t new_address; + + /** Process OUT transaction. */ + int (*transaction_out)(usbvirt_device_t *dev, + usb_endpoint_t endpoint, void *buffer, size_t size); + /** Process SETUP transaction. */ + int (*transaction_setup)(usbvirt_device_t *dev, + usb_endpoint_t endpoint, void *buffer, size_t size); + /** Process IN transaction. */ + int (*transaction_in)(usbvirt_device_t *dev, + usb_endpoint_t endpoint, void *buffer, size_t size, size_t *data_size); + + /** State information on control-transfer endpoints. */ + usbvirt_control_transfer_t current_control_transfers[USB11_ENDPOINT_MAX]; + + /* User debugging. */ + + /** Debug print. */ + void (*debug)(usbvirt_device_t *dev, int level, uint8_t tag, + const char *format, ...); + + /** Current debug level. */ + int debug_level; + + /** Bitmap of currently enabled tags. */ + uint8_t debug_enabled_tags; + + /* Library debugging. */ + + /** Debug print. */ + void (*lib_debug)(usbvirt_device_t *dev, int level, uint8_t tag, + const char *format, ...); + + /** Current debug level. */ + int lib_debug_level; + + /** Bitmap of currently enabled tags. */ + uint8_t lib_debug_enabled_tags; +}; + +#endif +/** + * @} + */ Index: uspace/lib/usbvirt/include/usbvirt/hub.h =================================================================== --- uspace/lib/usbvirt/include/usbvirt/hub.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/lib/usbvirt/include/usbvirt/hub.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,68 @@ +/* + * 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 libusbvirt usb + * @{ + */ +/** @file + * @brief Virtual USB device. + */ +#ifndef LIBUSBVIRT_HUB_H_ +#define LIBUSBVIRT_HUB_H_ + +#include "device.h" + +/** USB transaction type. + * This types does not correspond directly to types in USB specification, + * as actually DATA transactions are marked with these types to identify + * their direction (and tag). + */ +typedef enum { + USBVIRT_TRANSACTION_SETUP, + USBVIRT_TRANSACTION_IN, + USBVIRT_TRANSACTION_OUT +} usbvirt_transaction_type_t; + +const char *usbvirt_str_transaction_type(usbvirt_transaction_type_t type); + +/** Telephony methods of virtual devices. */ +typedef enum { + IPC_M_USBVIRT_GET_NAME = IPC_FIRST_USER_METHOD, + IPC_M_USBVIRT_TRANSACTION_SETUP, + IPC_M_USBVIRT_TRANSACTION_OUT, + IPC_M_USBVIRT_TRANSACTION_IN, +} usbvirt_device_method_t; + +int usbvirt_connect(usbvirt_device_t *); +int usbvirt_connect_local(usbvirt_device_t *); +int usbvirt_disconnect(usbvirt_device_t *dev); + +#endif +/** + * @} + */ Index: uspace/lib/usbvirt/src/callback.c =================================================================== --- uspace/lib/usbvirt/src/callback.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/lib/usbvirt/src/callback.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,234 @@ +/* + * 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 libusbvirt usb + * @{ + */ +/** @file + * @brief Callback connection handling. + */ +#include +#include +#include +#include +#include +#include + +#include "private.h" + +#define NAMESPACE "usb" +#define USB_MAX_PAYLOAD_SIZE 1020 + +/** Wrapper for SETUP transaction over telephone. */ +static void handle_setup_transaction(usbvirt_device_t *device, + ipc_callid_t iid, ipc_call_t icall) +{ + usb_address_t address = IPC_GET_ARG1(icall); + usb_endpoint_t endpoint = IPC_GET_ARG2(icall); + size_t expected_len = IPC_GET_ARG3(icall); + + if (address != device->address) { + ipc_answer_0(iid, EADDRNOTAVAIL); + return; + } + + if ((endpoint < 0) || (endpoint >= USB11_ENDPOINT_MAX)) { + ipc_answer_0(iid, EINVAL); + return; + } + + if (expected_len == 0) { + ipc_answer_0(iid, EINVAL); + return; + } + + size_t len = 0; + void * buffer = NULL; + int rc = async_data_write_accept(&buffer, false, + 1, USB_MAX_PAYLOAD_SIZE, 0, &len); + + if (rc != EOK) { + ipc_answer_0(iid, rc); + return; + } + + rc = device->transaction_setup(device, endpoint, buffer, len); + + ipc_answer_0(iid, rc); +} + +/** Wrapper for OUT transaction over telephone. */ +static void handle_out_transaction(usbvirt_device_t *device, + ipc_callid_t iid, ipc_call_t icall) +{ + usb_address_t address = IPC_GET_ARG1(icall); + usb_endpoint_t endpoint = IPC_GET_ARG2(icall); + size_t expected_len = IPC_GET_ARG3(icall); + + if (address != device->address) { + ipc_answer_0(iid, EADDRNOTAVAIL); + return; + } + + if ((endpoint < 0) || (endpoint >= USB11_ENDPOINT_MAX)) { + ipc_answer_0(iid, EINVAL); + return; + } + + int rc = EOK; + + size_t len = 0; + void *buffer = NULL; + + if (expected_len > 0) { + rc = async_data_write_accept(&buffer, false, + 1, USB_MAX_PAYLOAD_SIZE, 0, &len); + + if (rc != EOK) { + ipc_answer_0(iid, rc); + return; + } + } + + rc = device->transaction_out(device, endpoint, buffer, len); + + if (buffer != NULL) { + free(buffer); + } + + ipc_answer_0(iid, rc); +} + + +/** Wrapper for IN transaction over telephone. */ +static void handle_in_transaction(usbvirt_device_t *device, + ipc_callid_t iid, ipc_call_t icall) +{ + usb_address_t address = IPC_GET_ARG1(icall); + usb_endpoint_t endpoint = IPC_GET_ARG2(icall); + size_t expected_len = IPC_GET_ARG3(icall); + + if (address != device->address) { + ipc_answer_0(iid, EADDRNOTAVAIL); + return; + } + + if ((endpoint < 0) || (endpoint >= USB11_ENDPOINT_MAX)) { + ipc_answer_0(iid, EINVAL); + return; + } + + int rc = EOK; + + void *buffer = expected_len > 0 ? malloc(expected_len) : NULL; + size_t len; + + rc = device->transaction_in(device, endpoint, buffer, expected_len, &len); + /* + * If the request was processed, we will send data back. + */ + if ((rc == EOK) && (expected_len > 0)) { + size_t receive_len; + ipc_callid_t callid; + if (!async_data_read_receive(&callid, &receive_len)) { + ipc_answer_0(iid, EINVAL); + return; + } + async_data_read_finalize(callid, buffer, receive_len); + } + + ipc_answer_0(iid, rc); +} + +/** Wrapper for getting device name. */ +static void handle_get_name(usbvirt_device_t *device, + ipc_callid_t iid, ipc_call_t icall) +{ + if (device->name == NULL) { + ipc_answer_0(iid, ENOENT); + } + + size_t size = str_size(device->name); + + ipc_callid_t callid; + size_t accepted_size; + if (!async_data_read_receive(&callid, &accepted_size)) { + ipc_answer_0(iid, EINVAL); + return; + } + + if (accepted_size > size) { + accepted_size = size; + } + async_data_read_finalize(callid, device->name, accepted_size); + + ipc_answer_1(iid, EOK, accepted_size); +} + +/** Callback connection for a given device. */ +void device_callback_connection(usbvirt_device_t *device, ipc_callid_t iid, ipc_call_t *icall) +{ + ipc_answer_0(iid, EOK); + + while (true) { + ipc_callid_t callid; + ipc_call_t call; + + callid = async_get_call(&call); + switch (IPC_GET_IMETHOD(call)) { + case IPC_M_PHONE_HUNGUP: + ipc_answer_0(callid, EOK); + return; + + case IPC_M_USBVIRT_GET_NAME: + handle_get_name(device, callid, call); + break; + + case IPC_M_USBVIRT_TRANSACTION_SETUP: + handle_setup_transaction(device, callid, call); + break; + + case IPC_M_USBVIRT_TRANSACTION_OUT: + handle_out_transaction(device, callid, call); + break; + + case IPC_M_USBVIRT_TRANSACTION_IN: + handle_in_transaction(device, callid, call); + break; + + default: + ipc_answer_0(callid, EINVAL); + break; + } + } +} + + +/** + * @} + */ Index: uspace/lib/usbvirt/src/ctrlpipe.c =================================================================== --- uspace/lib/usbvirt/src/ctrlpipe.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/lib/usbvirt/src/ctrlpipe.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,182 @@ +/* + * 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 libusbvirt usb + * @{ + */ +/** @file + * @brief Device control pipe. + */ +#include + +#include "private.h" + +/** Compares handler type with request packet type. + * + * @param handler Handler. + * @param request_packet Request packet. + * @return Whether handler can serve this packet. + */ +static bool is_suitable_handler(usbvirt_control_transfer_handler_t *handler, + usb_device_request_setup_packet_t *request_packet) +{ + return ( + (handler->request_type == request_packet->request_type) + && (handler->request == request_packet->request)); + +} + +/** Find suitable transfer handler for given request packet. + * + * @param handlers Array of available handlers. + * @param request_packet Request SETUP packet. + * @return Handler or NULL. + */ +static usbvirt_control_transfer_handler_t *find_handler( + usbvirt_control_transfer_handler_t *handlers, + usb_device_request_setup_packet_t *request_packet) +{ + if (handlers == NULL) { + return NULL; + } + + while (handlers->callback != NULL) { + if (is_suitable_handler(handlers, request_packet)) { + return handlers; + } + handlers++; + } + + return NULL; +} + +#define _GET_BIT(byte, bit) \ + (((byte) & (1 << (bit))) ? '1' : '0') +#define _GET_BITS(byte) \ + _GET_BIT(byte, 7), _GET_BIT(byte, 6), _GET_BIT(byte, 5), \ + _GET_BIT(byte, 4), _GET_BIT(byte, 3), _GET_BIT(byte, 2), \ + _GET_BIT(byte, 1), _GET_BIT(byte, 0) + +static int find_and_run_handler(usbvirt_device_t *device, + usbvirt_control_transfer_handler_t *handlers, + usb_device_request_setup_packet_t *setup_packet, + uint8_t *data) +{ + int rc = EFORWARD; + usbvirt_control_transfer_handler_t *suitable_handler + = find_handler(handlers, setup_packet); + if (suitable_handler != NULL) { + const char *callback_name = "user handler"; + if (suitable_handler->name != NULL) { + callback_name = suitable_handler->name; + } + device->lib_debug(device, 1, USBVIRT_DEBUGTAG_CONTROL_PIPE_ZERO, + "pipe #0 - calling %s " \ + "[%c.%c%c.%c%c%c%c%c, R%d, V%d, I%d, L%d]", + callback_name, + _GET_BITS(setup_packet->request_type), + setup_packet->request, setup_packet->value, + setup_packet->index, setup_packet->length); + rc = suitable_handler->callback(device, setup_packet, data); + } + + return rc; +} +#undef _GET_BITS +#undef _GET_BIT + + +/** Handle communication over control pipe zero. + */ +int control_pipe(usbvirt_device_t *device, usbvirt_control_transfer_t *transfer) +{ + device->lib_debug(device, 2, USBVIRT_DEBUGTAG_CONTROL_PIPE_ZERO, + "op on control pipe zero (request_size=%u)", transfer->request_size); + + if (transfer->request_size < sizeof(usb_device_request_setup_packet_t)) { + return ENOMEM; + } + + usb_device_request_setup_packet_t *request + = (usb_device_request_setup_packet_t *) transfer->request; + + /* + * First, see whether user provided its own callback. + */ + int rc = EFORWARD; + if (device->ops) { + rc = find_and_run_handler(device, + device->ops->control_transfer_handlers, + request, transfer->data); + } + + /* + * If there was no user callback or the callback returned EFORWARD, + * we need to run a local handler. + */ + if (rc == EFORWARD) { + rc = find_and_run_handler(device, + control_pipe_zero_local_handlers, + request, transfer->data); + } + + /* + * Check for SET_ADDRESS finalization. + */ + if (device->new_address != -1) { + /* + * TODO: handle when this request is invalid (e.g. + * setting address when in configured state). + */ + usbvirt_device_state_t new_state; + if (device->new_address == 0) { + new_state = USBVIRT_STATE_DEFAULT; + } else { + new_state = USBVIRT_STATE_ADDRESS; + } + device->address = device->new_address; + + device->new_address = -1; + + if (DEVICE_HAS_OP(device, on_state_change)) { + device->ops->on_state_change(device, device->state, + new_state); + } + device->state = new_state; + + device->lib_debug(device, 2, USBVIRT_DEBUGTAG_CONTROL_PIPE_ZERO, + "device address changed to %d (state %s)", + device->address, str_device_state(device->state)); + } + + return rc; +} + +/** + * @} + */ Index: uspace/lib/usbvirt/src/debug.c =================================================================== --- uspace/lib/usbvirt/src/debug.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/lib/usbvirt/src/debug.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,103 @@ +/* + * 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 libusbvirt usb + * @{ + */ +/** @file + * @brief Debugging support. + */ +#include +#include + +#include "private.h" + + +static void debug_print(int level, uint8_t tag, + int current_level, uint8_t enabled_tags, + const char *format, va_list args) +{ + if (level > current_level) { + return; + } + + if ((tag & enabled_tags) == 0) { + return; + } + + bool print_prefix = true; + + if ((format[0] == '%') && (format[1] == 'M')) { + format += 2; + print_prefix = false; + } + + if (print_prefix) { + printf("[vusb]: "); + while (--level > 0) { + printf(" "); + } + } + + vprintf(format, args); + + if (print_prefix) { + printf("\n"); + } +} + + +void user_debug(usbvirt_device_t *device, int level, uint8_t tag, + const char *format, ...) +{ + va_list args; + va_start(args, format); + + debug_print(level, tag, + device->debug_level, device->debug_enabled_tags, + format, args); + + va_end(args); +} + +void lib_debug(usbvirt_device_t *device, int level, uint8_t tag, + const char *format, ...) +{ + va_list args; + va_start(args, format); + + debug_print(level, tag, + device->lib_debug_level, device->lib_debug_enabled_tags, + format, args); + + va_end(args); +} + +/** + * @} + */ Index: uspace/lib/usbvirt/src/main.c =================================================================== --- uspace/lib/usbvirt/src/main.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/lib/usbvirt/src/main.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -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 libusbvirt usb + * @{ + */ +/** @file + * @brief Device registration with virtual USB framework. + */ +#include +#include +#include +#include +#include + +#include "private.h" + +#define NAMESPACE "usb" + +/** Virtual device wrapper. */ +typedef struct { + /** Actual device. */ + usbvirt_device_t *device; + /** Phone to host controller. */ + int vhcd_phone; + /** Device id. */ + sysarg_t id; + /** Linked-list member. */ + link_t link; +} virtual_device_t; + +/*** List of known device. */ +static LIST_INITIALIZE(device_list); + +/** Find virtual device wrapper based on the contents. */ +static virtual_device_t *find_device(usbvirt_device_t *device) +{ + if (list_empty(&device_list)) { + return NULL; + } + + link_t *pos; + for (pos = device_list.next; pos != &device_list; pos = pos->next) { + virtual_device_t *dev + = list_get_instance(pos, virtual_device_t, link); + if (dev->device == device) { + return dev; + } + } + + return NULL; +} + +/** Find virtual device wrapper by its id. */ +static virtual_device_t *find_device_by_id(sysarg_t id) +{ + if (list_empty(&device_list)) { + return NULL; + } + + link_t *pos; + for (pos = device_list.next; pos != &device_list; pos = pos->next) { + virtual_device_t *dev + = list_get_instance(pos, virtual_device_t, link); + if (dev->id == id) { + return dev; + } + } + + return NULL; +} + +/** Reply to a control transfer. */ +static int control_transfer_reply(usbvirt_device_t *device, + usb_endpoint_t endpoint, void *buffer, size_t size) +{ + usbvirt_control_transfer_t *transfer = &device->current_control_transfers[endpoint]; + if (transfer->data != NULL) { + free(transfer->data); + } + transfer->data = malloc(size); + memcpy(transfer->data, buffer, size); + transfer->data_size = size; + + return EOK; +} + +/** Initialize virtual device. */ +static void device_init(usbvirt_device_t *dev) +{ + dev->transaction_out = transaction_out; + dev->transaction_setup = transaction_setup; + dev->transaction_in = transaction_in; + + dev->control_transfer_reply = control_transfer_reply; + + dev->debug = user_debug; + dev->lib_debug = lib_debug; + + dev->state = USBVIRT_STATE_DEFAULT; + dev->address = 0; + dev->new_address = -1; + + size_t i; + for (i = 0; i < USB11_ENDPOINT_MAX; i++) { + usbvirt_control_transfer_t *transfer = &dev->current_control_transfers[i]; + transfer->direction = 0; + transfer->request = NULL; + transfer->request_size = 0; + transfer->data = NULL; + transfer->data_size = 0; + } +} + +/** Add a virtual device. + * The returned device (if not NULL) shall be destroy via destroy_device(). + */ +static virtual_device_t *add_device(usbvirt_device_t *dev) +{ + assert(find_device(dev) == NULL); + virtual_device_t *new_device + = (virtual_device_t *) malloc(sizeof(virtual_device_t)); + + new_device->device = dev; + link_initialize(&new_device->link); + + list_append(&new_device->link, &device_list); + + return new_device; +} + +/** Destroy virtual device. */ +static void destroy_device(virtual_device_t *dev) +{ + if (dev->vhcd_phone > 0) { + ipc_hangup(dev->vhcd_phone); + } + + list_remove(&dev->link); + + free(dev); +} + +/** Callback connection handler. */ +static void callback_connection(ipc_callid_t iid, ipc_call_t *icall) +{ + // FIXME - determine which device just called back + virtual_device_t *dev = find_device_by_id(0); + if (dev == NULL) { + ipc_answer_0(iid, EINVAL); + printf("Ooops\n"); + return; + } + + device_callback_connection(dev->device, iid, icall); +} + +/** Create necessary phones for communication with virtual HCD. + * This function wraps following calls: + * -# open /dev/devices/\\virt\\usbhc for reading + * -# access phone of file opened in previous step + * -# create callback through just opened phone + * -# create handler for calling on data from host to function + * -# return the (outgoing) phone + * + * @warning This function is wrapper for several actions and therefore + * it is not possible - in case of error - to determine at which point + * error occurred. + * + * @param dev Device to connect. + * @return EOK on success or error code from errno.h. + */ +int usbvirt_connect(usbvirt_device_t *dev) +{ + virtual_device_t *virtual_device = find_device(dev); + if (virtual_device != NULL) { + return EEXISTS; + } + + const char *vhc_path = "/virt/usbhc"; + int rc; + devman_handle_t handle; + + rc = devman_device_get_handle(vhc_path, &handle, 0); + if (rc != EOK) { + printf("devman_device_get_handle() failed\n"); + return rc; + } + + int hcd_phone = devman_device_connect(handle, 0); + + if (hcd_phone < 0) { + printf("devman_device_connect() failed\n"); + return hcd_phone; + } + + sysarg_t phonehash; + rc = ipc_connect_to_me(hcd_phone, 0, 0, 0, &phonehash); + if (rc != EOK) { + printf("ipc_connect_to_me() failed\n"); + return rc; + } + + device_init(dev); + + virtual_device = add_device(dev); + virtual_device->vhcd_phone = hcd_phone; + virtual_device->id = 0; + + async_new_connection(phonehash, 0, NULL, callback_connection); + + return EOK; +} + +/** Prepares device as local. + * This is useful if you want to have a virtual device in the same task + * as HCD. + * + * @param dev Device to connect. + * @return Error code. + * @retval EOK Device connected. + * @retval EEXISTS This device is already connected. + */ +int usbvirt_connect_local(usbvirt_device_t *dev) +{ + virtual_device_t *virtual_device = find_device(dev); + if (virtual_device != NULL) { + return EEXISTS; + } + + device_init(dev); + + virtual_device = add_device(dev); + virtual_device->vhcd_phone = -1; + virtual_device->id = 0; + + return EOK; +} + +/** Disconnects device from HCD. + * + * @param dev Device to be disconnected. + * @return Error code. + * @retval EOK Device connected. + * @retval ENOENT This device is not connected. + */ +int usbvirt_disconnect(usbvirt_device_t *dev) +{ + virtual_device_t *virtual_device = find_device(dev); + if (virtual_device == NULL) { + return ENOENT; + } + + destroy_device(virtual_device); + + return EOK; +} + + +/** + * @} + */ Index: uspace/lib/usbvirt/src/private.h =================================================================== --- uspace/lib/usbvirt/src/private.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/lib/usbvirt/src/private.h (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,94 @@ +/* + * 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 libusbvirt usb + * @{ + */ +/** @file + * @brief Virtual USB private header. + */ +#ifndef LIBUSBVIRT_PRIVATE_H_ +#define LIBUSBVIRT_PRIVATE_H_ + +#include +#include +#include + + +#define DEVICE_HAS_OP(dev, op) \ + ( \ + ( ((dev)->ops) != NULL ) \ + && \ + ( ((dev)->ops->op) != NULL ) \ + ) + +int usbvirt_data_to_host(struct usbvirt_device *dev, + usb_endpoint_t endpoint, void *buffer, size_t size); + +int handle_incoming_data(struct usbvirt_device *dev, + usb_endpoint_t endpoint, void *buffer, size_t size); + +int control_pipe(usbvirt_device_t *device, usbvirt_control_transfer_t *transfer); + +int handle_std_request(usbvirt_device_t *device, usb_device_request_setup_packet_t *request, uint8_t *data); + +void device_callback_connection(usbvirt_device_t *device, ipc_callid_t iid, ipc_call_t *icall); + +int transaction_setup(usbvirt_device_t *device, usb_endpoint_t endpoint, + void *buffer, size_t size); +int transaction_out(usbvirt_device_t *device, usb_endpoint_t endpoint, + void *buffer, size_t size); +int transaction_in(usbvirt_device_t *device, usb_endpoint_t endpoint, + void *buffer, size_t size, size_t *data_size); + + +void user_debug(usbvirt_device_t *device, int level, uint8_t tag, + const char *format, ...); +void lib_debug(usbvirt_device_t *device, int level, uint8_t tag, + const char *format, ...); + +static inline const char *str_device_state(usbvirt_device_state_t state) +{ + switch (state) { + case USBVIRT_STATE_DEFAULT: + return "default"; + case USBVIRT_STATE_ADDRESS: + return "address"; + case USBVIRT_STATE_CONFIGURED: + return "configured"; + default: + return "unknown"; + } +} + +extern usbvirt_control_transfer_handler_t control_pipe_zero_local_handlers[]; + +#endif +/** + * @} + */ Index: uspace/lib/usbvirt/src/stdreq.c =================================================================== --- uspace/lib/usbvirt/src/stdreq.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/lib/usbvirt/src/stdreq.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,214 @@ +/* + * 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 libusbvirt usb + * @{ + */ +/** @file + * @brief Preprocessing of standard device requests. + */ +#include +#include +#include +#include + +#include "private.h" + +/* + * All sub handlers must return EFORWARD to inform the caller that + * they were not able to process the request (yes, it is abuse of + * this error code but such error code shall not collide with anything + * else in this context). + */ + +/** GET_DESCRIPTOR handler. */ +static int handle_get_descriptor(usbvirt_device_t *device, + usb_device_request_setup_packet_t *setup_packet, uint8_t *extra_data) +{ + uint8_t type = setup_packet->value_high; + uint8_t index = setup_packet->value_low; + + /* + * Standard device descriptor. + */ + if ((type == USB_DESCTYPE_DEVICE) && (index == 0)) { + if (device->descriptors && device->descriptors->device) { + return device->control_transfer_reply(device, 0, + device->descriptors->device, + device->descriptors->device->length); + } else { + return EFORWARD; + } + } + + /* + * Configuration descriptor together with interface, endpoint and + * class-specific descriptors. + */ + if (type == USB_DESCTYPE_CONFIGURATION) { + if (!device->descriptors) { + return EFORWARD; + } + if (index >= device->descriptors->configuration_count) { + return EFORWARD; + } + /* Copy the data. */ + usbvirt_device_configuration_t *config = &device->descriptors + ->configuration[index]; + uint8_t *all_data = malloc(config->descriptor->total_length); + if (all_data == NULL) { + return ENOMEM; + } + + uint8_t *ptr = all_data; + memcpy(ptr, config->descriptor, config->descriptor->length); + ptr += config->descriptor->length; + size_t i; + for (i = 0; i < config->extra_count; i++) { + usbvirt_device_configuration_extras_t *extra + = &config->extra[i]; + memcpy(ptr, extra->data, extra->length); + ptr += extra->length; + } + + int rc = device->control_transfer_reply(device, 0, + all_data, config->descriptor->total_length); + + free(all_data); + + return rc; + } + + return EFORWARD; +} + +/** SET_ADDRESS handler. */ +static int handle_set_address(usbvirt_device_t *device, + usb_device_request_setup_packet_t *setup_packet, uint8_t *extra_data) +{ + uint16_t new_address = setup_packet->value; + uint16_t zero1 = setup_packet->index; + uint16_t zero2 = setup_packet->length; + + if ((zero1 != 0) || (zero2 != 0)) { + return EINVAL; + } + + if (new_address > 127) { + return EINVAL; + } + + device->new_address = new_address; + + return EOK; +} + +/** SET_CONFIGURATION handler. */ +static int handle_set_configuration(usbvirt_device_t *device, + usb_device_request_setup_packet_t *setup_packet, uint8_t *extra_data) +{ + uint16_t configuration_value = setup_packet->value; + uint16_t zero1 = setup_packet->index; + uint16_t zero2 = setup_packet->length; + + if ((zero1 != 0) || (zero2 != 0)) { + return EINVAL; + } + + /* + * Configuration value is 1 byte information. + */ + if (configuration_value > 255) { + return EINVAL; + } + + /* + * Do nothing when in default state. According to specification, + * this is not specified. + */ + if (device->state == USBVIRT_STATE_DEFAULT) { + return EOK; + } + + if (configuration_value == 0) { + if (DEVICE_HAS_OP(device, on_state_change)) { + device->ops->on_state_change(device, device->state, + USBVIRT_STATE_ADDRESS); + } + device->state = USBVIRT_STATE_ADDRESS; + } else { + /* + * TODO: browse provided configurations and verify that + * user selected existing configuration. + */ + if (DEVICE_HAS_OP(device, on_state_change)) { + device->ops->on_state_change(device, device->state, + USBVIRT_STATE_CONFIGURED); + } + device->state = USBVIRT_STATE_CONFIGURED; + if (device->descriptors) { + device->descriptors->current_configuration + = configuration_value; + } + } + + return EOK; +} + + +#define MAKE_BM_REQUEST(direction, recipient) \ + USBVIRT_MAKE_CONTROL_REQUEST_TYPE(direction, \ + USBVIRT_REQUEST_TYPE_STANDARD, recipient) +#define MAKE_BM_REQUEST_DEV(direction) \ + MAKE_BM_REQUEST(direction, USBVIRT_REQUEST_RECIPIENT_DEVICE) + +usbvirt_control_transfer_handler_t control_pipe_zero_local_handlers[] = { + { + .request_type = MAKE_BM_REQUEST_DEV(USB_DIRECTION_IN), + .request = USB_DEVREQ_GET_DESCRIPTOR, + .name = "GetDescriptor()", + .callback = handle_get_descriptor + }, + { + .request_type = MAKE_BM_REQUEST_DEV(USB_DIRECTION_OUT), + .request = USB_DEVREQ_SET_ADDRESS, + .name = "SetAddress()", + .callback = handle_set_address + }, + { + .request_type = MAKE_BM_REQUEST_DEV(USB_DIRECTION_OUT), + .request = USB_DEVREQ_SET_CONFIGURATION, + .name = "SetConfiguration()", + .callback = handle_set_configuration + }, + USBVIRT_CONTROL_TRANSFER_HANDLER_LAST +}; + +/** + * @} + */ Index: uspace/lib/usbvirt/src/transaction.c =================================================================== --- uspace/lib/usbvirt/src/transaction.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) +++ uspace/lib/usbvirt/src/transaction.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -0,0 +1,268 @@ +/* + * 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 libusbvirt usb + * @{ + */ +/** @file + * @brief Transaction processing. + */ +#include +#include +#include + +#include "private.h" + +static usb_direction_t setup_transaction_direction(usbvirt_device_t *, + usb_endpoint_t, void *, size_t); +static void process_control_transfer(usbvirt_device_t *, + usb_endpoint_t, usbvirt_control_transfer_t *); + +/** Convert virtual USB transaction type to string. + */ +const char *usbvirt_str_transaction_type(usbvirt_transaction_type_t type) +{ + switch (type) { + case USBVIRT_TRANSACTION_SETUP: + return "setup"; + case USBVIRT_TRANSACTION_IN: + return "in"; + case USBVIRT_TRANSACTION_OUT: + return "out"; + default: + return "unknown"; + } +} + +/** SETUP transaction handling. + * The setup transaction only prepares control transfer on given endpoint. + */ +int transaction_setup(usbvirt_device_t *device, usb_endpoint_t endpoint, + void *buffer, size_t size) +{ + device->lib_debug(device, 1, USBVIRT_DEBUGTAG_TRANSACTION, + "setup transaction: endpoint=%d, size=%u", endpoint, size); + + usbvirt_control_transfer_t *transfer = &device->current_control_transfers[endpoint]; + + if (transfer->request != NULL) { + free(transfer->request); + } + if (transfer->data != NULL) { + free(transfer->data); + } + + transfer->direction = setup_transaction_direction(device, endpoint, + buffer, size); + transfer->request = malloc(size); + memcpy(transfer->request, buffer, size); + transfer->request_size = size; + transfer->data = NULL; + transfer->data_size = 0; + + if (transfer->direction == USB_DIRECTION_IN) { + process_control_transfer(device, endpoint, transfer); + } + + return EOK; +} + +/** OUT transaction handling. + * The OUT transaction can trigger processing of a control transfer. + */ +int transaction_out(usbvirt_device_t *device, usb_endpoint_t endpoint, + void *buffer, size_t size) +{ + device->lib_debug(device, 1, USBVIRT_DEBUGTAG_TRANSACTION, + "out transaction: endpoint=%d, size=%u", endpoint, size); + + /* + * First check whether it is a transaction over control pipe. + */ + usbvirt_control_transfer_t *transfer = &device->current_control_transfers[endpoint]; + if (transfer->request != NULL) { + if (transfer->direction == USB_DIRECTION_OUT) { + /* + * For out transactions, append the data to the buffer. + */ + uint8_t *new_buffer = (uint8_t *) malloc(transfer->data_size + size); + if (transfer->data) { + memcpy(new_buffer, transfer->data, transfer->data_size); + } + memcpy(new_buffer + transfer->data_size, buffer, size); + + if (transfer->data) { + free(transfer->data); + } + transfer->data = new_buffer; + transfer->data_size += size; + } else { + /* + * For in transactions, this means end of the + * transaction. + */ + free(transfer->request); + if (transfer->data) { + free(transfer->data); + } + transfer->request = NULL; + transfer->request_size = 0; + transfer->data = NULL; + transfer->data_size = 0; + } + + return EOK; + } + + /* + * Otherwise, announce that some data has come. + */ + if (device->ops && device->ops->on_data) { + return device->ops->on_data(device, endpoint, buffer, size); + } else { + return ENOTSUP; + } +} + +/** IN transaction handling. + * The IN transaction can trigger processing of a control transfer. + */ +int transaction_in(usbvirt_device_t *device, usb_endpoint_t endpoint, + void *buffer, size_t size, size_t *data_size) +{ + device->lib_debug(device, 1, USBVIRT_DEBUGTAG_TRANSACTION, + "in transaction: endpoint=%d, size=%u", endpoint, size); + + /* + * First check whether it is a transaction over control pipe. + */ + usbvirt_control_transfer_t *transfer = &device->current_control_transfers[endpoint]; + if (transfer->request != NULL) { + if (transfer->direction == USB_DIRECTION_OUT) { + /* + * This means end of input data. + */ + process_control_transfer(device, endpoint, transfer); + } else { + /* + * For in transactions, this means sending next part + * of the buffer. + */ + // FIXME: handle when the HC wants the data back + // in more chunks + size_t actual_size = 0; + if (transfer->data) { + actual_size = transfer->data_size; + } + if (actual_size > size) { + actual_size = size; + } + device->lib_debug(device, 1, USBVIRT_DEBUGTAG_TRANSACTION, + "in transaction: will copy %zu bytes", actual_size); + if (actual_size > 0) { + memcpy(buffer, transfer->data, actual_size); + if (data_size) { + *data_size = actual_size; + } + } + } + + return EOK; + } + + if (size == 0) { + return EINVAL; + } + + int rc = 1; + + if (device->ops && device->ops->on_data_request) { + rc = device->ops->on_data_request(device, endpoint, buffer, size, data_size); + } + + return rc; +} + +/** Determine direction of control transfer. + * First, try the user provided callback, otherwise guess, believing that + * it uses the same format as control pipe 0. + */ +static usb_direction_t setup_transaction_direction(usbvirt_device_t *device, + usb_endpoint_t endpoint, + void *data, size_t size) +{ + int direction = -1; + if (device->ops && device->ops->decide_control_transfer_direction) { + direction = device->ops->decide_control_transfer_direction(endpoint, + data, size); + } + + /* + * If the user-supplied routine have not handled the direction + * (or simply was not provided) we will guess, hoping that it + * uses same format as standard request on control pipe zero. + */ + if (direction < 0) { + if (size > 0) { + uint8_t *ptr = (uint8_t *) data; + if ((ptr[0] & 128) == 128) { + direction = USB_DIRECTION_IN; + } else { + direction = USB_DIRECTION_OUT; + } + } else { + /* This shall not happen anyway. */ + direction = USB_DIRECTION_OUT; + } + } + + return (usb_direction_t) direction; +} + +/** Process control transfer. + */ +static void process_control_transfer(usbvirt_device_t *device, + usb_endpoint_t endpoint, + usbvirt_control_transfer_t *transfer) +{ + int rc = EFORWARD; + + if (device->ops && device->ops->on_control_transfer) { + rc = device->ops->on_control_transfer(device, endpoint, transfer); + } + + if (rc == EFORWARD) { + if (endpoint == 0) { + rc = control_pipe(device, transfer); + } + } +} + +/** + * @} + */ Index: uspace/srv/devman/devman.c =================================================================== --- uspace/srv/devman/devman.c (revision 6eb794aa8b215fdc5cb202ffc13bae94b06623b0) +++ uspace/srv/devman/devman.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -133,4 +133,12 @@ printf(NAME": the '%s' driver was added to the list of available " "drivers.\n", drv->name); + + printf(NAME ": match ids:"); + link_t *cur; + for (cur = drv->match_ids.ids.next; cur != &drv->match_ids.ids; cur = cur->next) { + match_id_t *match_id = list_get_instance(cur, match_id_t, link); + printf(" %d:%s", match_id->score, match_id->id); + } + printf("\n"); } Index: uspace/srv/net/tl/udp/udp.c =================================================================== --- uspace/srv/net/tl/udp/udp.c (revision 6eb794aa8b215fdc5cb202ffc13bae94b06623b0) +++ uspace/srv/net/tl/udp/udp.c (revision 467bf403640ee108a5beaa0da88dce261ba9fabf) @@ -711,5 +711,5 @@ int socket_id; size_t addrlen; - size_t size; + size_t size = 0; ipc_call_t answer; int answer_count;