Index: uspace/drv/root/root.c =================================================================== --- uspace/drv/root/root.c (revision 7e752b2a0d66c871748e5fa9e8bbe3a27c70a202) +++ uspace/drv/root/root.c (revision da55d5bda3670c3ce6e950da9d75291d0635e5a7) @@ -120,4 +120,58 @@ } +/** Create virtual USB host controller device. + * Note that the virtual HC is actually device and driver in one + * task. + * + * @param parent Parent device. + * @return Error code. + */ +static int add_virtual_usb_host_controller(device_t *parent) +{ + printf(NAME ": adding virtual host contoller.\n"); + + int rc; + device_t *vhc = NULL; + match_id_t *match_id = NULL; + + vhc = create_device(); + if (vhc == NULL) { + rc = ENOMEM; + goto failure; + } + + vhc->name = "vhc"; + printf(NAME ": the new device's name is %s.\n", vhc->name); + + /* Initialize match id list. */ + match_id = create_match_id(); + if (match_id == NULL) { + rc = ENOMEM; + goto failure; + } + + match_id->id = "usb&hc=vhc"; + match_id->score = 100; + add_match_id(&vhc->match_ids, match_id); + + /* Register child device. */ + rc = child_device_register(vhc, parent); + if (rc != EOK) + goto failure; + + return EOK; + +failure: + if (match_id != NULL) + match_id->id = NULL; + + if (vhc != NULL) { + vhc->name = NULL; + delete_device(vhc); + } + + return rc; +} + /** Get the root device. * @@ -135,4 +189,10 @@ printf(NAME ": failed to add child device for platform.\n"); + /* Register virtual USB host controller. */ + int rc = add_virtual_usb_host_controller(dev); + if (EOK != rc) { + printf(NAME ": failed to add child device - virtual USB HC.\n"); + } + return res; } Index: uspace/drv/uhci/Makefile =================================================================== --- uspace/drv/uhci/Makefile (revision da55d5bda3670c3ce6e950da9d75291d0635e5a7) +++ uspace/drv/uhci/Makefile (revision da55d5bda3670c3ce6e950da9d75291d0635e5a7) @@ -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 = uhci + +SOURCES = \ + main.c + +include $(USPACE_PREFIX)/Makefile.common Index: uspace/drv/uhci/main.c =================================================================== --- uspace/drv/uhci/main.c (revision da55d5bda3670c3ce6e950da9d75291d0635e5a7) +++ uspace/drv/uhci/main.c (revision da55d5bda3670c3ce6e950da9d75291d0635e5a7) @@ -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. + */ +#include +#include + +static int enqueue_transfer_out(usb_hc_device_t *hc, + usb_hcd_attached_device_info_t *dev, usb_hc_endpoint_info_t *endpoint, + void *buffer, size_t size, + usb_hcd_transfer_callback_out_t callback, void *arg) +{ + printf("UHCI: transfer OUT [%d.%d (%s); %u]\n", + dev->address, endpoint->endpoint, + usb_str_transfer_type(endpoint->transfer_type), + size); + return ENOTSUP; +} + +static int enqueue_transfer_setup(usb_hc_device_t *hc, + usb_hcd_attached_device_info_t *dev, usb_hc_endpoint_info_t *endpoint, + void *buffer, size_t size, + usb_hcd_transfer_callback_out_t callback, void *arg) +{ + printf("UHCI: transfer SETUP [%d.%d (%s); %u]\n", + dev->address, endpoint->endpoint, + usb_str_transfer_type(endpoint->transfer_type), + size); + return ENOTSUP; +} + +static int enqueue_transfer_in(usb_hc_device_t *hc, + usb_hcd_attached_device_info_t *dev, usb_hc_endpoint_info_t *endpoint, + void *buffer, size_t size, + usb_hcd_transfer_callback_in_t callback, void *arg) +{ + printf("UHCI: transfer IN [%d.%d (%s); %u]\n", + dev->address, endpoint->endpoint, + usb_str_transfer_type(endpoint->transfer_type), + size); + return ENOTSUP; +} + +static usb_hcd_transfer_ops_t uhci_transfer_ops = { + .transfer_out = enqueue_transfer_out, + .transfer_in = enqueue_transfer_in, + .transfer_setup = enqueue_transfer_setup +}; + +static int uhci_add_hc(usb_hc_device_t *device) +{ + device->transfer_ops = &uhci_transfer_ops; + + /* + * We need to announce the presence of our root hub. + * Commented out until the problem which causes the whole task to + * block is solved. + */ + //usb_hcd_add_root_hub(device); + + return EOK; +} + +usb_hc_driver_t uhci_driver = { + .name = "uhci", + .add_hc = uhci_add_hc +}; + +int main(int argc, char *argv[]) +{ + /* + * Do some global initializations. + */ + + return usb_hcd_main(&uhci_driver); +} Index: uspace/drv/uhci/uhci.ma =================================================================== --- uspace/drv/uhci/uhci.ma (revision da55d5bda3670c3ce6e950da9d75291d0635e5a7) +++ uspace/drv/uhci/uhci.ma (revision da55d5bda3670c3ce6e950da9d75291d0635e5a7) @@ -0,0 +1,3 @@ +10 pci/ven=8086&dev=7020 +10 usb&hc=uhci +10 usb&hc=uhci&hub Index: uspace/drv/usbkbd/Makefile =================================================================== --- uspace/drv/usbkbd/Makefile (revision da55d5bda3670c3ce6e950da9d75291d0635e5a7) +++ uspace/drv/usbkbd/Makefile (revision da55d5bda3670c3ce6e950da9d75291d0635e5a7) @@ -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 da55d5bda3670c3ce6e950da9d75291d0635e5a7) +++ uspace/drv/usbkbd/main.c (revision da55d5bda3670c3ce6e950da9d75291d0635e5a7) @@ -0,0 +1,120 @@ +/* + * 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 + +#define BUFFER_SIZE 32 + +/* Call this periodically to check keyboard status changes. */ +static void poll_keyboard(device_t *dev) +{ + int rc; + usb_handle_t handle; + char 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 = my_address, + .endpoint = poll_endpoint + }; + + rc = usb_drv_async_interrupt_in(dev->parent_phone, poll_target, + buffer, BUFFER_SIZE, &actual_size, &handle); + if (rc != EOK) { + return; + } + + rc = usb_drv_async_wait_for(handle); + if (rc != EOK) { + return; + } + + /* + * If the keyboard answered with NAK, it returned no data. + * This implies that no change happened since last query. + */ + if (actual_size == 0) { + return; + } + + /* + * Process pressed keys. + */ +} + +static int add_kbd_device(device_t *dev) +{ + /* For now, fail immediately. */ + return ENOTSUP; + + /* + * When everything is okay, connect to "our" HC. + */ + 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; + + /* + * Just for fun ;-). + */ + poll_keyboard(dev); + + /* + * Hurrah, device is initialized. + */ + return EOK; +} + +static driver_ops_t kbd_driver_ops = { + .add_device = add_kbd_device, +}; + +static driver_t kbd_driver = { + .name = "usbkbd", + .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 da55d5bda3670c3ce6e950da9d75291d0635e5a7) +++ uspace/drv/usbkbd/usbkbd.ma (revision da55d5bda3670c3ce6e950da9d75291d0635e5a7) @@ -0,0 +1,1 @@ +10 usb&class=hid Index: uspace/drv/vhc/Makefile =================================================================== --- uspace/drv/vhc/Makefile (revision da55d5bda3670c3ce6e950da9d75291d0635e5a7) +++ uspace/drv/vhc/Makefile (revision da55d5bda3670c3ce6e950da9d75291d0635e5a7) @@ -0,0 +1,50 @@ +# +# 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$(LIB_PREFIX) \ + -I$(LIBUSB_PREFIX)/include \ + -I$(LIBDRV_PREFIX)/include +BINARY = vhc + +SOURCES = \ + conndev.c \ + connhost.c \ + debug.c \ + devices.c \ + hc.c \ + hcd.c \ + hub.c \ + hubops.c + +include $(USPACE_PREFIX)/Makefile.common Index: uspace/drv/vhc/conn.h =================================================================== --- uspace/drv/vhc/conn.h (revision da55d5bda3670c3ce6e950da9d75291d0635e5a7) +++ uspace/drv/vhc/conn.h (revision da55d5bda3670c3ce6e950da9d75291d0635e5a7) @@ -0,0 +1,53 @@ +/* + * 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 "vhcd.h" +#include "devices.h" + +void connection_handler_host(ipcarg_t); + +usb_hcd_transfer_ops_t vhc_transfer_ops; + +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 da55d5bda3670c3ce6e950da9d75291d0635e5a7) +++ uspace/drv/vhc/conndev.c (revision da55d5bda3670c3ce6e950da9d75291d0635e5a7) @@ -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; + ipcarg_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) +{ + ipcarg_t method = IPC_GET_METHOD(*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 da55d5bda3670c3ce6e950da9d75291d0635e5a7) +++ uspace/drv/vhc/connhost.c (revision da55d5bda3670c3ce6e950da9d75291d0635e5a7) @@ -0,0 +1,173 @@ +/* + * 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 "vhcd.h" +#include "conn.h" +#include "hc.h" + +typedef struct { + usb_direction_t direction; + usb_hcd_transfer_callback_out_t out_callback; + usb_hcd_transfer_callback_in_t in_callback; + usb_hc_device_t *hc; + 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->hc, + size, outcome, + transfer->arg); + break; + case USB_DIRECTION_OUT: + transfer->out_callback(transfer->hc, + outcome, + transfer->arg); + break; + default: + assert(false && "unreachable"); + break; + } + + free(transfer); +} + +static transfer_info_t *create_transfer_info(usb_hc_device_t *hc, + 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->hc = hc; + + return transfer; +} + +static int enqueue_transfer_out(usb_hc_device_t *hc, + usb_hcd_attached_device_info_t *dev, usb_hc_endpoint_info_t *endpoint, + void *buffer, size_t size, + usb_hcd_transfer_callback_out_t callback, void *arg) +{ + printf(NAME ": transfer OUT [%d.%d (%s); %u]\n", + dev->address, endpoint->endpoint, + usb_str_transfer_type(endpoint->transfer_type), + size); + + transfer_info_t *transfer + = create_transfer_info(hc, USB_DIRECTION_OUT, arg); + transfer->out_callback = callback; + + usb_target_t target = { + .address = dev->address, + .endpoint = endpoint->endpoint + }; + + hc_add_transaction_to_device(false, target, buffer, size, + universal_callback, transfer); + + return EOK; +} + +static int enqueue_transfer_setup(usb_hc_device_t *hc, + usb_hcd_attached_device_info_t *dev, usb_hc_endpoint_info_t *endpoint, + void *buffer, size_t size, + usb_hcd_transfer_callback_out_t callback, void *arg) +{ + printf(NAME ": transfer SETUP [%d.%d (%s); %u]\n", + dev->address, endpoint->endpoint, + usb_str_transfer_type(endpoint->transfer_type), + size); + + transfer_info_t *transfer + = create_transfer_info(hc, USB_DIRECTION_OUT, arg); + transfer->out_callback = callback; + + usb_target_t target = { + .address = dev->address, + .endpoint = endpoint->endpoint + }; + + hc_add_transaction_to_device(true, target, buffer, size, + universal_callback, transfer); + + return EOK; +} + +static int enqueue_transfer_in(usb_hc_device_t *hc, + usb_hcd_attached_device_info_t *dev, usb_hc_endpoint_info_t *endpoint, + void *buffer, size_t size, + usb_hcd_transfer_callback_in_t callback, void *arg) +{ + printf(NAME ": transfer IN [%d.%d (%s); %u]\n", + dev->address, endpoint->endpoint, + usb_str_transfer_type(endpoint->transfer_type), + size); + + transfer_info_t *transfer + = create_transfer_info(hc, USB_DIRECTION_IN, arg); + transfer->in_callback = callback; + + usb_target_t target = { + .address = dev->address, + .endpoint = endpoint->endpoint + }; + + hc_add_transaction_from_device(target, buffer, size, + universal_callback, transfer); + + return EOK; +} + + +usb_hcd_transfer_ops_t vhc_transfer_ops = { + .transfer_out = enqueue_transfer_out, + .transfer_in = enqueue_transfer_in, + .transfer_setup = enqueue_transfer_setup +}; + +/** + * @} + */ Index: uspace/drv/vhc/debug.c =================================================================== --- uspace/drv/vhc/debug.c (revision da55d5bda3670c3ce6e950da9d75291d0635e5a7) +++ uspace/drv/vhc/debug.c (revision da55d5bda3670c3ce6e950da9d75291d0635e5a7) @@ -0,0 +1,78 @@ +/* + * 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 "vhcd.h" + +/** Current debug level. */ +int debug_level = 0; + +/** Debugging printf. + * This function is intended for single-line messages as it + * automatically prints debugging prefix at the beginning of the + * line. + * + * @see printf + * @param level Debugging level. + */ +void dprintf(int level, const char *format, ...) +{ + if (level > debug_level) { + return; + } + + printf("%s(%d): ", NAME, level); + va_list args; + va_start(args, format); + vprintf(format, args); + va_end(args); + printf("\n"); +} + +/** Debug print informing of invalid call. + */ +void dprintf_inval_call(int level, ipc_call_t call, ipcarg_t phone_hash) +{ + dprintf(level, "phone%#x: invalid call [%u (%u, %u, %u, %u, %u)]", + phone_hash, + IPC_GET_METHOD(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 da55d5bda3670c3ce6e950da9d75291d0635e5a7) +++ uspace/drv/vhc/devices.c (revision da55d5bda3670c3ce6e950da9d75291d0635e5a7) @@ -0,0 +1,186 @@ +/* + * 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 "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); + + hub_add_device(dev); + + return dev; +} + +/** Destroy virtual device. + */ +void virtdev_destroy_device(virtdev_connection_t *dev) +{ + hub_remove_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 (!hub_can_device_signal(dev)) { + continue; + } + + ipc_call_t answer_data; + ipcarg_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 (virthub_dev.address == transaction->target.address) { + size_t tmp; + dprintf(3, "sending `%s' transaction to hub", + usbvirt_str_transaction_type(transaction->type)); + switch (transaction->type) { + case USBVIRT_TRANSACTION_SETUP: + virthub_dev.transaction_setup(&virthub_dev, + transaction->target.endpoint, + transaction->buffer, transaction->len); + break; + + case USBVIRT_TRANSACTION_IN: + virthub_dev.transaction_in(&virthub_dev, + transaction->target.endpoint, + transaction->buffer, transaction->len, + &tmp); + if (tmp < transaction->len) { + transaction->len = tmp; + } + break; + + case USBVIRT_TRANSACTION_OUT: + virthub_dev.transaction_out(&virthub_dev, + 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 da55d5bda3670c3ce6e950da9d75291d0635e5a7) +++ uspace/drv/vhc/devices.h (revision da55d5bda3670c3ce6e950da9d75291d0635e5a7) @@ -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 da55d5bda3670c3ce6e950da9d75291d0635e5a7) +++ uspace/drv/vhc/hc.c (revision da55d5bda3670c3ce6e950da9d75291d0635e5a7) @@ -0,0 +1,186 @@ +/* + * 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 (500 * 1000) + +#define USLEEP_VAR 5000 + +#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 (%d)]" +#define TRANSACTION_PRINTF(t) \ + (t).target.address, (t).target.endpoint, \ + usbvirt_str_transaction_type((t).type), \ + (int)(t).len + +#define transaction_get_instance(lnk) \ + list_get_instance(lnk, transaction_t, link) + +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, "processing transaction " TRANSACTION_FORMAT ", 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. + */ +void hc_manager(void) +{ + 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_PORT_COUNT + 2]; + hub_get_port_statuses(ports, HUB_PORT_COUNT + 1); + dprintf(3, "virtual hub: addr=%d ports=%s", + virthub_dev.address, ports); + + link_t *first_transaction_link = transaction_list.next; + transaction_t *transaction + = transaction_get_instance(first_transaction_link); + list_remove(first_transaction_link); + + 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); + } +} + +/** Create new transaction + */ +static transaction_t *transaction_create(usbvirt_transaction_type_t type, + usb_target_t target, + 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->target = target; + transaction->buffer = buffer; + transaction->len = len; + transaction->callback = callback; + transaction->callback_arg = arg; + + dprintf(1, "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, + 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, + 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, + void * buffer, size_t len, + hc_transaction_done_callback_t callback, void * arg) +{ + transaction_t *transaction = transaction_create(USBVIRT_TRANSACTION_IN, + target, buffer, len, callback, arg); + list_append(&transaction->link, &transaction_list); +} + +/** + * @} + */ Index: uspace/drv/vhc/hc.h =================================================================== --- uspace/drv/vhc/hc.h (revision da55d5bda3670c3ce6e950da9d75291d0635e5a7) +++ uspace/drv/vhc/hc.h (revision da55d5bda3670c3ce6e950da9d75291d0635e5a7) @@ -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 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; + /** 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, + void * buffer, size_t len, + hc_transaction_done_callback_t callback, void * arg); + +void hc_add_transaction_from_device(usb_target_t target, + 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 da55d5bda3670c3ce6e950da9d75291d0635e5a7) +++ uspace/drv/vhc/hcd.c (revision da55d5bda3670c3ce6e950da9d75291d0635e5a7) @@ -0,0 +1,122 @@ +/* + * 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 int vhc_count = 0; +static int vhc_add_device(usb_hc_device_t *dev) +{ + /* + * Currently, we know how to simulate only single HC. + */ + if (vhc_count > 0) { + return ELIMIT; + } + + vhc_count++; + + dev->transfer_ops = &vhc_transfer_ops; + dev->generic->ops->default_handler = default_connection_handler; + + /* + * Initialize our hub and announce its presence. + */ + hub_init(); + usb_hcd_add_root_hub(dev); + + printf("%s: virtual USB host controller ready.\n", NAME); + + return EOK; +} + +static usb_hc_driver_t vhc_driver = { + .name = NAME, + .add_hc = &vhc_add_device +}; + +/** Fibril wrapper for HC transaction manager. + * + * @param arg Not used. + * @return Nothing, return argument is unreachable. + */ +static int hc_manager_fibril(void *arg) +{ + hc_manager(); + return EOK; +} + +int main(int argc, char * argv[]) +{ + printf("%s: virtual USB host controller driver.\n", NAME); + + debug_level = 10; + + fid_t fid = fibril_create(hc_manager_fibril, NULL); + if (fid == 0) { + printf("%s: failed to start HC manager fibril\n", NAME); + return ENOMEM; + } + fibril_add_ready(fid); + + /* + * Temporary workaround. Wait a little bit to be the last driver + * in devman output. + */ + sleep(4); + + return usb_hcd_main(&vhc_driver); +} + + +/** + * @} + */ Index: uspace/drv/vhc/hub.c =================================================================== --- uspace/drv/vhc/hub.c (revision da55d5bda3670c3ce6e950da9d75291d0635e5a7) +++ uspace/drv/vhc/hub.c (revision da55d5bda3670c3ce6e950da9d75291d0635e5a7) @@ -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 usb + * @{ + */ +/** @file + * @brief Virtual USB hub. + */ +#include +#include +#include +#include +#include + +#include "vhcd.h" +#include "hub.h" +#include "hubintern.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_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, +}; + +/** Hub as a virtual device. */ +usbvirt_device_t virthub_dev = { + .ops = &hub_ops, + .descriptors = &descriptors, + .lib_debug_level = 4, + .lib_debug_enabled_tags = USBVIRT_DEBUGTAG_ALL +}; + +/** Hub device. */ +hub_device_t hub_dev; + +/** Initialize virtual hub. */ +void hub_init(void) +{ + size_t i; + for (i = 0; i < HUB_PORT_COUNT; i++) { + hub_port_t *port = &hub_dev.ports[i]; + + port->device = NULL; + port->state = HUB_PORT_STATE_NOT_CONFIGURED; + port->status_change = 0; + } + + usbvirt_connect_local(&virthub_dev); + + dprintf(1, "virtual hub (%d ports) created", HUB_PORT_COUNT); +} + +/** Connect device to the hub. + * + * @param device Device to be connected. + * @return Port where the device was connected to. + */ +size_t hub_add_device(virtdev_connection_t *device) +{ + size_t i; + for (i = 0; i < HUB_PORT_COUNT; i++) { + hub_port_t *port = &hub_dev.ports[i]; + + if (port->device != NULL) { + continue; + } + + port->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; +} + +/** Disconnect device from the hub. */ +void hub_remove_device(virtdev_connection_t *device) +{ + size_t i; + for (i = 0; i < HUB_PORT_COUNT; i++) { + hub_port_t *port = &hub_dev.ports[i]; + + if (port->device != device) { + continue; + } + + port->device = NULL; + port->state = HUB_PORT_STATE_DISCONNECTED; + + set_port_status_change(port, HUB_STATUS_C_PORT_CONNECTION); + } +} + +/** Tell whether device port is open. + * + * @return Whether communication to and from the device can go through the hub. + */ +bool hub_can_device_signal(virtdev_connection_t * device) +{ + size_t i; + for (i = 0; i < HUB_PORT_COUNT; i++) { + if (hub_dev.ports[i].device == device) { + return hub_dev.ports[i].state == HUB_PORT_STATE_ENABLED; + } + } + + return false; +} + +/** Format hub port status. + * + * @param result Buffer where to store status string. + * @param len Number of characters that is possible to store in @p result + * (excluding trailing zero). + */ +void hub_get_port_statuses(char *result, size_t len) +{ + if (len > HUB_PORT_COUNT) { + len = HUB_PORT_COUNT; + } + size_t i; + for (i = 0; i < len; i++) { + result[i] = hub_port_state_as_char(hub_dev.ports[i].state); + } + result[len] = 0; +} + +/** + * @} + */ Index: uspace/drv/vhc/hub.h =================================================================== --- uspace/drv/vhc/hub.h (revision da55d5bda3670c3ce6e950da9d75291d0635e5a7) +++ uspace/drv/vhc/hub.h (revision da55d5bda3670c3ce6e950da9d75291d0635e5a7) @@ -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 Virtual USB hub. + */ +#ifndef VHCD_HUB_H_ +#define VHCD_HUB_H_ + +#include + +#include "devices.h" + +#define HUB_PORT_COUNT 6 + +#define BITS2BYTES(bits) \ + (bits ? ((((bits)-1)>>3)+1) : 0) + +extern usbvirt_device_t virthub_dev; + +void hub_init(void); +size_t hub_add_device(virtdev_connection_t *); +void hub_remove_device(virtdev_connection_t *); +bool hub_can_device_signal(virtdev_connection_t *); +void hub_get_port_statuses(char *result, size_t len); + +#endif +/** + * @} + */ Index: uspace/drv/vhc/hubintern.h =================================================================== --- uspace/drv/vhc/hubintern.h (revision da55d5bda3670c3ce6e950da9d75291d0635e5a7) +++ uspace/drv/vhc/hubintern.h (revision da55d5bda3670c3ce6e950da9d75291d0635e5a7) @@ -0,0 +1,145 @@ +/* + * 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 + */ +#ifndef VHCD_HUBINTERN_H_ +#define VHCD_HUBINTERN_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; + +/** 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_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; + +/** Convert hub port state to a char. */ +static inline char hub_port_state_as_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 '?'; + } +} + +/** 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 { + virtdev_connection_t *device; + hub_port_state_t state; + uint16_t status_change; +} hub_port_t; + +/** Hub device type. */ +typedef struct { + hub_port_t ports[HUB_PORT_COUNT]; +} hub_device_t; + +extern hub_device_t hub_dev; + +extern hub_descriptor_t hub_descriptor; + +extern usbvirt_device_ops_t hub_ops; + +void clear_port_status_change(hub_port_t *, uint16_t); +void set_port_status_change(hub_port_t *, uint16_t); + + +#endif +/** + * @} + */ Index: uspace/drv/vhc/hubops.c =================================================================== --- uspace/drv/vhc/hubops.c (revision da55d5bda3670c3ce6e950da9d75291d0635e5a7) +++ uspace/drv/vhc/hubops.c (revision da55d5bda3670c3ce6e950da9d75291d0635e5a7) @@ -0,0 +1,384 @@ +/* + * 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 +#include +#include + +#include "vhcd.h" +#include "hub.h" +#include "hubintern.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 int on_get_descriptor(struct usbvirt_device *dev, + usb_device_request_setup_packet_t *request, uint8_t *data); +static int on_class_request(struct usbvirt_device *dev, + usb_device_request_setup_packet_t *request, uint8_t *data); +static int on_data_request(struct usbvirt_device *dev, + usb_endpoint_t endpoint, + void *buffer, size_t size, size_t *actual_size); + +/** Standard USB requests. */ +static usbvirt_standard_device_request_ops_t standard_request_ops = { + .on_get_status = NULL, + .on_clear_feature = NULL, + .on_set_feature = NULL, + .on_set_address = NULL, + .on_get_descriptor = on_get_descriptor, + .on_set_descriptor = NULL, + .on_get_configuration = NULL, + .on_set_configuration = NULL, + .on_get_interface = NULL, + .on_set_interface = NULL, + .on_synch_frame = NULL +}; + +/** Hub operations. */ +usbvirt_device_ops_t hub_ops = { + .standard_request_ops = &standard_request_ops, + .on_class_device_request = on_class_request, + .on_data = NULL, + .on_data_request = on_data_request +}; + +/** Callback for GET_DESCRIPTOR request. */ +static int on_get_descriptor(struct usbvirt_device *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; +} + +/** Change port status and updates status change status fields. + */ +static void set_port_state(hub_port_t *port, hub_port_state_t state) +{ + port->state = state; + if (state == 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); + } + if (state == HUB_PORT_STATE_RESUMING) { + async_usleep(10*1000); + if (port->state == state) { + set_port_state(port, HUB_PORT_STATE_ENABLED); + } + } + if (state == HUB_PORT_STATE_RESETTING) { + async_usleep(10*1000); + if (port->state == state) { + set_port_status_change(port, HUB_STATUS_C_PORT_RESET); + set_port_state(port, HUB_PORT_STATE_ENABLED); + } + } +} + +/** Get access to a port or return with EINVAL. */ +#define _GET_PORT(portvar, index) \ + do { \ + if (virthub_dev.state != USBVIRT_STATE_CONFIGURED) { \ + return EINVAL; \ + } \ + if (((index) == 0) || ((index) > HUB_PORT_COUNT)) { \ + return EINVAL; \ + } \ + } while (false); \ + hub_port_t *portvar = &hub_dev.ports[index] + + +static int clear_hub_feature(uint16_t feature) +{ + return ENOTSUP; +} + +static int clear_port_feature(uint16_t feature, uint16_t portindex) +{ + _GET_PORT(port, portindex); + + switch (feature) { + case USB_HUB_FEATURE_PORT_ENABLE: + if ((port->state != HUB_PORT_STATE_NOT_CONFIGURED) + && (port->state != HUB_PORT_STATE_POWERED_OFF)) { + set_port_state(port, HUB_PORT_STATE_DISABLED); + } + return EOK; + + case USB_HUB_FEATURE_PORT_SUSPEND: + if (port->state != HUB_PORT_STATE_SUSPENDED) { + return EOK; + } + set_port_state(port, HUB_PORT_STATE_RESUMING); + return EOK; + + case USB_HUB_FEATURE_PORT_POWER: + if (port->state != HUB_PORT_STATE_NOT_CONFIGURED) { + set_port_state(port, HUB_PORT_STATE_POWERED_OFF); + } + return EOK; + + case USB_HUB_FEATURE_C_PORT_CONNECTION: + clear_port_status_change(port, HUB_STATUS_C_PORT_CONNECTION); + return EOK; + + case USB_HUB_FEATURE_C_PORT_ENABLE: + clear_port_status_change(port, HUB_STATUS_C_PORT_ENABLE); + return EOK; + + case USB_HUB_FEATURE_C_PORT_SUSPEND: + clear_port_status_change(port, HUB_STATUS_C_PORT_SUSPEND); + return EOK; + + case USB_HUB_FEATURE_C_PORT_OVER_CURRENT: + clear_port_status_change(port, HUB_STATUS_C_PORT_OVER_CURRENT); + return EOK; + } + + return ENOTSUP; +} + +static int get_bus_state(uint16_t portindex) +{ + return ENOTSUP; +} + +static int get_hub_descriptor(uint8_t descriptor_type, + uint8_t descriptor_index, uint16_t length) +{ + return ENOTSUP; +} + +static int get_hub_status(void) +{ + uint32_t hub_status = 0; + + return virthub_dev.control_transfer_reply(&virthub_dev, 0, + &hub_status, 4); +} + +static int get_port_status(uint16_t portindex) +{ + _GET_PORT(port, portindex); + + uint32_t status; + status = MAKE_BYTE( + /* Current connect status. */ + port->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 virthub_dev.control_transfer_reply(&virthub_dev, 0, &status, 4); +} + + +static int set_hub_feature(uint16_t feature) +{ + return ENOTSUP; +} + +static int set_port_feature(uint16_t feature, uint16_t portindex) +{ + _GET_PORT(port, portindex); + + switch (feature) { + case USB_HUB_FEATURE_PORT_RESET: + if (port->state != HUB_PORT_STATE_POWERED_OFF) { + set_port_state(port, HUB_PORT_STATE_RESETTING); + } + return EOK; + + case USB_HUB_FEATURE_PORT_SUSPEND: + if (port->state == HUB_PORT_STATE_ENABLED) { + set_port_state(port, HUB_PORT_STATE_SUSPENDED); + } + return EOK; + + case USB_HUB_FEATURE_PORT_POWER: + if (port->state == HUB_PORT_STATE_POWERED_OFF) { + set_port_state(port, HUB_PORT_STATE_DISCONNECTED); + } + return EOK; + } + return ENOTSUP; +} + +#undef _GET_PORT + + +/** Callback for class request. */ +static int on_class_request(struct usbvirt_device *dev, + usb_device_request_setup_packet_t *request, uint8_t *data) +{ + dprintf(2, "hub class request (%d)\n", (int) request->request); + + uint8_t recipient = request->request_type & 31; + uint8_t direction = request->request_type >> 7; + +#define _VERIFY(cond) \ + do { \ + if (!(cond)) { \ + dprintf(0, "WARN: invalid class request (%s not met).\n", \ + NAME, #cond); \ + return EINVAL; \ + } \ + } while (0) + + switch (request->request) { + case USB_HUB_REQUEST_CLEAR_FEATURE: + _VERIFY(direction == 0); + _VERIFY(request->length == 0); + if (recipient == 0) { + _VERIFY(request->index == 0); + return clear_hub_feature(request->value); + } else { + _VERIFY(recipient == 3); + return clear_port_feature(request->value, + request->index); + } + + case USB_HUB_REQUEST_GET_STATE: + return get_bus_state(request->index); + + case USB_HUB_REQUEST_GET_DESCRIPTOR: + return get_hub_descriptor(request->value_low, + request->value_high, request->length); + + case USB_HUB_REQUEST_GET_STATUS: + if (recipient == 0) { + return get_hub_status(); + } else { + return get_port_status(request->index); + } + + case USB_HUB_REQUEST_SET_FEATURE: + if (recipient == 0) { + return set_hub_feature(request->value); + } else { + return set_port_feature(request->value, request->index); + } + + default: + break; + } + +#undef _VERIFY + + + return EOK; +} + +void clear_port_status_change(hub_port_t *port, uint16_t change) +{ + port->status_change &= (~change); +} + +void set_port_status_change(hub_port_t *port, uint16_t change) +{ + port->status_change |= change; +} + +/** Callback for data request. */ +static int on_data_request(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; + } + + uint8_t change_map = 0; + + size_t i; + for (i = 0; i < HUB_PORT_COUNT; i++) { + hub_port_t *port = &hub_dev.ports[i]; + + if (port->status_change != 0) { + change_map |= (1 << (i + 1)); + } + } + + uint8_t *b = (uint8_t *) buffer; + if (size > 0) { + *b = change_map; + *actual_size = 1; + } + + return EOK; +} + + +/** + * @} + */ Index: uspace/drv/vhc/vhc.ma =================================================================== --- uspace/drv/vhc/vhc.ma (revision da55d5bda3670c3ce6e950da9d75291d0635e5a7) +++ uspace/drv/vhc/vhc.ma (revision da55d5bda3670c3ce6e950da9d75291d0635e5a7) @@ -0,0 +1,2 @@ +10 usb&hc=vhc +10 usb&hc=vhc&hub Index: uspace/drv/vhc/vhcd.h =================================================================== --- uspace/drv/vhc/vhcd.h (revision da55d5bda3670c3ce6e950da9d75291d0635e5a7) +++ uspace/drv/vhc/vhcd.h (revision da55d5bda3670c3ce6e950da9d75291d0635e5a7) @@ -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 host controller common definitions. + */ +#ifndef VHCD_VHCD_H_ +#define VHCD_VHCD_H_ + +#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 + +extern int debug_level; +void dprintf(int, const char *, ...); +void dprintf_inval_call(int, ipc_call_t, ipcarg_t); + +#endif +/** + * @} + */