Index: uspace/app/vuhid/Makefile =================================================================== --- uspace/app/vuhid/Makefile (revision 57c7050ac47e21d938a2a00205aa48518b743a78) +++ uspace/app/vuhid/Makefile (revision 57c7050ac47e21d938a2a00205aa48518b743a78) @@ -0,0 +1,54 @@ +# +# Copyright (c) 2011 Vojtech Horky +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# - Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# - Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# - The name of the author may not be used to endorse or promote products +# derived from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR +# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES +# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# + +USPACE_PREFIX = ../.. +# acronym for virtual USB human input device +# (it is really annoying to write long names) +BINARY = vuh + +LIBS = \ + $(LIBUSBVIRT_PREFIX)/libusbvirt.a \ + $(LIBUSB_PREFIX)/libusb.a +EXTRA_CFLAGS = \ + -I$(LIBUSB_PREFIX)/include \ + -I$(LIBUSBVIRT_PREFIX)/include \ + -I$(LIBDRV_PREFIX)/include + + +SOURCES_INTERFACES = \ + hids/bootkbd.c + +SOURCES = \ + main.c \ + device.c \ + ifaces.c \ + stdreq.c \ + $(SOURCES_INTERFACES) + + +include $(USPACE_PREFIX)/Makefile.common Index: uspace/app/vuhid/device.c =================================================================== --- uspace/app/vuhid/device.c (revision 57c7050ac47e21d938a2a00205aa48518b743a78) +++ uspace/app/vuhid/device.c (revision 57c7050ac47e21d938a2a00205aa48518b743a78) @@ -0,0 +1,335 @@ +/* + * Copyright (c) 2011 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup usbvirthid + * @{ + */ +/** + * @file + * Virtual USB HID device. + */ +#include "virthid.h" +#include +#include +#include +#include + +static int on_data_from_device(usbvirt_device_t *dev, + usb_endpoint_t ep, usb_transfer_type_t tr_type, + void *data, size_t data_size, size_t *actual_size) +{ + vuhid_data_t *vuhid = dev->device_data; + vuhid_interface_t *iface = vuhid->in_endpoints_mapping[ep]; + if (iface == NULL) { + return ESTALL; + } + + if (iface->on_data_in == NULL) { + return EBADCHECKSUM; + } + + return iface->on_data_in(iface, data, data_size, actual_size); +} + +static int on_data_to_device(usbvirt_device_t *dev, + usb_endpoint_t ep, usb_transfer_type_t tr_type, + void *data, size_t data_size) +{ + vuhid_data_t *vuhid = dev->device_data; + vuhid_interface_t *iface = vuhid->out_endpoints_mapping[ep]; + if (iface == NULL) { + return ESTALL; + } + + if (iface->on_data_out == NULL) { + return EBADCHECKSUM; + } + + return iface->on_data_out(iface, data, data_size); +} + +static int interface_life_fibril(void *arg) +{ + vuhid_interface_t *iface = arg; + + if (iface->live != NULL) { + iface->live(iface); + } + + return EOK; +} + + +static vuhid_interface_t *find_interface_by_id(vuhid_interface_t **ifaces, + const char *id) +{ + vuhid_interface_t *iface = ifaces[0]; + while (iface != NULL) { + if (str_cmp(iface->id, id) == 0) { + return iface; + } + iface++; + } + + return iface; +} + +int add_interface_by_id(vuhid_interface_t **interfaces, const char *id, + usbvirt_device_t *dev) +{ + vuhid_interface_t *iface = find_interface_by_id(interfaces, id); + if (iface == NULL) { + return ENOENT; + } + + if ((iface->in_data_size == 0) && (iface->out_data_size == 0)) { + return EEMPTY; + } + + vuhid_data_t *hid_data = dev->device_data; + + /* Check that we have not run out of available endpoints. */ + if ((iface->in_data_size > 0) + && (hid_data->in_endpoint_first_free >= VUHID_ENDPOINT_MAX)) { + return ELIMIT; + } + if ((iface->out_data_size > 0) + && (hid_data->out_endpoint_first_free >= VUHID_ENDPOINT_MAX)) { + return ELIMIT; + } + + if (dev->descriptors->configuration->descriptor->interface_count >= + VUHID_INTERFACE_MAX) { + return ELIMIT; + } + + /* + * How may descriptors we would add? + */ + /* Start with interface descriptor. */ + size_t new_descriptor_count = 1; + /* Having in/out data size positive means we would need endpoint. */ + if (iface->in_data_size > 0) { + new_descriptor_count++; + } + if (iface->out_data_size > 0) { + new_descriptor_count++; + } + /* Having report descriptor means adding the HID descriptor. */ + if (iface->report_descriptor != NULL) { + new_descriptor_count++; + } + + /* From now on, in case of errors, we goto to error_leave */ + int rc; + + /* + * Prepare new descriptors. + */ + printf("preparing descriptors...\n"); + size_t descr_count = 0; + size_t total_descr_size = 0; + usb_standard_interface_descriptor_t *descr_iface = NULL; + hid_descriptor_t *descr_hid = NULL; + usb_standard_endpoint_descriptor_t *descr_ep_in = NULL; + usb_standard_endpoint_descriptor_t *descr_ep_out = NULL; + + size_t ep_count = 0; + if (iface->in_data_size > 0) { + ep_count++; + } + if (iface->out_data_size > 0) { + ep_count++; + } + assert(ep_count > 0); + + /* Interface would be needed always. */ + descr_iface = malloc(sizeof(usb_standard_interface_descriptor_t)); + if (descr_iface == NULL) { + rc = ENOMEM; + goto error_leave; + } + descr_count++; + total_descr_size += sizeof(usb_standard_interface_descriptor_t); + descr_iface->length = sizeof(usb_standard_interface_descriptor_t); + descr_iface->descriptor_type = USB_DESCTYPE_INTERFACE; + descr_iface->interface_number + = dev->descriptors->configuration->descriptor->interface_count; + descr_iface->alternate_setting = 0; + descr_iface->endpoint_count = ep_count; + descr_iface->interface_class = USB_CLASS_HID; + descr_iface->interface_subclass = iface->usb_subclass; + descr_iface->interface_protocol = iface->usb_protocol; + descr_iface->str_interface = 0; + + /* Create the HID descriptor. */ + if (iface->report_descriptor != NULL) { + descr_hid = malloc(sizeof(hid_descriptor_t)); + if (descr_hid == NULL) { + rc = ENOMEM; + goto error_leave; + } + descr_count++; + total_descr_size += sizeof(hid_descriptor_t); + descr_hid->length = sizeof(hid_descriptor_t); + descr_hid->type = USB_DESCTYPE_HID; + descr_hid->hid_spec_release = 0x101; + descr_hid->country_code = 0; + descr_hid->descriptor_count = 1; + descr_hid->descriptor1_type = USB_DESCTYPE_HID_REPORT; + descr_hid->descriptor1_length = iface->report_descriptor_size; + } + + /* Prepare the endpoint descriptors. */ + if (iface->in_data_size > 0) { + descr_ep_in = malloc(sizeof(usb_standard_endpoint_descriptor_t)); + if (descr_ep_in == NULL) { + rc = ENOMEM; + goto error_leave; + } + descr_count++; + total_descr_size += sizeof(usb_standard_endpoint_descriptor_t); + descr_ep_in->length = sizeof(usb_standard_endpoint_descriptor_t); + descr_ep_in->descriptor_type = USB_DESCTYPE_ENDPOINT; + descr_ep_in->endpoint_address + = 0x80 | hid_data->in_endpoint_first_free; + descr_ep_in->attributes = 3; + descr_ep_in->max_packet_size = iface->in_data_size; + descr_ep_in->poll_interval = 10; + } + if (iface->out_data_size > 0) { + descr_ep_out = malloc(sizeof(usb_standard_endpoint_descriptor_t)); + if (descr_ep_out == NULL) { + rc = ENOMEM; + goto error_leave; + } + descr_count++; + total_descr_size += sizeof(usb_standard_endpoint_descriptor_t); + descr_ep_out->length = sizeof(usb_standard_endpoint_descriptor_t); + descr_ep_out->descriptor_type = USB_DESCTYPE_ENDPOINT; + descr_ep_out->endpoint_address + = 0x00 | hid_data->out_endpoint_first_free; + descr_ep_out->attributes = 3; + descr_ep_out->max_packet_size = iface->out_data_size; + descr_ep_out->poll_interval = 10; + } + + /* Extend existing extra descriptors with these ones. */ + usbvirt_device_configuration_extras_t *extra_descriptors + = dev->descriptors->configuration->extra; + extra_descriptors = realloc(extra_descriptors, + sizeof(usbvirt_device_configuration_extras_t) + * (dev->descriptors->configuration->extra_count + descr_count)); + if (extra_descriptors == NULL) { + rc = ENOMEM; + goto error_leave; + } + + /* Launch the "life" fibril. */ + fid_t life_fibril = fibril_create(interface_life_fibril, iface); + if (life_fibril == 0) { + rc = ENOMEM; + goto error_leave; + } + + printf("adding extra descriptors...\n"); + /* Allocation is okay, we can (actually have to now) overwrite the + * original pointer. + */ + dev->descriptors->configuration->extra = extra_descriptors; + extra_descriptors += dev->descriptors->configuration->extra_count; + + /* Initialize them. */ +#define _APPEND_DESCRIPTOR(descriptor) \ + do { \ + if ((descriptor) != NULL) { \ + extra_descriptors->data = (uint8_t *) (descriptor); \ + extra_descriptors->length = (descriptor)->length; \ + extra_descriptors++; \ + } \ + } while (0) + + _APPEND_DESCRIPTOR(descr_iface); + _APPEND_DESCRIPTOR(descr_hid); + _APPEND_DESCRIPTOR(descr_ep_in); + _APPEND_DESCRIPTOR(descr_ep_out); +#undef _APPEND_DESCRIPTOR + dev->descriptors->configuration->extra_count += descr_count; + + /* + * Final changes. + * Increase the necessary counters, make endpoint mapping. + * + */ + if (iface->in_data_size > 0) { + hid_data->in_endpoints_mapping[hid_data->in_endpoint_first_free] + = iface; + dev->ops->data_in[hid_data->in_endpoint_first_free] + = on_data_from_device; + hid_data->in_endpoint_first_free++; + } + if (iface->out_data_size > 0) { + hid_data->out_endpoints_mapping[hid_data->out_endpoint_first_free] + = iface; + dev->ops->data_out[hid_data->out_endpoint_first_free] + = on_data_to_device; + hid_data->out_endpoint_first_free++; + } + + hid_data->interface_mapping[ + dev->descriptors->configuration->descriptor->interface_count] + = iface; + + dev->descriptors->configuration->descriptor->interface_count++; + dev->descriptors->configuration->descriptor->total_length + += total_descr_size; + + fibril_add_ready(life_fibril); + + return EOK; + +error_leave: + if (descr_iface != NULL) { + free(descr_iface); + } + if (descr_hid != NULL) { + free(descr_hid); + } + if (descr_ep_in != NULL) { + free(descr_ep_in); + } + if (descr_ep_out != NULL) { + free(descr_ep_out); + } + + return rc; +} + + +/** @} + */ Index: uspace/app/vuhid/hids/bootkbd.c =================================================================== --- uspace/app/vuhid/hids/bootkbd.c (revision 57c7050ac47e21d938a2a00205aa48518b743a78) +++ uspace/app/vuhid/hids/bootkbd.c (revision 57c7050ac47e21d938a2a00205aa48518b743a78) @@ -0,0 +1,176 @@ +/* + * Copyright (c) 2011 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup usbvirthid + * @{ + */ +/** @file + * + */ +#include "../virthid.h" +#include +#include +#include +#include + +#include "../../virtusbkbd/report.h" + +uint8_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(6), + 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() +}; + +#define INPUT_SIZE 8 + +static uint8_t in_data[] = { + 0, 0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0, 0, 0x39, 0x00, 0x00, 0x00, 0x00, 0x00, // Caps Lock + 0, 0, 0x53, 0x00, 0x00, 0x00, 0x00, 0x00, // Num Lock + 0, 0, 0x39, 0x00, 0x00, 0x00, 0x00, 0x00, // Caps Lock + 1 << 2, 0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 1 << 2, 0, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, + 1 << 2, 0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0, 0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 +}; +static size_t in_data_count = sizeof(in_data)/INPUT_SIZE; +// FIXME - locking +static size_t in_data_position = 0; + +static int on_data_in(vuhid_interface_t *iface, + void *buffer, size_t buffer_size, size_t *act_buffer_size) +{ + static size_t last_pos = (size_t) -1; + size_t pos = in_data_position; + if (pos >= in_data_count) { + return EBADCHECKSUM; + } + + if (last_pos == pos) { + return ENAK; + } + + if (buffer_size > INPUT_SIZE) { + buffer_size = INPUT_SIZE; + } + + if (act_buffer_size != NULL) { + *act_buffer_size = buffer_size; + } + + memcpy(buffer, in_data + pos * INPUT_SIZE, buffer_size); + last_pos = pos; + + return EOK; +} + +static int on_data_out(vuhid_interface_t *iface, + void *buffer, size_t buffer_size) +{ + if (buffer_size == 0) { + return EEMPTY; + } + uint8_t leds = ((uint8_t *) buffer)[0]; +#define _GET_LED(index, signature) \ + (((leds) & (1 << index)) ? (signature) : '-') + usb_log_info("%s: LEDs = %c%c%c%c%c\n", + iface->name, + _GET_LED(0, '0'), _GET_LED(1, 'A'), _GET_LED(2, 's'), + _GET_LED(3, 'c'), _GET_LED(4, 'k')); +#undef _GET_LED + return EOK; +} + + +static void live(vuhid_interface_t *iface) +{ + async_usleep(1000 * 1000 * 5); + usb_log_debug("Boot keyboard comes to life...\n"); + while (in_data_position < in_data_count) { + async_usleep(1000 * 500); + in_data_position++; + } + usb_log_debug("Boot keyboard died.\n"); +} + + +vuhid_interface_t vuhid_interface_bootkbd = { + .id = "boot", + .name = "boot keyboard", + .usb_subclass = USB_HID_SUBCLASS_BOOT, + .usb_protocol = USB_HID_PROTOCOL_KEYBOARD, + + .report_descriptor = report_descriptor, + .report_descriptor_size = sizeof(report_descriptor), + + .in_data_size = INPUT_SIZE, + .on_data_in = on_data_in, + + .out_data_size = 1, + .on_data_out = on_data_out, + + .live = live +}; + +/** + * @} + */ Index: uspace/app/vuhid/ifaces.c =================================================================== --- uspace/app/vuhid/ifaces.c (revision 57c7050ac47e21d938a2a00205aa48518b743a78) +++ uspace/app/vuhid/ifaces.c (revision 57c7050ac47e21d938a2a00205aa48518b743a78) @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2011 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup usbvirthid + * @{ + */ +/** + * @file + * List of known interfaces. + */ +#include +#include "ifaces.h" + +extern vuhid_interface_t vuhid_interface_bootkbd; + +vuhid_interface_t *available_hid_interfaces[] = { + &vuhid_interface_bootkbd, + NULL +}; + + +/** @} + */ Index: uspace/app/vuhid/ifaces.h =================================================================== --- uspace/app/vuhid/ifaces.h (revision 57c7050ac47e21d938a2a00205aa48518b743a78) +++ uspace/app/vuhid/ifaces.h (revision 57c7050ac47e21d938a2a00205aa48518b743a78) @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2011 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup usbvirthid + * @{ + */ +/** @file + * + */ +#ifndef VUHID_IFACES_H_ +#define VUHID_IFACES_H_ + +#include "virthid.h" + +extern vuhid_interface_t *available_hid_interfaces[]; + +#endif +/** + * @} + */ Index: uspace/app/vuhid/main.c =================================================================== --- uspace/app/vuhid/main.c (revision 57c7050ac47e21d938a2a00205aa48518b743a78) +++ uspace/app/vuhid/main.c (revision 57c7050ac47e21d938a2a00205aa48518b743a78) @@ -0,0 +1,195 @@ +/* + * Copyright (c) 2011 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup usbvirthid + * @{ + */ +/** + * @file + * Virtual USB HID device. + */ + +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#include "virthid.h" +#include "ifaces.h" +#include "stdreq.h" + +static usbvirt_control_request_handler_t endpoint_zero_handlers[] = { + { + .req_direction = USB_DIRECTION_IN, + .req_type = USB_REQUEST_TYPE_STANDARD, + .req_recipient = USB_REQUEST_RECIPIENT_INTERFACE, + .request = USB_DEVREQ_GET_DESCRIPTOR, + .name = "Get_Descriptor", + .callback = req_get_descriptor + }, + { + .req_direction = USB_DIRECTION_OUT, + .req_recipient = USB_REQUEST_RECIPIENT_INTERFACE, + .req_type = USB_REQUEST_TYPE_CLASS, + .request = USB_HIDREQ_SET_PROTOCOL, + .name = "Set_Protocol", + .callback = req_set_protocol + }, + { + .req_direction = USB_DIRECTION_OUT, + .req_recipient = USB_REQUEST_RECIPIENT_INTERFACE, + .req_type = USB_REQUEST_TYPE_CLASS, + .request = USB_HIDREQ_SET_REPORT, + .name = "Set_Report", + .callback = req_set_report + }, + { + .callback = NULL + } +}; + +/** Keyboard callbacks. + * We abuse the fact that static variables are zero-filled. + */ +static usbvirt_device_ops_t hid_ops = { + .control = endpoint_zero_handlers, +}; + +/** Standard configuration descriptor. */ +static usb_standard_configuration_descriptor_t std_configuration_descriptor = { + .length = sizeof(usb_standard_configuration_descriptor_t), + .descriptor_type = USB_DESCTYPE_CONFIGURATION, + /* Will be patched at runtime. */ + .total_length = sizeof(usb_standard_configuration_descriptor_t), + .interface_count = 0, + .configuration_number = 1, + .str_configuration = 0, + .attributes = 128, /* denotes bus-powered device */ + .max_power = 50 +}; + +/** Standard device descriptor. */ +static 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 +}; + +/** HID configuration. */ +usbvirt_device_configuration_t configuration = { + .descriptor = &std_configuration_descriptor, + .extra = NULL, + .extra_count = 0 +}; + +/** HID standard descriptors. */ +usbvirt_descriptors_t descriptors = { + .device = &std_device_descriptor, + .configuration = &configuration, + .configuration_count = 1, +}; + +static vuhid_data_t vuhid_data = { + .in_endpoints_mapping = { NULL }, + .in_endpoint_first_free = 1, + .out_endpoints_mapping = { NULL }, + .out_endpoint_first_free = 1 +}; + +/** Keyboard device. + * Rest of the items will be initialized later. + */ +static usbvirt_device_t hid_dev = { + .ops = &hid_ops, + .descriptors = &descriptors, + .name = "HID", + .device_data = &vuhid_data +}; + + +int main(int argc, char * argv[]) +{ + int rc; + + usb_log_enable(USB_LOG_LEVEL_DEBUG2, "vusbhid"); + + /* Determine which interfaces to initialize. */ + int i; + for (i = 1; i < argc; i++) { + rc = add_interface_by_id(available_hid_interfaces, argv[i], + &hid_dev); + if (rc != EOK) { + fprintf(stderr, "Failed to add device `%s': %s.\n", + argv[i], str_error(rc)); + } else { + printf("Added device `%s'.\n", argv[i]); + } + } + + for (i = 0; i < (int) hid_dev.descriptors->configuration->extra_count; i++) { + usb_log_debug("Found extra descriptor: %s.\n", + usb_debug_str_buffer( + hid_dev.descriptors->configuration->extra[i].data, + hid_dev.descriptors->configuration->extra[i].length, + 0)); + } + + rc = usbvirt_device_plug(&hid_dev, "/virt/usbhc/hc"); + if (rc != EOK) { + printf("Unable to start communication with VHCD: %s.\n", + str_error(rc)); + return rc; + } + + printf("Connected to VHCD...\n"); + + while (true) { + async_usleep(10 * 1000 * 1000); + } + + printf("Terminating...\n"); + + return 0; +} + + +/** @} + */ Index: uspace/app/vuhid/stdreq.c =================================================================== --- uspace/app/vuhid/stdreq.c (revision 57c7050ac47e21d938a2a00205aa48518b743a78) +++ uspace/app/vuhid/stdreq.c (revision 57c7050ac47e21d938a2a00205aa48518b743a78) @@ -0,0 +1,119 @@ +/* + * Copyright (c) 2011 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup usbvirthid + * @{ + */ +/** + * @file + * + */ +#include +#include +#include +#include "stdreq.h" +#include "virthid.h" + +#define VUHID_DATA(vuhid, device) \ + vuhid_data_t *vuhid = device->device_data + +int req_get_descriptor(usbvirt_device_t *device, + const usb_device_request_setup_packet_t *setup_packet, + uint8_t *data, size_t *act_size) +{ + VUHID_DATA(vuhid, device); + + if (setup_packet->value_high == USB_DESCTYPE_HID_REPORT) { + vuhid_interface_t *iface + = vuhid->interface_mapping[setup_packet->index]; + if (iface == NULL) { + return EFORWARD; + } + if (iface->report_descriptor != NULL) { + usbvirt_control_reply_helper(setup_packet, + data, act_size, + iface->report_descriptor, + iface->report_descriptor_size); + return EOK; + } else { + return ENOENT; + } + } + + /* Let the framework handle all the rest. */ + return EFORWARD; +} + +int req_set_protocol(usbvirt_device_t *device, + const usb_device_request_setup_packet_t *setup_packet, + uint8_t *data, size_t *act_size) +{ + VUHID_DATA(vuhid, device); + + size_t iface_index = setup_packet->index; + int protocol = setup_packet->value; + + // FIXME - check ranges + vuhid_interface_t *iface = vuhid->interface_mapping[iface_index]; + if (iface == NULL) { + return ENOENT; + } + iface->set_protocol = protocol; + + return EOK; +} + +int req_set_report(usbvirt_device_t *device, + const usb_device_request_setup_packet_t *setup_packet, + uint8_t *data, size_t *act_size) +{ + VUHID_DATA(vuhid, device); + + size_t iface_index = setup_packet->index; + + // FIXME - check ranges + vuhid_interface_t *iface = vuhid->interface_mapping[iface_index]; + if (iface == NULL) { + return ENOENT; + } + + size_t data_length = setup_packet->length; + if (iface->on_data_out == NULL) { + return ENOTSUP; + } + + /* SET_REPORT is translated to data out */ + int rc = iface->on_data_out(iface, data, data_length); + + return rc; +} + + + +/** @} + */ Index: uspace/app/vuhid/stdreq.h =================================================================== --- uspace/app/vuhid/stdreq.h (revision 57c7050ac47e21d938a2a00205aa48518b743a78) +++ uspace/app/vuhid/stdreq.h (revision 57c7050ac47e21d938a2a00205aa48518b743a78) @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2011 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup usbvirthid + * @{ + */ +/** @file + * Device request handlers. + */ +#ifndef VUHID_STDREQ_H_ +#define VUHID_STDREQ_H_ + +#include + +int req_get_descriptor(usbvirt_device_t *device, + const usb_device_request_setup_packet_t *setup_packet, + uint8_t *data, size_t *act_size); + +int req_set_protocol(usbvirt_device_t *device, + const usb_device_request_setup_packet_t *setup_packet, + uint8_t *data, size_t *act_size); + +int req_set_report(usbvirt_device_t *device, + const usb_device_request_setup_packet_t *setup_packet, + uint8_t *data, size_t *act_size); + +#endif +/** + * @} + */ Index: uspace/app/vuhid/virthid.h =================================================================== --- uspace/app/vuhid/virthid.h (revision 57c7050ac47e21d938a2a00205aa48518b743a78) +++ uspace/app/vuhid/virthid.h (revision 57c7050ac47e21d938a2a00205aa48518b743a78) @@ -0,0 +1,90 @@ +/* + * Copyright (c) 2011 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup usbvirthid + * @{ + */ +/** @file + * + */ +#ifndef VUHID_VIRTHID_H_ +#define VUHID_VIRTHID_H_ + +#include +#include + +#define VUHID_ENDPOINT_MAX USB11_ENDPOINT_MAX +#define VUHID_INTERFACE_MAX 8 + +typedef struct vuhid_interface vuhid_interface_t; + +struct vuhid_interface { + const char *name; + const char *id; + int usb_subclass; + int usb_protocol; + + uint8_t *report_descriptor; + size_t report_descriptor_size; + + size_t in_data_size; + size_t out_data_size; + + int (*on_data_in)(vuhid_interface_t *, void *, size_t, size_t *); + int (*on_data_out)(vuhid_interface_t *, void *, size_t); + void (*live)(vuhid_interface_t *); + + int set_protocol; + + void *interface_data; +}; + +typedef struct { + vuhid_interface_t *in_endpoints_mapping[VUHID_ENDPOINT_MAX]; + size_t in_endpoint_first_free; + vuhid_interface_t *out_endpoints_mapping[VUHID_ENDPOINT_MAX]; + size_t out_endpoint_first_free; + vuhid_interface_t *interface_mapping[VUHID_INTERFACE_MAX]; +} vuhid_data_t; + +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; + +int add_interface_by_id(vuhid_interface_t **, const char *, usbvirt_device_t *); + +#endif +/** + * @} + */