Index: uspace/lib/usb/src/altiface.c =================================================================== --- uspace/lib/usb/src/altiface.c (revision e50cd7f06f4f69de26916ce998bb262dbcd8bec0) +++ uspace/lib/usb/src/altiface.c (revision e50cd7f06f4f69de26916ce998bb262dbcd8bec0) @@ -0,0 +1,181 @@ +/* + * 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 libusb + * @{ + */ +/** @file + * Handling alternate interface settings. + */ +#include +#include +#include +#include +#include +#include +#include + +/** Count number of alternate settings of a interface. + * + * @param config_descr Full configuration descriptor. + * @param config_descr_size Size of @p config_descr in bytes. + * @param interface_no Interface number. + * @return Number of alternate interfaces for @p interface_no interface. + */ +size_t usb_interface_count_alternates(uint8_t *config_descr, + size_t config_descr_size, uint8_t interface_no) +{ + assert(config_descr != NULL); + assert(config_descr_size > 0); + + usb_dp_parser_t dp_parser = { + .nesting = usb_dp_standard_descriptor_nesting + }; + usb_dp_parser_data_t dp_data = { + .data = config_descr, + .size = config_descr_size, + .arg = NULL + }; + + size_t alternate_count = 0; + + uint8_t *iface_ptr = usb_dp_get_nested_descriptor(&dp_parser, + &dp_data, config_descr); + while (iface_ptr != NULL) { + usb_standard_interface_descriptor_t *iface + = (usb_standard_interface_descriptor_t *) iface_ptr; + if (iface->descriptor_type == USB_DESCTYPE_INTERFACE) { + if (iface->interface_number == interface_no) { + alternate_count++; + } + } + iface_ptr = usb_dp_get_sibling_descriptor(&dp_parser, &dp_data, + config_descr, iface_ptr); + } + + return alternate_count; +} + +/** Create alternate interface representation structure. + * + * @param[in] config_descr Configuration descriptor. + * @param[in] config_descr_size Size of configuration descriptor. + * @param[in] interface_number Interface number. + * @param[out] alternates_ptr Where to store pointer to allocated structure. + * @return Error code. + */ +int usb_alternate_interfaces_create(uint8_t *config_descr, + size_t config_descr_size, int interface_number, + usb_alternate_interfaces_t **alternates_ptr) +{ + assert(alternates_ptr != NULL); + assert(config_descr != NULL); + assert(config_descr_size > 0); + + if (interface_number < 0) { + alternates_ptr = NULL; + return EOK; + } + + usb_alternate_interfaces_t *alternates + = malloc(sizeof(usb_alternate_interfaces_t)); + + if (alternates == NULL) { + return ENOMEM; + } + + alternates->alternative_count + = usb_interface_count_alternates(config_descr, config_descr_size, + interface_number); + + if (alternates->alternative_count == 0) { + free(alternates); + return ENOENT; + } + + alternates->alternatives = malloc(alternates->alternative_count + * sizeof(usb_alternate_interface_descriptors_t)); + if (alternates->alternatives == NULL) { + free(alternates); + return ENOMEM; + } + + alternates->current = 0; + + usb_dp_parser_t dp_parser = { + .nesting = usb_dp_standard_descriptor_nesting + }; + usb_dp_parser_data_t dp_data = { + .data = config_descr, + .size = config_descr_size, + .arg = NULL + }; + + usb_alternate_interface_descriptors_t *cur_alt_iface + = &alternates->alternatives[0]; + + uint8_t *iface_ptr = usb_dp_get_nested_descriptor(&dp_parser, + &dp_data, dp_data.data); + while (iface_ptr != NULL) { + usb_standard_interface_descriptor_t *iface + = (usb_standard_interface_descriptor_t *) iface_ptr; + if ((iface->descriptor_type != USB_DESCTYPE_INTERFACE) + || (iface->interface_number != interface_number)) { + iface_ptr = usb_dp_get_sibling_descriptor(&dp_parser, + &dp_data, + dp_data.data, iface_ptr); + continue; + } + + cur_alt_iface->interface = iface; + cur_alt_iface->nested_descriptors = iface_ptr + sizeof(*iface); + + /* Find next interface to count size of nested descriptors. */ + iface_ptr = usb_dp_get_sibling_descriptor(&dp_parser, &dp_data, + dp_data.data, iface_ptr); + if (iface_ptr == NULL) { + uint8_t *next = dp_data.data + dp_data.size; + cur_alt_iface->nested_descriptors_size + = next - cur_alt_iface->nested_descriptors; + } else { + cur_alt_iface->nested_descriptors_size + = iface_ptr - cur_alt_iface->nested_descriptors; + } + + cur_alt_iface++; + } + + *alternates_ptr = alternates; + + return EOK; +} + + +/** + * @} + */ Index: uspace/lib/usb/src/devdrv.c =================================================================== --- uspace/lib/usb/src/devdrv.c (revision ef354b6778a2049a1546b354af20cf92410bf74c) +++ uspace/lib/usb/src/devdrv.c (revision e50cd7f06f4f69de26916ce998bb262dbcd8bec0) @@ -72,14 +72,4 @@ } -/** Log out of memory error on given device. - * - * @param dev Device causing the trouble. - */ -static void usb_log_oom(ddf_dev_t *dev) -{ - usb_log_error("Out of memory when adding device `%s'.\n", - dev->name); -} - /** Count number of pipes the driver expects. * @@ -108,300 +98,26 @@ */ static int initialize_other_pipes(usb_endpoint_description_t **endpoints, - usb_device_t *dev) -{ - int rc; - - size_t pipe_count = count_other_pipes(endpoints); - if (pipe_count == 0) { + usb_device_t *dev, int alternate_setting) +{ + if (endpoints == NULL) { + dev->pipes = NULL; + dev->pipes_count = 0; return EOK; } - dev->pipes = malloc(sizeof(usb_endpoint_mapping_t) * pipe_count); - if (dev->pipes == NULL) { - usb_log_oom(dev->ddf_dev); - return ENOMEM; - } - - size_t i; - - /* Initialize to NULL first for rollback purposes. */ - for (i = 0; i < pipe_count; i++) { - dev->pipes[i].pipe = NULL; - } - - for (i = 0; i < pipe_count; i++) { - dev->pipes[i].pipe = malloc(sizeof(usb_pipe_t)); - if (dev->pipes[i].pipe == NULL) { - usb_log_oom(dev->ddf_dev); - rc = ENOMEM; - goto rollback; - } - - dev->pipes[i].description = endpoints[i]; - dev->pipes[i].interface_no = dev->interface_no; - dev->pipes[i].interface_setting = 0; - } - - rc = usb_pipe_initialize_from_configuration(dev->pipes, pipe_count, + usb_endpoint_mapping_t *pipes; + size_t pipes_count; + + int rc = usb_device_create_pipes(dev->ddf_dev, &dev->wire, endpoints, dev->descriptors.configuration, dev->descriptors.configuration_size, - &dev->wire); - if (rc != EOK) { - usb_log_error("Failed initializing USB endpoints: %s.\n", - str_error(rc)); - goto rollback; - } - - /* Register the endpoints. */ - usb_hc_connection_t hc_conn; - rc = usb_hc_connection_initialize_from_device(&hc_conn, dev->ddf_dev); - if (rc != EOK) { - usb_log_error( - "Failed initializing connection to host controller: %s.\n", - str_error(rc)); - goto rollback; - } - rc = usb_hc_connection_open(&hc_conn); - if (rc != EOK) { - usb_log_error("Failed to connect to host controller: %s.\n", - str_error(rc)); - goto rollback; - } - for (i = 0; i < pipe_count; i++) { - if (dev->pipes[i].present) { - rc = usb_pipe_register(dev->pipes[i].pipe, - dev->pipes[i].descriptor->poll_interval, - &hc_conn); - /* Ignore error when operation not supported by HC. */ - if ((rc != EOK) && (rc != ENOTSUP)) { - /* FIXME: what shall we do? */ - dev->pipes[i].present = false; - free(dev->pipes[i].pipe); - dev->pipes[i].pipe = NULL; - } - } - } - /* Ignoring errors here. */ - usb_hc_connection_close(&hc_conn); - - dev->pipes_count = pipe_count; - - return EOK; - -rollback: - for (i = 0; i < pipe_count; i++) { - if (dev->pipes[i].pipe != NULL) { - free(dev->pipes[i].pipe); - } - } - free(dev->pipes); - - return rc; -} - -/** Initialize all endpoint pipes. - * - * @param drv The driver. - * @param dev The device to be initialized. - * @return Error code. - */ -static int initialize_pipes(usb_device_t *dev) -{ - int rc; - - rc = usb_device_connection_initialize_from_device(&dev->wire, - dev->ddf_dev); - if (rc != EOK) { - usb_log_error( - "Failed initializing connection on device `%s'. %s.\n", - dev->ddf_dev->name, str_error(rc)); - return rc; - } - - rc = usb_pipe_initialize_default_control(&dev->ctrl_pipe, - &dev->wire); - if (rc != EOK) { - usb_log_error("Failed to initialize default control pipe " \ - "on device `%s': %s.\n", - dev->ddf_dev->name, str_error(rc)); - return rc; - } - - rc = usb_pipe_probe_default_control(&dev->ctrl_pipe); - if (rc != EOK) { - usb_log_error( - "Probing default control pipe on device `%s' failed: %s.\n", - dev->ddf_dev->name, str_error(rc)); - return rc; - } - - /* Get our interface. */ - dev->interface_no = usb_device_get_assigned_interface(dev->ddf_dev); - - /* - * For further actions, we need open session on default control pipe. - */ - rc = usb_pipe_start_session(&dev->ctrl_pipe); - if (rc != EOK) { - usb_log_error("Failed to start an IPC session: %s.\n", - str_error(rc)); - return rc; - } - - /* Get the device descriptor. */ - rc = usb_request_get_device_descriptor(&dev->ctrl_pipe, - &dev->descriptors.device); - if (rc != EOK) { - usb_log_error("Failed to retrieve device descriptor: %s.\n", - str_error(rc)); - return rc; - } - - /* Get the full configuration descriptor. */ - rc = usb_request_get_full_configuration_descriptor_alloc( - &dev->ctrl_pipe, 0, (void **) &dev->descriptors.configuration, - &dev->descriptors.configuration_size); - if (rc != EOK) { - usb_log_error("Failed retrieving configuration descriptor: %s. %s\n", - dev->ddf_dev->name, str_error(rc)); - return rc; - } - - if (driver->endpoints != NULL) { - rc = initialize_other_pipes(driver->endpoints, dev); - } - - /* No checking here. */ - usb_pipe_end_session(&dev->ctrl_pipe); - - /* Rollback actions. */ - if (rc != EOK) { - if (dev->descriptors.configuration != NULL) { - free(dev->descriptors.configuration); - } - } - - return rc; -} - -/** Count number of alternate settings of a interface. - * - * @param config_descr Full configuration descriptor. - * @param config_descr_size Size of @p config_descr in bytes. - * @param interface_no Interface number. - * @return Number of alternate interfaces for @p interface_no interface. - */ -static size_t count_alternate_interfaces(uint8_t *config_descr, - size_t config_descr_size, int interface_no) -{ - assert(config_descr != NULL); - usb_dp_parser_t dp_parser = { - .nesting = usb_dp_standard_descriptor_nesting - }; - usb_dp_parser_data_t dp_data = { - .data = config_descr, - .size = config_descr_size, - .arg = NULL - }; - - size_t alternate_count = 0; - - uint8_t *iface_ptr = usb_dp_get_nested_descriptor(&dp_parser, - &dp_data, config_descr); - while (iface_ptr != NULL) { - usb_standard_interface_descriptor_t *iface - = (usb_standard_interface_descriptor_t *) iface_ptr; - if (iface->descriptor_type == USB_DESCTYPE_INTERFACE) { - if (iface->interface_number == interface_no) { - alternate_count++; - } - } - iface_ptr = usb_dp_get_sibling_descriptor(&dp_parser, &dp_data, - config_descr, iface_ptr); - } - - return alternate_count; -} - -/** Initialize structures related to alternate interfaces. - * - * @param dev Device where alternate settings shall be initialized. - * @return Error code. - */ -static int initialize_alternate_interfaces(usb_device_t *dev) -{ - if (dev->interface_no < 0) { - dev->alternate_interfaces = NULL; - return EOK; - } - - usb_alternate_interfaces_t *alternates - = malloc(sizeof(usb_alternate_interfaces_t)); - - if (alternates == NULL) { - return ENOMEM; - } - - alternates->alternative_count - = count_alternate_interfaces(dev->descriptors.configuration, - dev->descriptors.configuration_size, dev->interface_no); - - if (alternates->alternative_count == 0) { - free(alternates); - return ENOENT; - } - - alternates->alternatives = malloc(alternates->alternative_count - * sizeof(usb_alternate_interface_descriptors_t)); - if (alternates->alternatives == NULL) { - free(alternates); - return ENOMEM; - } - - alternates->current = 0; - - usb_dp_parser_t dp_parser = { - .nesting = usb_dp_standard_descriptor_nesting - }; - usb_dp_parser_data_t dp_data = { - .data = dev->descriptors.configuration, - .size = dev->descriptors.configuration_size, - .arg = NULL - }; - - usb_alternate_interface_descriptors_t *cur_alt_iface - = &alternates->alternatives[0]; - - uint8_t *iface_ptr = usb_dp_get_nested_descriptor(&dp_parser, - &dp_data, dp_data.data); - while (iface_ptr != NULL) { - usb_standard_interface_descriptor_t *iface - = (usb_standard_interface_descriptor_t *) iface_ptr; - if ((iface->descriptor_type != USB_DESCTYPE_INTERFACE) - || (iface->interface_number != dev->interface_no)) { - iface_ptr = usb_dp_get_sibling_descriptor(&dp_parser, - &dp_data, - dp_data.data, iface_ptr); - continue; - } - - cur_alt_iface->interface = iface; - cur_alt_iface->nested_descriptors = iface_ptr + sizeof(*iface); - - /* Find next interface to count size of nested descriptors. */ - iface_ptr = usb_dp_get_sibling_descriptor(&dp_parser, &dp_data, - dp_data.data, iface_ptr); - if (iface_ptr == NULL) { - uint8_t *next = dp_data.data + dp_data.size; - cur_alt_iface->nested_descriptors_size - = next - cur_alt_iface->nested_descriptors; - } else { - cur_alt_iface->nested_descriptors_size - = iface_ptr - cur_alt_iface->nested_descriptors; - } - - cur_alt_iface++; - } - - dev->alternate_interfaces = alternates; + dev->interface_no, alternate_setting, + &pipes, &pipes_count); + + if (rc != EOK) { + return rc; + } + + dev->pipes = pipes; + dev->pipes_count = pipes_count; return EOK; @@ -423,27 +139,12 @@ int rc; - usb_device_t *dev = malloc(sizeof(usb_device_t)); - if (dev == NULL) { - usb_log_error("Out of memory when adding device `%s'.\n", - gen_dev->name); - return ENOMEM; - } - - - dev->ddf_dev = gen_dev; - dev->ddf_dev->driver_data = dev; - dev->driver_data = NULL; - dev->descriptors.configuration = NULL; - - dev->pipes_count = 0; - dev->pipes = NULL; - - rc = initialize_pipes(dev); - if (rc != EOK) { - free(dev); - return rc; - } - - (void) initialize_alternate_interfaces(dev); + usb_device_t *dev = NULL; + const char *err_msg = NULL; + rc = usb_device_create(gen_dev, driver->endpoints, &dev, &err_msg); + if (rc != EOK) { + usb_log_error("USB device `%s' creation failed (%s): %s.\n", + gen_dev->name, err_msg, str_error(rc)); + return rc; + } return driver->ops->add_device(dev); @@ -457,36 +158,10 @@ static int destroy_current_pipes(usb_device_t *dev) { - size_t i; - int rc; - - /* TODO: this shall be done under some device mutex. */ - - /* First check that no session is opened. */ - for (i = 0; i < dev->pipes_count; i++) { - if (usb_pipe_is_session_started(dev->pipes[i].pipe)) { - return EBUSY; - } - } - - /* Prepare connection to HC. */ - usb_hc_connection_t hc_conn; - rc = usb_hc_connection_initialize_from_device(&hc_conn, dev->ddf_dev); - if (rc != EOK) { - return rc; - } - rc = usb_hc_connection_open(&hc_conn); - if (rc != EOK) { - return rc; - } - - /* Destroy the pipes. */ - for (i = 0; i < dev->pipes_count; i++) { - usb_pipe_unregister(dev->pipes[i].pipe, &hc_conn); - free(dev->pipes[i].pipe); - } - - usb_hc_connection_close(&hc_conn); - - free(dev->pipes); + int rc = usb_device_destroy_pipes(dev->ddf_dev, + dev->pipes, dev->pipes_count); + if (rc != EOK) { + return rc; + } + dev->pipes = NULL; dev->pipes_count = 0; @@ -505,4 +180,11 @@ * with usb_pipe_initialize_from_configuration(). * + * @warning This is a wrapper function that does several operations that + * can fail and that cannot be rollbacked easily. That means that a failure + * during the SET_INTERFACE request would result in having a device with + * no pipes at all (except the default control one). That is because the old + * pipes needs to be unregistered at HC first and the new ones could not + * be created. + * * @param dev USB device. * @param alternate_setting Alternate setting to choose. @@ -519,6 +201,4 @@ int rc; - /* TODO: more transactional behavior. */ - /* Destroy existing pipes. */ rc = destroy_current_pipes(dev); @@ -535,7 +215,323 @@ /* Create new pipes. */ - rc = initialize_other_pipes(endpoints, dev); + rc = initialize_other_pipes(endpoints, dev, (int) alternate_setting); return rc; +} + +/** Retrieve basic descriptors from the device. + * + * @param[in] ctrl_pipe Control endpoint pipe. + * @param[out] descriptors Where to store the descriptors. + * @return Error code. + */ +int usb_device_retrieve_descriptors(usb_pipe_t *ctrl_pipe, + usb_device_descriptors_t *descriptors) +{ + assert(descriptors != NULL); + + descriptors->configuration = NULL; + + int rc; + + /* It is worth to start a long transfer. */ + rc = usb_pipe_start_long_transfer(ctrl_pipe); + if (rc != EOK) { + return rc; + } + + /* Get the device descriptor. */ + rc = usb_request_get_device_descriptor(ctrl_pipe, &descriptors->device); + if (rc != EOK) { + goto leave; + } + + /* Get the full configuration descriptor. */ + rc = usb_request_get_full_configuration_descriptor_alloc( + ctrl_pipe, 0, (void **) &descriptors->configuration, + &descriptors->configuration_size); + +leave: + usb_pipe_end_long_transfer(ctrl_pipe); + + return rc; +} + +/** Create pipes for a device. + * + * This is more or less a wrapper that does following actions: + * - allocate and initialize pipes + * - map endpoints to the pipes based on the descriptions + * - registers endpoints with the host controller + * + * @param[in] dev Generic DDF device backing the USB one. + * @param[in] wire Initialized backing connection to the host controller. + * @param[in] endpoints Endpoints description, NULL terminated. + * @param[in] config_descr Configuration descriptor of active configuration. + * @param[in] config_descr_size Size of @p config_descr in bytes. + * @param[in] interface_no Interface to map from. + * @param[in] interface_setting Interface setting (default is usually 0). + * @param[out] pipes_ptr Where to store array of created pipes + * (not NULL terminated). + * @param[out] pipes_count_ptr Where to store number of pipes + * (set to if you wish to ignore the count). + * @return Error code. + */ +int usb_device_create_pipes(ddf_dev_t *dev, usb_device_connection_t *wire, + usb_endpoint_description_t **endpoints, + uint8_t *config_descr, size_t config_descr_size, + int interface_no, int interface_setting, + usb_endpoint_mapping_t **pipes_ptr, size_t *pipes_count_ptr) +{ + assert(dev != NULL); + assert(wire != NULL); + assert(endpoints != NULL); + assert(config_descr != NULL); + assert(config_descr_size > 0); + assert(pipes_ptr != NULL); + + size_t i; + int rc; + + size_t pipe_count = count_other_pipes(endpoints); + if (pipe_count == 0) { + *pipes_ptr = NULL; + return EOK; + } + + usb_endpoint_mapping_t *pipes + = malloc(sizeof(usb_endpoint_mapping_t) * pipe_count); + if (pipes == NULL) { + return ENOMEM; + } + + /* Initialize to NULL to allow smooth rollback. */ + for (i = 0; i < pipe_count; i++) { + pipes[i].pipe = NULL; + } + + /* Now allocate and fully initialize. */ + for (i = 0; i < pipe_count; i++) { + pipes[i].pipe = malloc(sizeof(usb_pipe_t)); + if (pipes[i].pipe == NULL) { + rc = ENOMEM; + goto rollback_free_only; + } + pipes[i].description = endpoints[i]; + pipes[i].interface_no = interface_no; + pipes[i].interface_setting = interface_setting; + } + + /* Find the mapping from configuration descriptor. */ + rc = usb_pipe_initialize_from_configuration(pipes, pipe_count, + config_descr, config_descr_size, wire); + if (rc != EOK) { + goto rollback_free_only; + } + + /* Register the endpoints with HC. */ + usb_hc_connection_t hc_conn; + rc = usb_hc_connection_initialize_from_device(&hc_conn, dev); + if (rc != EOK) { + goto rollback_free_only; + } + + rc = usb_hc_connection_open(&hc_conn); + if (rc != EOK) { + goto rollback_free_only; + } + + for (i = 0; i < pipe_count; i++) { + if (pipes[i].present) { + rc = usb_pipe_register(pipes[i].pipe, + pipes[i].descriptor->poll_interval, &hc_conn); + if (rc != EOK) { + goto rollback_unregister_endpoints; + } + } + } + + usb_hc_connection_close(&hc_conn); + + *pipes_ptr = pipes; + if (pipes_count_ptr != NULL) { + *pipes_count_ptr = pipe_count; + } + + return EOK; + + /* + * Jump here if something went wrong after endpoints have + * been registered. + * This is also the target when the registration of + * endpoints fails. + */ +rollback_unregister_endpoints: + for (i = 0; i < pipe_count; i++) { + if (pipes[i].present) { + usb_pipe_unregister(pipes[i].pipe, &hc_conn); + } + } + + usb_hc_connection_close(&hc_conn); + + /* + * Jump here if something went wrong before some actual communication + * with HC. Then the only thing that needs to be done is to free + * allocated memory. + */ +rollback_free_only: + for (i = 0; i < pipe_count; i++) { + if (pipes[i].pipe != NULL) { + free(pipes[i].pipe); + } + } + free(pipes); + + return rc; +} + +/** Destroy pipes previously created by usb_device_create_pipes. + * + * @param[in] dev Generic DDF device backing the USB one. + * @param[in] pipes Endpoint mapping to be destroyed. + * @param[in] pipes_count Number of endpoints. + */ +int usb_device_destroy_pipes(ddf_dev_t *dev, + usb_endpoint_mapping_t *pipes, size_t pipes_count) +{ + assert(dev != NULL); + assert(((pipes != NULL) && (pipes_count > 0)) + || ((pipes == NULL) && (pipes_count == 0))); + + if (pipes_count == 0) { + return EOK; + } + + int rc; + + /* Prepare connection to HC to allow endpoint unregistering. */ + usb_hc_connection_t hc_conn; + rc = usb_hc_connection_initialize_from_device(&hc_conn, dev); + if (rc != EOK) { + return rc; + } + rc = usb_hc_connection_open(&hc_conn); + if (rc != EOK) { + return rc; + } + + /* Destroy the pipes. */ + size_t i; + for (i = 0; i < pipes_count; i++) { + usb_pipe_unregister(pipes[i].pipe, &hc_conn); + free(pipes[i].pipe); + } + + usb_hc_connection_close(&hc_conn); + + free(pipes); + + return EOK; +} + +/** Initialize control pipe in a device. + * + * @param dev USB device in question. + * @param errmsg Where to store error context. + * @return + */ +static int init_wire_and_ctrl_pipe(usb_device_t *dev, const char **errmsg) +{ + int rc; + + rc = usb_device_connection_initialize_from_device(&dev->wire, + dev->ddf_dev); + if (rc != EOK) { + *errmsg = "device connection initialization"; + return rc; + } + + rc = usb_pipe_initialize_default_control(&dev->ctrl_pipe, + &dev->wire); + if (rc != EOK) { + *errmsg = "default control pipe initialization"; + return rc; + } + + return EOK; +} + + +/** Create new instance of USB device. + * + * @param[in] ddf_dev Generic DDF device backing the USB one. + * @param[in] endpoints NULL terminated array of endpoints (NULL for none). + * @param[out] dev_ptr Where to store pointer to the new device. + * @param[out] errstr_ptr Where to store description of context + * (in case error occurs). + * @return Error code. + */ +int usb_device_create(ddf_dev_t *ddf_dev, + usb_endpoint_description_t **endpoints, + usb_device_t **dev_ptr, const char **errstr_ptr) +{ + assert(dev_ptr != NULL); + assert(ddf_dev != NULL); + + int rc; + + usb_device_t *dev = malloc(sizeof(usb_device_t)); + if (dev == NULL) { + *errstr_ptr = "structure allocation"; + return ENOMEM; + } + + // FIXME: proper deallocation in case of errors + + dev->ddf_dev = ddf_dev; + dev->driver_data = NULL; + dev->descriptors.configuration = NULL; + dev->alternate_interfaces = NULL; + + dev->pipes_count = 0; + dev->pipes = NULL; + + /* Initialize backing wire and control pipe. */ + rc = init_wire_and_ctrl_pipe(dev, errstr_ptr); + if (rc != EOK) { + return rc; + } + + /* Get our interface. */ + dev->interface_no = usb_device_get_assigned_interface(dev->ddf_dev); + + /* Retrieve standard descriptors. */ + rc = usb_device_retrieve_descriptors(&dev->ctrl_pipe, + &dev->descriptors); + if (rc != EOK) { + *errstr_ptr = "descriptor retrieval"; + return rc; + } + + /* Create alternate interfaces. */ + rc = usb_alternate_interfaces_create(dev->descriptors.configuration, + dev->descriptors.configuration_size, dev->interface_no, + &dev->alternate_interfaces); + if (rc != EOK) { + /* We will try to silently ignore this. */ + dev->alternate_interfaces = NULL; + } + + rc = initialize_other_pipes(endpoints, dev, 0); + if (rc != EOK) { + *errstr_ptr = "pipes initialization"; + return rc; + } + + *errstr_ptr = NULL; + *dev_ptr = dev; + + return EOK; } Index: uspace/lib/usb/src/devpoll.c =================================================================== --- uspace/lib/usb/src/devpoll.c (revision ef354b6778a2049a1546b354af20cf92410bf74c) +++ uspace/lib/usb/src/devpoll.c (revision e50cd7f06f4f69de26916ce998bb262dbcd8bec0) @@ -33,7 +33,8 @@ * USB device driver framework - automatic interrupt polling. */ -#include +#include #include #include +#include #include #include @@ -45,8 +46,14 @@ /** Data needed for polling. */ typedef struct { + int debug; + size_t max_failures; + useconds_t delay; + bool auto_clear_halt; + bool (*on_data)(usb_device_t *, uint8_t *, size_t, void *); + void (*on_polling_end)(usb_device_t *, bool, void *); + bool (*on_error)(usb_device_t *, int, void *); + usb_device_t *dev; size_t pipe_index; - usb_polling_callback_t callback; - usb_polling_terminted_callback_t terminated_callback; size_t request_size; uint8_t *buffer; @@ -54,4 +61,5 @@ } polling_data_t; + /** Polling fibril. * @@ -66,14 +74,22 @@ usb_pipe_t *pipe = polling_data->dev->pipes[polling_data->pipe_index].pipe; + + if (polling_data->debug > 0) { + usb_endpoint_mapping_t *mapping + = &polling_data->dev->pipes[polling_data->pipe_index]; + usb_log_debug("Poll0x%x: started polling of `%s' - " \ + "interface %d (%s,%d,%d), %zuB/%zu.\n", + polling_data, + polling_data->dev->ddf_dev->name, + (int) mapping->interface->interface_number, + usb_str_class(mapping->interface->interface_class), + (int) mapping->interface->interface_subclass, + (int) mapping->interface->interface_protocol, + polling_data->request_size, pipe->max_packet_size); + } size_t failed_attempts = 0; - while (failed_attempts < MAX_FAILED_ATTEMPTS) { + while (failed_attempts <= polling_data->max_failures) { int rc; - - rc = usb_pipe_start_session(pipe); - if (rc != EOK) { - failed_attempts++; - continue; - } size_t actual_size; @@ -81,8 +97,40 @@ polling_data->request_size, &actual_size); - /* Quit the session regardless of errors. */ - usb_pipe_end_session(pipe); + if (polling_data->debug > 1) { + if (rc == EOK) { + usb_log_debug( + "Poll0x%x: received: '%s' (%zuB).\n", + polling_data, + usb_debug_str_buffer(polling_data->buffer, + actual_size, 16), + actual_size); + } else { + usb_log_debug( + "Poll0x%x: polling failed: %s.\n", + polling_data, str_error(rc)); + } + } + + /* If the pipe stalled, we can try to reset the stall. */ + if ((rc == ESTALL) && (polling_data->auto_clear_halt)) { + /* + * We ignore error here as this is usually a futile + * attempt anyway. + */ + usb_request_clear_endpoint_halt( + &polling_data->dev->ctrl_pipe, + pipe->endpoint_no); + } if (rc != EOK) { + if (polling_data->on_error != NULL) { + bool cont = polling_data->on_error( + polling_data->dev, rc, + polling_data->custom_arg); + if (!cont) { + failed_attempts + = polling_data->max_failures; + } + } failed_attempts++; continue; @@ -90,5 +138,5 @@ /* We have the data, execute the callback now. */ - bool carry_on = polling_data->callback(polling_data->dev, + bool carry_on = polling_data->on_data(polling_data->dev, polling_data->buffer, actual_size, polling_data->custom_arg); @@ -101,15 +149,26 @@ /* Reset as something might be only a temporary problem. */ failed_attempts = 0; - } - - if (failed_attempts > 0) { - usb_log_error( - "Polling of device `%s' terminated: recurring failures.\n", - polling_data->dev->ddf_dev->name); - } - - if (polling_data->terminated_callback != NULL) { - polling_data->terminated_callback(polling_data->dev, + + /* Take a rest before next request. */ + async_usleep(polling_data->delay); + } + + if (polling_data->on_polling_end != NULL) { + polling_data->on_polling_end(polling_data->dev, failed_attempts > 0, polling_data->custom_arg); + } + + if (polling_data->debug > 0) { + if (failed_attempts > 0) { + usb_log_error( + "Polling of device `%s' terminated: %s.\n", + polling_data->dev->ddf_dev->name, + "recurring failures"); + } else { + usb_log_debug( + "Polling of device `%s' terminated by user.\n", + polling_data->dev->ddf_dev->name + ); + } } @@ -154,4 +213,61 @@ } + usb_device_auto_polling_t *auto_polling + = malloc(sizeof(usb_device_auto_polling_t)); + if (auto_polling == NULL) { + return ENOMEM; + } + + auto_polling->debug = 1; + auto_polling->auto_clear_halt = true; + auto_polling->delay = 0; + auto_polling->max_failures = MAX_FAILED_ATTEMPTS; + auto_polling->on_data = callback; + auto_polling->on_polling_end = terminated_callback; + auto_polling->on_error = NULL; + + int rc = usb_device_auto_polling(dev, pipe_index, auto_polling, + request_size, arg); + + free(auto_polling); + + return rc; +} + +/** Start automatic device polling over interrupt in pipe. + * + * The polling settings is copied thus it is okay to destroy the structure + * after this function returns. + * + * @warning There is no guarantee when the request to the device + * will be sent for the first time (it is possible that this + * first request would be executed prior to return from this function). + * + * @param dev Device to be periodically polled. + * @param pipe_index Index of the endpoint pipe used for polling. + * @param polling Polling settings. + * @param request_size How many bytes to ask for in each request. + * @param arg Custom argument (passed as is to the callbacks). + * @return Error code. + * @retval EOK New fibril polling the device was already started. + */ +int usb_device_auto_polling(usb_device_t *dev, size_t pipe_index, + usb_device_auto_polling_t *polling, + size_t request_size, void *arg) +{ + if (dev == NULL) { + return EBADMEM; + } + if (pipe_index >= dev->pipes_count) { + return EINVAL; + } + if ((dev->pipes[pipe_index].pipe->transfer_type != USB_TRANSFER_INTERRUPT) + || (dev->pipes[pipe_index].pipe->direction != USB_DIRECTION_IN)) { + return EINVAL; + } + if ((polling == NULL) || (polling->on_data == NULL)) { + return EBADMEM; + } + polling_data_t *polling_data = malloc(sizeof(polling_data_t)); if (polling_data == NULL) { @@ -159,16 +275,28 @@ } - /* Allocate now to prevent immediate failure in the polling fibril. */ - polling_data->buffer = malloc(request_size); + /* Fill-in the data. */ + polling_data->buffer = malloc(sizeof(request_size)); if (polling_data->buffer == NULL) { free(polling_data); return ENOMEM; } + polling_data->request_size = request_size; polling_data->dev = dev; polling_data->pipe_index = pipe_index; - polling_data->callback = callback; - polling_data->terminated_callback = terminated_callback; - polling_data->request_size = request_size; polling_data->custom_arg = arg; + + polling_data->debug = polling->debug; + polling_data->max_failures = polling->max_failures; + if (polling->delay >= 0) { + polling_data->delay = (useconds_t) polling->delay; + } else { + polling_data->delay = (useconds_t) dev->pipes[pipe_index] + .descriptor->poll_interval; + } + polling_data->auto_clear_halt = polling->auto_clear_halt; + + polling_data->on_data = polling->on_data; + polling_data->on_polling_end = polling->on_polling_end; + polling_data->on_error = polling->on_error; fid_t fibril = fibril_create(polling_fibril, polling_data); @@ -176,10 +304,9 @@ free(polling_data->buffer); free(polling_data); - /* FIXME: better error code. */ return ENOMEM; } fibril_add_ready(fibril); - /* The allocated buffer etc. will be freed by the fibril. */ + /* Fibril launched. That fibril will free the allocated data. */ return EOK; Index: uspace/lib/usb/src/hidiface.c =================================================================== --- uspace/lib/usb/src/hidiface.c (revision e50cd7f06f4f69de26916ce998bb262dbcd8bec0) +++ uspace/lib/usb/src/hidiface.c (revision e50cd7f06f4f69de26916ce998bb262dbcd8bec0) @@ -0,0 +1,146 @@ +/* + * 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 libusb + * @{ + */ +/** @file + * Client functions for accessing USB HID interface (implementation). + */ +#include +#include +#include +#include +#include +#include +#include + +/** Ask for event array length. + * + * @param dev_phone Opened phone to DDF device providing USB HID interface. + * @return Number of usages returned or negative error code. + */ +int usbhid_dev_get_event_length(int dev_phone) +{ + if (dev_phone < 0) { + return EINVAL; + } + + sysarg_t len; + int rc = async_req_1_1(dev_phone, DEV_IFACE_ID(USBHID_DEV_IFACE), + IPC_M_USBHID_GET_EVENT_LENGTH, &len); + if (rc == EOK) { + return (int) len; + } else { + return rc; + } +} + +/** Request for next event from HID device. + * + * @param[in] dev_phone Opened phone to DDF device providing USB HID interface. + * @param[out] usage_pages Where to store usage pages. + * @param[out] usages Where to store usages (actual data). + * @param[in] usage_count Length of @p usage_pages and @p usages buffer + * (in items, not bytes). + * @param[out] actual_usage_count Number of usages actually returned by the + * device driver. + * @param[in] flags Flags (see USBHID_IFACE_FLAG_*). + * @return Error code. + */ +int usbhid_dev_get_event(int dev_phone, uint16_t *usage_pages, uint16_t *usages, + size_t usage_count, size_t *actual_usage_count, unsigned int flags) +{ + if (dev_phone < 0) { + return EINVAL; + } + if ((usage_pages == NULL) || (usages == NULL)) { + return ENOMEM; + } + if (usage_count == 0) { + return EINVAL; + } + + size_t buffer_size = sizeof(uint16_t) * usage_count * 2; + uint16_t *buffer = malloc(buffer_size); + if (buffer == NULL) { + return ENOMEM; + } + + aid_t opening_request = async_send_2(dev_phone, + DEV_IFACE_ID(USBHID_DEV_IFACE), IPC_M_USBHID_GET_EVENT, + flags, NULL); + if (opening_request == 0) { + free(buffer); + return ENOMEM; + } + + ipc_call_t data_request_call; + aid_t data_request = async_data_read(dev_phone, buffer, buffer_size, + &data_request_call); + if (data_request == 0) { + async_wait_for(opening_request, NULL); + free(buffer); + return ENOMEM; + } + + sysarg_t data_request_rc; + sysarg_t opening_request_rc; + async_wait_for(data_request, &data_request_rc); + async_wait_for(opening_request, &opening_request_rc); + + if (data_request_rc != EOK) { + /* Prefer return code of the opening request. */ + if (opening_request_rc != EOK) { + return (int) opening_request_rc; + } else { + return (int) data_request_rc; + } + } + + if (opening_request_rc != EOK) { + return (int) opening_request_rc; + } + + size_t actual_size = IPC_GET_ARG2(data_request_call); + size_t items = actual_size / 2; + + /* Copy the individual items. */ + memcpy(usage_pages, buffer, items * sizeof(uint16_t)); + memcpy(usages, buffer + items, items * sizeof(uint16_t)); + + if (actual_usage_count != NULL) { + *actual_usage_count = items; + } + + return EOK; +} + +/** + * @} + */ Index: uspace/lib/usb/src/hidparser.c =================================================================== --- uspace/lib/usb/src/hidparser.c (revision ef354b6778a2049a1546b354af20cf92410bf74c) +++ uspace/lib/usb/src/hidparser.c (revision e50cd7f06f4f69de26916ce998bb262dbcd8bec0) @@ -877,5 +877,4 @@ offset = item->offset + (j * item->size); - // FIXME if((size_t)(offset/8) != (size_t)((offset+item->size-1)/8)) { @@ -1352,9 +1351,11 @@ field = list_get_instance(field_it, usb_hid_report_field_t, link); - usb_hid_report_path_append_item (field->collection_path, field->usage_page, field->usage); - if(usb_hid_report_compare_usage_path (field->collection_path, path, flags) == EOK) { - ret++; - } - usb_hid_report_remove_last_item (field->collection_path); + if(USB_HID_ITEM_FLAG_CONSTANT(field->item_flags) == 0){ + usb_hid_report_path_append_item (field->collection_path, field->usage_page, field->usage); + if(usb_hid_report_compare_usage_path (field->collection_path, path, flags) == EOK) { + ret++; + } + usb_hid_report_remove_last_item (field->collection_path); + } field_it = field_it->next; @@ -1536,24 +1537,4 @@ /** - * Clones given report item structure and returns the new one - * - * @param item Report item structure to clone - * @return Clonned item - */ -usb_hid_report_item_t *usb_hid_report_item_clone(const usb_hid_report_item_t *item) -{ - usb_hid_report_item_t *new_report_item; - - if(!(new_report_item = malloc(sizeof(usb_hid_report_item_t)))) { - return NULL; - } - memcpy(new_report_item,item, sizeof(usb_hid_report_item_t)); - link_initialize(&(new_report_item->link)); - - return new_report_item; -} - - -/** * * @@ -1604,4 +1585,55 @@ } + +usb_hid_report_item_t *usb_hid_report_item_clone(const usb_hid_report_item_t *item) +{ + usb_hid_report_item_t *new_report_item; + + if(!(new_report_item = malloc(sizeof(usb_hid_report_item_t)))) { + return NULL; + } + memcpy(new_report_item,item, sizeof(usb_hid_report_item_t)); + link_initialize(&(new_report_item->link)); + + return new_report_item; +} + + +usb_hid_report_field_t *usb_hid_report_get_sibling(usb_hid_report_t *report, + usb_hid_report_field_t *field, + usb_hid_report_path_t *path, int flags, + usb_hid_report_type_t type) +{ + usb_hid_report_description_t *report_des = usb_hid_report_find_description (report, path->report_id, type); + link_t *field_it; + + if(report_des == NULL){ + return NULL; + } + + if(field == NULL){ + // vezmu prvni co mathuje podle path!! + field_it = report_des->report_items.next; + } + else { + field_it = field->link.next; + } + + while(field_it != &report_des->report_items) { + field = list_get_instance(field_it, usb_hid_report_field_t, link); + + usb_hid_report_path_append_item (field->collection_path, field->usage_page, field->usage); + if(usb_hid_report_compare_usage_path (field->collection_path, path, flags) == EOK){ + usb_hid_report_remove_last_item (field->collection_path); + usb_log_debug("....OK\n"); + return field; + } + usb_hid_report_remove_last_item (field->collection_path); + + field_it = field_it->next; + } + + return NULL; +} /** * @} Index: uspace/lib/usb/src/hidreport.c =================================================================== --- uspace/lib/usb/src/hidreport.c (revision ef354b6778a2049a1546b354af20cf92410bf74c) +++ uspace/lib/usb/src/hidreport.c (revision e50cd7f06f4f69de26916ce998bb262dbcd8bec0) @@ -80,4 +80,5 @@ d = usb_dp_get_sibling_descriptor(&parser, &parser_data, dev->descriptors.configuration, d); + ++i; } @@ -118,14 +119,4 @@ uint16_t length = hid_desc->report_desc_info.length; size_t actual_size = 0; - - /* - * Start session for the control transfer. - */ - int sess_rc = usb_pipe_start_session(&dev->ctrl_pipe); - if (sess_rc != EOK) { - usb_log_warning("Failed to start a session: %s.\n", - str_error(sess_rc)); - return sess_rc; - } /* @@ -161,16 +152,4 @@ "%u)\n", actual_size, length); return EINVAL; - } - - /* - * End session for the control transfer. - */ - sess_rc = usb_pipe_end_session(&dev->ctrl_pipe); - if (sess_rc != EOK) { - usb_log_warning("Failed to end a session: %s.\n", - str_error(sess_rc)); - free(*report_desc); - *report_desc = NULL; - return sess_rc; } Index: uspace/lib/usb/src/hidreq.c =================================================================== --- uspace/lib/usb/src/hidreq.c (revision ef354b6778a2049a1546b354af20cf92410bf74c) +++ uspace/lib/usb/src/hidreq.c (revision e50cd7f06f4f69de26916ce998bb262dbcd8bec0) @@ -56,7 +56,5 @@ * @retval EOK if successful. * @retval EINVAL if no HID device is given. - * @return Other value inherited from one of functions - * usb_pipe_start_session(), usb_pipe_end_session(), - * usb_control_request_set(). + * @return Other value inherited from function usb_control_request_set(). */ int usbhid_req_set_report(usb_pipe_t *ctrl_pipe, int iface_no, @@ -79,12 +77,5 @@ */ - int rc, sess_rc; - - sess_rc = usb_pipe_start_session(ctrl_pipe); - if (sess_rc != EOK) { - usb_log_warning("Failed to start a session: %s.\n", - str_error(sess_rc)); - return sess_rc; - } + int rc; uint16_t value = 0; @@ -97,16 +88,8 @@ USB_HIDREQ_SET_REPORT, value, iface_no, buffer, buf_size); - sess_rc = usb_pipe_end_session(ctrl_pipe); - - if (rc != EOK) { - usb_log_warning("Error sending output report to the keyboard: " - "%s.\n", str_error(rc)); - return rc; - } - - if (sess_rc != EOK) { - usb_log_warning("Error closing session: %s.\n", - str_error(sess_rc)); - return sess_rc; + if (rc != EOK) { + usb_log_warning("Error sending output report to the keyboard: " + "%s.\n", str_error(rc)); + return rc; } @@ -123,7 +106,5 @@ * @retval EOK if successful. * @retval EINVAL if no HID device is given. - * @return Other value inherited from one of functions - * usb_pipe_start_session(), usb_pipe_end_session(), - * usb_control_request_set(). + * @return Other value inherited from function usb_control_request_set(). */ int usbhid_req_set_protocol(usb_pipe_t *ctrl_pipe, int iface_no, @@ -146,12 +127,5 @@ */ - int rc, sess_rc; - - sess_rc = usb_pipe_start_session(ctrl_pipe); - if (sess_rc != EOK) { - usb_log_warning("Failed to start a session: %s.\n", - str_error(sess_rc)); - return sess_rc; - } + int rc; usb_log_debug("Sending Set_Protocol request to the device (" @@ -162,16 +136,8 @@ USB_HIDREQ_SET_PROTOCOL, protocol, iface_no, NULL, 0); - sess_rc = usb_pipe_end_session(ctrl_pipe); - - if (rc != EOK) { - usb_log_warning("Error sending output report to the keyboard: " - "%s.\n", str_error(rc)); - return rc; - } - - if (sess_rc != EOK) { - usb_log_warning("Error closing session: %s.\n", - str_error(sess_rc)); - return sess_rc; + if (rc != EOK) { + usb_log_warning("Error sending output report to the keyboard: " + "%s.\n", str_error(rc)); + return rc; } @@ -189,7 +155,5 @@ * @retval EOK if successful. * @retval EINVAL if no HID device is given. - * @return Other value inherited from one of functions - * usb_pipe_start_session(), usb_pipe_end_session(), - * usb_control_request_set(). + * @return Other value inherited from function usb_control_request_set(). */ int usbhid_req_set_idle(usb_pipe_t *ctrl_pipe, int iface_no, uint8_t duration) @@ -211,12 +175,5 @@ */ - int rc, sess_rc; - - sess_rc = usb_pipe_start_session(ctrl_pipe); - if (sess_rc != EOK) { - usb_log_warning("Failed to start a session: %s.\n", - str_error(sess_rc)); - return sess_rc; - } + int rc; usb_log_debug("Sending Set_Idle request to the device (" @@ -229,16 +186,8 @@ USB_HIDREQ_SET_IDLE, value, iface_no, NULL, 0); - sess_rc = usb_pipe_end_session(ctrl_pipe); - - if (rc != EOK) { - usb_log_warning("Error sending output report to the keyboard: " - "%s.\n", str_error(rc)); - return rc; - } - - if (sess_rc != EOK) { - usb_log_warning("Error closing session: %s.\n", - str_error(sess_rc)); - return sess_rc; + if (rc != EOK) { + usb_log_warning("Error sending output report to the keyboard: " + "%s.\n", str_error(rc)); + return rc; } @@ -259,7 +208,5 @@ * @retval EOK if successful. * @retval EINVAL if no HID device is given. - * @return Other value inherited from one of functions - * usb_pipe_start_session(), usb_pipe_end_session(), - * usb_control_request_set(). + * @return Other value inherited from function usb_control_request_set(). */ int usbhid_req_get_report(usb_pipe_t *ctrl_pipe, int iface_no, @@ -283,12 +230,5 @@ */ - int rc, sess_rc; - - sess_rc = usb_pipe_start_session(ctrl_pipe); - if (sess_rc != EOK) { - usb_log_warning("Failed to start a session: %s.\n", - str_error(sess_rc)); - return sess_rc; - } + int rc; uint16_t value = 0; @@ -302,16 +242,8 @@ actual_size); - sess_rc = usb_pipe_end_session(ctrl_pipe); - - if (rc != EOK) { - usb_log_warning("Error sending output report to the keyboard: " - "%s.\n", str_error(rc)); - return rc; - } - - if (sess_rc != EOK) { - usb_log_warning("Error closing session: %s.\n", - str_error(sess_rc)); - return sess_rc; + if (rc != EOK) { + usb_log_warning("Error sending output report to the keyboard: " + "%s.\n", str_error(rc)); + return rc; } @@ -328,7 +260,5 @@ * @retval EOK if successful. * @retval EINVAL if no HID device is given. - * @return Other value inherited from one of functions - * usb_pipe_start_session(), usb_pipe_end_session(), - * usb_control_request_set(). + * @return Other value inherited from function usb_control_request_set(). */ int usbhid_req_get_protocol(usb_pipe_t *ctrl_pipe, int iface_no, @@ -351,12 +281,5 @@ */ - int rc, sess_rc; - - sess_rc = usb_pipe_start_session(ctrl_pipe); - if (sess_rc != EOK) { - usb_log_warning("Failed to start a session: %s.\n", - str_error(sess_rc)); - return sess_rc; - } + int rc; usb_log_debug("Sending Get_Protocol request to the device (" @@ -370,16 +293,8 @@ USB_HIDREQ_GET_PROTOCOL, 0, iface_no, buffer, 1, &actual_size); - sess_rc = usb_pipe_end_session(ctrl_pipe); - - if (rc != EOK) { - usb_log_warning("Error sending output report to the keyboard: " - "%s.\n", str_error(rc)); - return rc; - } - - if (sess_rc != EOK) { - usb_log_warning("Error closing session: %s.\n", - str_error(sess_rc)); - return sess_rc; + if (rc != EOK) { + usb_log_warning("Error sending output report to the keyboard: " + "%s.\n", str_error(rc)); + return rc; } @@ -427,12 +342,5 @@ */ - int rc, sess_rc; - - sess_rc = usb_pipe_start_session(ctrl_pipe); - if (sess_rc != EOK) { - usb_log_warning("Failed to start a session: %s.\n", - str_error(sess_rc)); - return sess_rc; - } + int rc; usb_log_debug("Sending Get_Idle request to the device (" @@ -448,16 +356,8 @@ &actual_size); - sess_rc = usb_pipe_end_session(ctrl_pipe); - - if (rc != EOK) { - usb_log_warning("Error sending output report to the keyboard: " - "%s.\n", str_error(rc)); - return rc; - } - - if (sess_rc != EOK) { - usb_log_warning("Error closing session: %s.\n", - str_error(sess_rc)); - return sess_rc; + if (rc != EOK) { + usb_log_warning("Error sending output report to the keyboard: " + "%s.\n", str_error(rc)); + return rc; } Index: uspace/lib/usb/src/host/batch.c =================================================================== --- uspace/lib/usb/src/host/batch.c (revision ef354b6778a2049a1546b354af20cf92410bf74c) +++ uspace/lib/usb/src/host/batch.c (revision e50cd7f06f4f69de26916ce998bb262dbcd8bec0) @@ -39,12 +39,12 @@ #include +void usb_transfer_batch_call_in(usb_transfer_batch_t *instance); +void usb_transfer_batch_call_out(usb_transfer_batch_t *instance); + void usb_transfer_batch_init( usb_transfer_batch_t *instance, - usb_target_t target, - usb_transfer_type_t transfer_type, - usb_speed_t speed, - size_t max_packet_size, + endpoint_t *ep, char *buffer, - char *transport_buffer, + char *data_buffer, size_t buffer_size, char *setup_buffer, @@ -54,29 +54,48 @@ void *arg, ddf_fun_t *fun, - endpoint_t *ep, - void *private_data + void *private_data, + void (*private_data_dtor)(void *p_data) ) { assert(instance); link_initialize(&instance->link); - instance->target = target; - instance->transfer_type = transfer_type; - instance->speed = speed; - instance->direction = USB_DIRECTION_BOTH; + instance->ep = ep; instance->callback_in = func_in; instance->callback_out = func_out; instance->arg = arg; instance->buffer = buffer; - instance->transport_buffer = transport_buffer; + instance->data_buffer = data_buffer; instance->buffer_size = buffer_size; instance->setup_buffer = setup_buffer; instance->setup_size = setup_size; - instance->max_packet_size = max_packet_size; instance->fun = fun; instance->private_data = private_data; + instance->private_data_dtor = private_data_dtor; instance->transfered_size = 0; instance->next_step = NULL; instance->error = EOK; - instance->ep = ep; + endpoint_use(instance->ep); +} +/*----------------------------------------------------------------------------*/ +/** Helper function, calls callback and correctly destroys batch structure. + * + * @param[in] instance Batch structure to use. + */ +void usb_transfer_batch_call_in_and_dispose(usb_transfer_batch_t *instance) +{ + assert(instance); + usb_transfer_batch_call_in(instance); + usb_transfer_batch_dispose(instance); +} +/*----------------------------------------------------------------------------*/ +/** Helper function calls callback and correctly destroys batch structure. + * + * @param[in] instance Batch structure to use. + */ +void usb_transfer_batch_call_out_and_dispose(usb_transfer_batch_t *instance) +{ + assert(instance); + usb_transfer_batch_call_out(instance); + usb_transfer_batch_dispose(instance); } /*----------------------------------------------------------------------------*/ @@ -86,8 +105,9 @@ * */ -void usb_transfer_batch_finish(usb_transfer_batch_t *instance, int error) +void usb_transfer_batch_finish(usb_transfer_batch_t *instance) { assert(instance); - instance->error = error; + assert(instance->ep); + endpoint_release(instance->ep); instance->next_step(instance); } @@ -103,16 +123,14 @@ assert(instance); assert(instance->callback_in); + assert(instance->ep); /* We are data in, we need data */ - memcpy(instance->buffer, instance->transport_buffer, - instance->buffer_size); + memcpy(instance->buffer, instance->data_buffer, instance->buffer_size); usb_log_debug("Batch %p done (T%d.%d, %s %s in, %zuB): %s (%d).\n", - instance, - instance->target.address, instance->target.endpoint, - usb_str_speed(instance->speed), - usb_str_transfer_type_short(instance->transfer_type), - instance->transfered_size, - str_error(instance->error), instance->error); + instance, instance->ep->address, instance->ep->endpoint, + usb_str_speed(instance->ep->speed), + usb_str_transfer_type_short(instance->ep->transfer_type), + instance->transfered_size, str_error(instance->error), instance->error); instance->callback_in(instance->fun, instance->error, @@ -130,8 +148,7 @@ usb_log_debug("Batch %p done (T%d.%d, %s %s out): %s (%d).\n", - instance, - instance->target.address, instance->target.endpoint, - usb_str_speed(instance->speed), - usb_str_transfer_type_short(instance->transfer_type), + instance, instance->ep->address, instance->ep->endpoint, + usb_str_speed(instance->ep->speed), + usb_str_transfer_type_short(instance->ep->transfer_type), str_error(instance->error), instance->error); @@ -139,4 +156,19 @@ instance->error, instance->arg); } +/*----------------------------------------------------------------------------*/ +/** Correctly dispose all used data structures. + * + * @param[in] instance Batch structure to use. + */ +void usb_transfer_batch_dispose(usb_transfer_batch_t *instance) +{ + assert(instance); + usb_log_debug("Batch(%p) disposing.\n", instance); + if (instance->private_data) { + assert(instance->private_data_dtor); + instance->private_data_dtor(instance->private_data); + } + free(instance); +} /** * @} Index: uspace/lib/usb/src/host/device_keeper.c =================================================================== --- uspace/lib/usb/src/host/device_keeper.c (revision ef354b6778a2049a1546b354af20cf92410bf74c) +++ uspace/lib/usb/src/host/device_keeper.c (revision e50cd7f06f4f69de26916ce998bb262dbcd8bec0) @@ -48,113 +48,15 @@ { assert(instance); - fibril_mutex_initialize(&instance->guard); - fibril_condvar_initialize(&instance->change); - instance->last_address = 0; unsigned i = 0; for (; i < USB_ADDRESS_COUNT; ++i) { instance->devices[i].occupied = false; - instance->devices[i].control_used = 0; instance->devices[i].handle = 0; - list_initialize(&instance->devices[i].endpoints); + instance->devices[i].speed = USB_SPEED_MAX; } -} -/*----------------------------------------------------------------------------*/ -void usb_device_keeper_add_ep( - usb_device_keeper_t *instance, usb_address_t address, endpoint_t *ep) -{ - assert(instance); - fibril_mutex_lock(&instance->guard); - assert(instance->devices[address].occupied); - list_append(&ep->same_device_eps, &instance->devices[address].endpoints); - fibril_mutex_unlock(&instance->guard); -} -/*----------------------------------------------------------------------------*/ -/** Attempt to obtain address 0, blocks. - * - * @param[in] instance Device keeper structure to use. - * @param[in] speed Speed of the device requesting default address. - */ -void usb_device_keeper_reserve_default_address( - usb_device_keeper_t *instance, usb_speed_t speed) -{ - assert(instance); - fibril_mutex_lock(&instance->guard); - while (instance->devices[USB_ADDRESS_DEFAULT].occupied) { - fibril_condvar_wait(&instance->change, &instance->guard); - } - instance->devices[USB_ADDRESS_DEFAULT].occupied = true; - instance->devices[USB_ADDRESS_DEFAULT].speed = speed; - fibril_mutex_unlock(&instance->guard); -} -/*----------------------------------------------------------------------------*/ -/** Attempt to obtain address 0, blocks. - * - * @param[in] instance Device keeper structure to use. - * @param[in] speed Speed of the device requesting default address. - */ -void usb_device_keeper_release_default_address(usb_device_keeper_t *instance) -{ - assert(instance); - fibril_mutex_lock(&instance->guard); - instance->devices[USB_ADDRESS_DEFAULT].occupied = false; - fibril_mutex_unlock(&instance->guard); - fibril_condvar_signal(&instance->change); -} -/*----------------------------------------------------------------------------*/ -/** Check setup packet data for signs of toggle reset. - * - * @param[in] instance Device keeper structure to use. - * @param[in] target Device to receive setup packet. - * @param[in] data Setup packet data. - * - * Really ugly one. - */ -void usb_device_keeper_reset_if_need( - usb_device_keeper_t *instance, usb_target_t target, const uint8_t *data) -{ - assert(instance); - fibril_mutex_lock(&instance->guard); - if (target.endpoint > 15 || target.endpoint < 0 - || target.address >= USB_ADDRESS_COUNT || target.address < 0 - || !instance->devices[target.address].occupied) { - fibril_mutex_unlock(&instance->guard); - usb_log_error("Invalid data when checking for toggle reset.\n"); - return; - } - - switch (data[1]) - { - case 0x01: /*clear feature*/ - /* recipient is endpoint, value is zero (ENDPOINT_STALL) */ - if (((data[0] & 0xf) == 1) && ((data[2] | data[3]) == 0)) { - link_t *current = - instance->devices[target.address].endpoints.next; - while (current != - &instance->devices[target.address].endpoints) - { - /* endpoint number is < 16, thus first byte is enough */ - endpoint_toggle_reset_filtered( - current, data[4]); - current = current->next; - } - } - break; - - case 0x9: /* set configuration */ - case 0x11: /* set interface */ - /* target must be device */ - if ((data[0] & 0xf) == 0) { - link_t *current = - instance->devices[target.address].endpoints.next; - while (current != - &instance->devices[target.address].endpoints) - { - endpoint_toggle_reset(current); - current = current->next; - } - } - break; - } - fibril_mutex_unlock(&instance->guard); + // TODO: is this hack enough? + // (it is needed to allow smooth registration at default address) + instance->devices[0].occupied = true; + instance->last_address = 0; + fibril_mutex_initialize(&instance->guard); } /*----------------------------------------------------------------------------*/ @@ -184,7 +86,9 @@ assert(new_address != USB_ADDRESS_DEFAULT); assert(instance->devices[new_address].occupied == false); + instance->devices[new_address].occupied = true; instance->devices[new_address].speed = speed; instance->last_address = new_address; + fibril_mutex_unlock(&instance->guard); return new_address; @@ -202,7 +106,9 @@ assert(instance); fibril_mutex_lock(&instance->guard); + assert(address > 0); assert(address <= USB11_ADDRESS_MAX); assert(instance->devices[address].occupied); + instance->devices[address].handle = handle; fibril_mutex_unlock(&instance->guard); @@ -223,4 +129,5 @@ fibril_mutex_lock(&instance->guard); assert(instance->devices[address].occupied); + instance->devices[address].occupied = false; fibril_mutex_unlock(&instance->guard); @@ -241,4 +148,5 @@ while (address <= USB11_ADDRESS_MAX) { if (instance->devices[address].handle == handle) { + assert(instance->devices[address].occupied); fibril_mutex_unlock(&instance->guard); return address; @@ -262,30 +170,6 @@ assert(address >= 0); assert(address <= USB11_ADDRESS_MAX); + return instance->devices[address].speed; -} -/*----------------------------------------------------------------------------*/ -void usb_device_keeper_use_control( - usb_device_keeper_t *instance, usb_target_t target) -{ - assert(instance); - const uint16_t ep = 1 << target.endpoint; - fibril_mutex_lock(&instance->guard); - while (instance->devices[target.address].control_used & ep) { - fibril_condvar_wait(&instance->change, &instance->guard); - } - instance->devices[target.address].control_used |= ep; - fibril_mutex_unlock(&instance->guard); -} -/*----------------------------------------------------------------------------*/ -void usb_device_keeper_release_control( - usb_device_keeper_t *instance, usb_target_t target) -{ - assert(instance); - const uint16_t ep = 1 << target.endpoint; - fibril_mutex_lock(&instance->guard); - assert((instance->devices[target.address].control_used & ep) != 0); - instance->devices[target.address].control_used &= ~ep; - fibril_mutex_unlock(&instance->guard); - fibril_condvar_signal(&instance->change); } /** Index: uspace/lib/usb/src/host/endpoint.c =================================================================== --- uspace/lib/usb/src/host/endpoint.c (revision ef354b6778a2049a1546b354af20cf92410bf74c) +++ uspace/lib/usb/src/host/endpoint.c (revision e50cd7f06f4f69de26916ce998bb262dbcd8bec0) @@ -34,4 +34,5 @@ */ +#include #include #include @@ -49,5 +50,8 @@ instance->max_packet_size = max_packet_size; instance->toggle = 0; - link_initialize(&instance->same_device_eps); + instance->active = false; + fibril_mutex_initialize(&instance->guard); + fibril_condvar_initialize(&instance->avail); + endpoint_clear_hc_data(instance); return EOK; } @@ -56,6 +60,42 @@ { assert(instance); - list_remove(&instance->same_device_eps); + assert(!instance->active); free(instance); +} +/*----------------------------------------------------------------------------*/ +void endpoint_set_hc_data(endpoint_t *instance, + void *data, int (*toggle_get)(void *), void (*toggle_set)(void *, int)) +{ + assert(instance); + instance->hc_data.data = data; + instance->hc_data.toggle_get = toggle_get; + instance->hc_data.toggle_set = toggle_set; +} +/*----------------------------------------------------------------------------*/ +void endpoint_clear_hc_data(endpoint_t *instance) +{ + assert(instance); + instance->hc_data.data = NULL; + instance->hc_data.toggle_get = NULL; + instance->hc_data.toggle_set = NULL; +} +/*----------------------------------------------------------------------------*/ +void endpoint_use(endpoint_t *instance) +{ + assert(instance); + fibril_mutex_lock(&instance->guard); + while (instance->active) + fibril_condvar_wait(&instance->avail, &instance->guard); + instance->active = true; + fibril_mutex_unlock(&instance->guard); +} +/*----------------------------------------------------------------------------*/ +void endpoint_release(endpoint_t *instance) +{ + assert(instance); + fibril_mutex_lock(&instance->guard); + instance->active = false; + fibril_mutex_unlock(&instance->guard); + fibril_condvar_signal(&instance->avail); } /*----------------------------------------------------------------------------*/ @@ -63,4 +103,7 @@ { assert(instance); + if (instance->hc_data.toggle_get) + instance->toggle = + instance->hc_data.toggle_get(instance->hc_data.data); return (int)instance->toggle; } @@ -70,22 +113,15 @@ assert(instance); assert(toggle == 0 || toggle == 1); + if (instance->hc_data.toggle_set) + instance->hc_data.toggle_set(instance->hc_data.data, toggle); instance->toggle = toggle; } /*----------------------------------------------------------------------------*/ -void endpoint_toggle_reset(link_t *ep) +void endpoint_toggle_reset_filtered(endpoint_t *instance, usb_target_t target) { - endpoint_t *instance = - list_get_instance(ep, endpoint_t, same_device_eps); assert(instance); - instance->toggle = 0; -} -/*----------------------------------------------------------------------------*/ -void endpoint_toggle_reset_filtered(link_t *ep, usb_endpoint_t epn) -{ - endpoint_t *instance = - list_get_instance(ep, endpoint_t, same_device_eps); - assert(instance); - if (instance->endpoint == epn) - instance->toggle = 0; + if (instance->address == target.address && + (instance->endpoint == target.endpoint || target.endpoint == 0)) + endpoint_toggle_set(instance, 0); } /** Index: uspace/lib/usb/src/host/usb_endpoint_manager.c =================================================================== --- uspace/lib/usb/src/host/usb_endpoint_manager.c (revision ef354b6778a2049a1546b354af20cf92410bf74c) +++ uspace/lib/usb/src/host/usb_endpoint_manager.c (revision e50cd7f06f4f69de26916ce998bb262dbcd8bec0) @@ -31,4 +31,5 @@ #include +#include #include @@ -80,4 +81,12 @@ endpoint_destroy(node->ep); free(node); +} +/*----------------------------------------------------------------------------*/ +static void node_toggle_reset_filtered(link_t *item, void *arg) +{ + assert(item); + node_t *node = hash_table_get_instance(item, node_t, link); + usb_target_t *target = arg; + endpoint_toggle_reset_filtered(node->ep, *target); } /*----------------------------------------------------------------------------*/ @@ -202,4 +211,7 @@ node_t *node = hash_table_get_instance(item, node_t, link); + if (node->ep->active) + return EBUSY; + instance->free_bw += node->bw; hash_table_remove(&instance->ep_table, key, MAX_KEYS); @@ -230,2 +242,50 @@ return node->ep; } +/*----------------------------------------------------------------------------*/ +/** Check setup packet data for signs of toggle reset. + * + * @param[in] instance Device keeper structure to use. + * @param[in] target Device to receive setup packet. + * @param[in] data Setup packet data. + * + * Really ugly one. + */ +void usb_endpoint_manager_reset_if_need( + usb_endpoint_manager_t *instance, usb_target_t target, const uint8_t *data) +{ + assert(instance); + if (target.endpoint > 15 || target.endpoint < 0 + || target.address >= USB11_ADDRESS_MAX || target.address < 0) { + usb_log_error("Invalid data when checking for toggle reset.\n"); + return; + } + + switch (data[1]) + { + case 0x01: /*clear feature*/ + /* recipient is endpoint, value is zero (ENDPOINT_STALL) */ + if (((data[0] & 0xf) == 1) && ((data[2] | data[3]) == 0)) { + /* endpoint number is < 16, thus first byte is enough */ + usb_target_t reset_target = + { .address = target.address, data[4] }; + fibril_mutex_lock(&instance->guard); + hash_table_apply(&instance->ep_table, + node_toggle_reset_filtered, &reset_target); + fibril_mutex_unlock(&instance->guard); + } + break; + + case 0x9: /* set configuration */ + case 0x11: /* set interface */ + /* target must be device */ + if ((data[0] & 0xf) == 0) { + usb_target_t reset_target = + { .address = target.address, 0 }; + fibril_mutex_lock(&instance->guard); + hash_table_apply(&instance->ep_table, + node_toggle_reset_filtered, &reset_target); + fibril_mutex_unlock(&instance->guard); + } + break; + } +} Index: uspace/lib/usb/src/hub.c =================================================================== --- uspace/lib/usb/src/hub.c (revision ef354b6778a2049a1546b354af20cf92410bf74c) +++ uspace/lib/usb/src/hub.c (revision e50cd7f06f4f69de26916ce998bb262dbcd8bec0) @@ -40,4 +40,10 @@ #include #include +#include + +/** How much time to wait between attempts to register endpoint 0:0. + * The value is based on typical value for port reset + some overhead. + */ +#define ENDPOINT_0_0_REGISTER_ATTEMPT_DELAY_USEC (1000 * (10 + 2)) /** Check that HC connection is alright. @@ -53,35 +59,4 @@ } while (false) - -/** Tell host controller to reserve default address. - * - * @param connection Opened connection to host controller. - * @param speed Speed of the device that will respond on the default address. - * @return Error code. - */ -int usb_hc_reserve_default_address(usb_hc_connection_t *connection, - usb_speed_t speed) -{ - CHECK_CONNECTION(connection); - - return async_req_2_0(connection->hc_phone, - DEV_IFACE_ID(USBHC_DEV_IFACE), - IPC_M_USBHC_RESERVE_DEFAULT_ADDRESS, speed); -} - -/** Tell host controller to release default address. - * - * @param connection Opened connection to host controller. - * @return Error code. - */ -int usb_hc_release_default_address(usb_hc_connection_t *connection) -{ - CHECK_CONNECTION(connection); - - return async_req_1_0(connection->hc_phone, - DEV_IFACE_ID(USBHC_DEV_IFACE), - IPC_M_USBHC_RELEASE_DEFAULT_ADDRESS); -} - /** Ask host controller for free address assignment. * @@ -178,6 +153,11 @@ * error codes than those listed as return codes by this function itself). * + * The @p connection representing connection with host controller does not + * need to be started. + * This function duplicates the connection to allow simultaneous calls of + * this function (i.e. from different fibrils). + * * @param[in] parent Parent device (i.e. the hub device). - * @param[in] connection Opened connection to host controller. + * @param[in] connection Connection to host controller. * @param[in] dev_speed New device speed. * @param[in] enable_port Function for enabling signaling through the port the @@ -206,43 +186,40 @@ ddf_dev_ops_t *dev_ops, void *new_dev_data, ddf_fun_t **new_fun) { - CHECK_CONNECTION(connection); + assert(connection != NULL); + // FIXME: this is awful, we are accessing directly the structure. + usb_hc_connection_t hc_conn = { + .hc_handle = connection->hc_handle, + .hc_phone = -1 + }; + + int rc; + + rc = usb_hc_connection_open(&hc_conn); + if (rc != EOK) { + return rc; + } + /* * Request new address. */ - usb_address_t dev_addr = usb_hc_request_address(connection, dev_speed); + usb_address_t dev_addr = usb_hc_request_address(&hc_conn, dev_speed); if (dev_addr < 0) { + usb_hc_connection_close(&hc_conn); return EADDRNOTAVAIL; } - int rc; - - /* - * Reserve the default address. - */ - rc = usb_hc_reserve_default_address(connection, dev_speed); - if (rc != EOK) { - rc = EBUSY; - goto leave_release_free_address; - } - - /* - * Enable the port (i.e. allow signaling through this port). - */ - rc = enable_port(port_no, arg); - if (rc != EOK) { - goto leave_release_default_address; - } - - /* - * Change the address from default to the free one. - * We need to create a new control pipe for that. + /* + * We will not register control pipe on default address. + * The registration might fail. That means that someone else already + * registered that endpoint. We will simply wait and try again. + * (Someone else already wants to add a new device.) */ usb_device_connection_t dev_conn; rc = usb_device_connection_initialize_on_default_address(&dev_conn, - connection); + &hc_conn); if (rc != EOK) { rc = ENOTCONN; - goto leave_release_default_address; + goto leave_release_free_address; } @@ -252,54 +229,50 @@ if (rc != EOK) { rc = ENOTCONN; + goto leave_release_free_address; + } + + do { + rc = usb_pipe_register_with_speed(&ctrl_pipe, dev_speed, 0, + &hc_conn); + if (rc != EOK) { + /* Do not overheat the CPU ;-). */ + async_usleep(ENDPOINT_0_0_REGISTER_ATTEMPT_DELAY_USEC); + } + } while (rc != EOK); + + /* + * Endpoint is registered. We can enable the port and change + * device address. + */ + rc = enable_port(port_no, arg); + if (rc != EOK) { goto leave_release_default_address; } - /* Before sending any traffic, we need to register this - * endpoint. - */ - rc = usb_pipe_register(&ctrl_pipe, 0, connection); - if (rc != EOK) { - rc = EREFUSED; + rc = usb_pipe_probe_default_control(&ctrl_pipe); + if (rc != EOK) { + rc = ESTALL; goto leave_release_default_address; } - rc = usb_pipe_probe_default_control(&ctrl_pipe); - if (rc != EOK) { - rc = ENOTCONN; + + rc = usb_request_set_address(&ctrl_pipe, dev_addr); + if (rc != EOK) { + rc = ESTALL; goto leave_release_default_address; } - rc = usb_pipe_start_session(&ctrl_pipe); - if (rc != EOK) { - rc = ENOTCONN; - goto leave_unregister_endpoint; - } - - rc = usb_request_set_address(&ctrl_pipe, dev_addr); - if (rc != EOK) { - rc = ESTALL; - goto leave_stop_session; - } - - usb_pipe_end_session(&ctrl_pipe); - - /* - * Register the control endpoint for the new device. - */ - rc = usb_pipe_register(&ctrl_pipe, 0, connection); - if (rc != EOK) { - rc = EREFUSED; - goto leave_unregister_endpoint; - } - - /* - * Release the original endpoint. - */ - unregister_control_endpoint_on_default_address(connection); - - /* - * Once the address is changed, we can return the default address. - */ - usb_hc_release_default_address(connection); - + /* + * Address changed. We can release the original endpoint, thus + * allowing other to access the default address. + */ + unregister_control_endpoint_on_default_address(&hc_conn); + + /* + * Time to register the new endpoint. + */ + rc = usb_pipe_register(&ctrl_pipe, 0, &hc_conn); + if (rc != EOK) { + goto leave_release_free_address; + } /* @@ -316,6 +289,4 @@ } - - /* * And now inform the host controller about the handle. @@ -325,5 +296,5 @@ .handle = child_handle }; - rc = usb_hc_register_device(connection, &new_device); + rc = usb_hc_register_device(&hc_conn, &new_device); if (rc != EOK) { rc = EDESTADDRREQ; @@ -349,16 +320,11 @@ * Completely ignoring errors here. */ - -leave_stop_session: - usb_pipe_end_session(&ctrl_pipe); - -leave_unregister_endpoint: - usb_pipe_unregister(&ctrl_pipe, connection); - leave_release_default_address: - usb_hc_release_default_address(connection); + usb_pipe_unregister(&ctrl_pipe, &hc_conn); leave_release_free_address: - usb_hc_unregister_device(connection, dev_addr); + usb_hc_unregister_device(&hc_conn, dev_addr); + + usb_hc_connection_close(&hc_conn); return rc; Index: uspace/lib/usb/src/pipepriv.c =================================================================== --- uspace/lib/usb/src/pipepriv.c (revision e50cd7f06f4f69de26916ce998bb262dbcd8bec0) +++ uspace/lib/usb/src/pipepriv.c (revision e50cd7f06f4f69de26916ce998bb262dbcd8bec0) @@ -0,0 +1,129 @@ +/* + * 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 libusb + * @{ + */ +/** @file + * Library internal functions on USB pipes (implementation). + */ +#include "pipepriv.h" +#include +#include +#include + +/** Ensure exclusive access to the IPC phone of given pipe. + * + * @param pipe Pipe to be exclusively accessed. + */ +void pipe_start_transaction(usb_pipe_t *pipe) +{ + fibril_mutex_lock(&pipe->hc_phone_mutex); +} + +/** Terminate exclusive access to the IPC phone of given pipe. + * + * @param pipe Pipe to be released from exclusive usage. + */ +void pipe_end_transaction(usb_pipe_t *pipe) +{ + fibril_mutex_unlock(&pipe->hc_phone_mutex); +} + +/** Ensure exclusive access to the pipe as a whole. + * + * @param pipe Pipe to be exclusively accessed. + */ +void pipe_acquire(usb_pipe_t *pipe) +{ + fibril_mutex_lock(&pipe->guard); +} + +/** Terminate exclusive access to the pipe as a whole. + * + * @param pipe Pipe to be released from exclusive usage. + */ +void pipe_release(usb_pipe_t *pipe) +{ + fibril_mutex_unlock(&pipe->guard); +} + +/** Add reference of active transfers over the pipe. + * + * @param pipe The USB pipe. + * @return Error code. + * @retval EOK Currently always. + */ +int pipe_add_ref(usb_pipe_t *pipe) +{ +another_try: + pipe_acquire(pipe); + + if (pipe->refcount == 0) { + /* Need to open the phone by ourselves. */ + int phone = devman_device_connect(pipe->wire->hc_handle, 0); + if (phone < 0) { + // TODO: treat some error as non-recoverable + // and return error from here + pipe_release(pipe); + goto another_try; + } + /* + * No locking is needed, refcount is zero and whole pipe + * mutex is locked. + */ + pipe->hc_phone = phone; + } + pipe->refcount++; + + pipe_release(pipe); + + return EOK; +} + +/** Drop active transfer reference on the pipe. + * + * @param pipe The USB pipe. + */ +void pipe_drop_ref(usb_pipe_t *pipe) +{ + pipe_acquire(pipe); + assert(pipe->refcount > 0); + pipe->refcount--; + if (pipe->refcount == 0) { + /* We were the last users, let's hang-up. */ + async_hangup(pipe->hc_phone); + pipe->hc_phone = -1; + } + pipe_release(pipe); +} + + +/** + * @} + */ Index: uspace/lib/usb/src/pipepriv.h =================================================================== --- uspace/lib/usb/src/pipepriv.h (revision e50cd7f06f4f69de26916ce998bb262dbcd8bec0) +++ uspace/lib/usb/src/pipepriv.h (revision e50cd7f06f4f69de26916ce998bb262dbcd8bec0) @@ -0,0 +1,53 @@ +/* + * 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 libusb + * @{ + */ +/** @file + * Library internal functions on USB pipes. + */ +#ifndef LIBUSB_PIPEPRIV_H_ +#define LIBUSB_PIPEPRIV_H_ + +#include + +void pipe_acquire(usb_pipe_t *); +void pipe_release(usb_pipe_t *); + +void pipe_start_transaction(usb_pipe_t *); +void pipe_end_transaction(usb_pipe_t *); + +int pipe_add_ref(usb_pipe_t *); +void pipe_drop_ref(usb_pipe_t *); + + +#endif +/** + * @} + */ Index: uspace/lib/usb/src/pipes.c =================================================================== --- uspace/lib/usb/src/pipes.c (revision ef354b6778a2049a1546b354af20cf92410bf74c) +++ uspace/lib/usb/src/pipes.c (revision e50cd7f06f4f69de26916ce998bb262dbcd8bec0) @@ -41,4 +41,5 @@ #include #include +#include "pipepriv.h" #define IPC_AGAIN_DELAY (1000 * 2) /* 2ms */ @@ -241,4 +242,7 @@ * necessary. * + * @deprecated + * Obsoleted with introduction of usb_pipe_start_long_transfer + * * @param pipe Endpoint pipe to start the session on. * @return Error code. @@ -246,17 +250,5 @@ int usb_pipe_start_session(usb_pipe_t *pipe) { - assert(pipe); - - if (usb_pipe_is_session_started(pipe)) { - return EBUSY; - } - - int phone = devman_device_connect(pipe->wire->hc_handle, 0); - if (phone < 0) { - return phone; - } - - pipe->hc_phone = phone; - + usb_log_warning("usb_pipe_start_session() was deprecated.\n"); return EOK; } @@ -265,4 +257,7 @@ /** Ends a session on the endpoint pipe. * + * @deprecated + * Obsoleted with introduction of usb_pipe_end_long_transfer + * * @see usb_pipe_start_session * @@ -272,17 +267,5 @@ int usb_pipe_end_session(usb_pipe_t *pipe) { - assert(pipe); - - if (!usb_pipe_is_session_started(pipe)) { - return ENOENT; - } - - int rc = async_hangup(pipe->hc_phone); - if (rc != EOK) { - return rc; - } - - pipe->hc_phone = -1; - + usb_log_warning("usb_pipe_end_session() was deprecated.\n"); return EOK; } @@ -298,5 +281,34 @@ bool usb_pipe_is_session_started(usb_pipe_t *pipe) { - return (pipe->hc_phone >= 0); + pipe_acquire(pipe); + bool started = pipe->refcount > 0; + pipe_release(pipe); + return started; +} + +/** Prepare pipe for a long transfer. + * + * By a long transfer is mean transfer consisting of several + * requests to the HC. + * Calling such function is optional and it has positive effect of + * improved performance because IPC session is initiated only once. + * + * @param pipe Pipe over which the transfer will happen. + * @return Error code. + */ +int usb_pipe_start_long_transfer(usb_pipe_t *pipe) +{ + return pipe_add_ref(pipe); +} + +/** Terminate a long transfer on a pipe. + * + * @see usb_pipe_start_long_transfer + * + * @param pipe Pipe where to end the long transfer. + */ +void usb_pipe_end_long_transfer(usb_pipe_t *pipe) +{ + pipe_drop_ref(pipe); } Index: uspace/lib/usb/src/pipesinit.c =================================================================== --- uspace/lib/usb/src/pipesinit.c (revision ef354b6778a2049a1546b354af20cf92410bf74c) +++ uspace/lib/usb/src/pipesinit.c (revision e50cd7f06f4f69de26916ce998bb262dbcd8bec0) @@ -356,10 +356,14 @@ assert(connection); + fibril_mutex_initialize(&pipe->guard); pipe->wire = connection; pipe->hc_phone = -1; + fibril_mutex_initialize(&pipe->hc_phone_mutex); pipe->endpoint_no = endpoint_no; pipe->transfer_type = transfer_type; pipe->max_packet_size = max_packet_size; pipe->direction = direction; + pipe->refcount = 0; + pipe->auto_reset_halt = false; return EOK; @@ -382,4 +386,6 @@ 0, USB_TRANSFER_CONTROL, CTRL_PIPE_MIN_PACKET_SIZE, USB_DIRECTION_BOTH); + + pipe->auto_reset_halt = true; return rc; @@ -413,10 +419,5 @@ int rc; - TRY_LOOP(failed_attempts) { - rc = usb_pipe_start_session(pipe); - if (rc == EOK) { - break; - } - } + rc = usb_pipe_start_long_transfer(pipe); if (rc != EOK) { return rc; @@ -439,5 +440,5 @@ } } - usb_pipe_end_session(pipe); + usb_pipe_end_long_transfer(pipe); if (rc != EOK) { return rc; @@ -461,4 +462,25 @@ usb_hc_connection_t *hc_connection) { + return usb_pipe_register_with_speed(pipe, USB_SPEED_MAX + 1, + interval, hc_connection); +} + +/** Register endpoint with a speed at the host controller. + * + * You will rarely need to use this function because it is needed only + * if the registered endpoint is of address 0 and there is no other way + * to tell speed of the device at address 0. + * + * @param pipe Pipe to be registered. + * @param speed Speed of the device + * (invalid speed means use previously specified one). + * @param interval Polling interval. + * @param hc_connection Connection to the host controller (must be opened). + * @return Error code. + */ +int usb_pipe_register_with_speed(usb_pipe_t *pipe, usb_speed_t speed, + unsigned int interval, + usb_hc_connection_t *hc_connection) +{ assert(pipe); assert(hc_connection); @@ -468,13 +490,15 @@ } -#define _PACK(high, low) ((high) * 256 + (low)) - - return async_req_5_0(hc_connection->hc_phone, +#define _PACK2(high, low) (((high) << 16) + (low)) +#define _PACK3(high, middle, low) (((((high) << 8) + (middle)) << 8) + (low)) + + return async_req_4_0(hc_connection->hc_phone, DEV_IFACE_ID(USBHC_DEV_IFACE), IPC_M_USBHC_REGISTER_ENDPOINT, - _PACK(pipe->wire->address, pipe->endpoint_no), - _PACK(pipe->transfer_type, pipe->direction), - pipe->max_packet_size, interval); - -#undef _PACK + _PACK2(pipe->wire->address, pipe->endpoint_no), + _PACK3(speed, pipe->transfer_type, pipe->direction), + _PACK2(pipe->max_packet_size, interval)); + +#undef _PACK2 +#undef _PACK3 } Index: uspace/lib/usb/src/pipesio.c =================================================================== --- uspace/lib/usb/src/pipesio.c (revision ef354b6778a2049a1546b354af20cf92410bf74c) +++ uspace/lib/usb/src/pipesio.c (revision e50cd7f06f4f69de26916ce998bb262dbcd8bec0) @@ -49,4 +49,6 @@ #include #include +#include +#include "pipepriv.h" /** Request an in transfer, no checking of input parameters. @@ -78,13 +80,16 @@ } + /* Ensure serialization over the phone. */ + pipe_start_transaction(pipe); + /* * Make call identifying target USB device and type of transfer. */ - aid_t opening_request = async_send_4(pipe->hc_phone, + aid_t opening_request = async_send_3(pipe->hc_phone, DEV_IFACE_ID(USBHC_DEV_IFACE), ipc_method, pipe->wire->address, pipe->endpoint_no, - pipe->max_packet_size, NULL); if (opening_request == 0) { + pipe_end_transaction(pipe); return ENOMEM; } @@ -96,4 +101,10 @@ aid_t data_request = async_data_read(pipe->hc_phone, buffer, size, &data_request_call); + + /* + * Since now on, someone else might access the backing phone + * without breaking the transfer IPC protocol. + */ + pipe_end_transaction(pipe); if (data_request == 0) { @@ -146,13 +157,9 @@ if (buffer == NULL) { - return EINVAL; + return EINVAL; } if (size == 0) { return EINVAL; - } - - if (!usb_pipe_is_session_started(pipe)) { - return EBADF; } @@ -165,8 +172,17 @@ } + int rc; + rc = pipe_add_ref(pipe); + if (rc != EOK) { + return rc; + } + + size_t act_size = 0; - int rc; rc = usb_pipe_read_no_checks(pipe, buffer, size, &act_size); + + pipe_drop_ref(pipe); + if (rc != EOK) { return rc; @@ -210,13 +226,16 @@ } + /* Ensure serialization over the phone. */ + pipe_start_transaction(pipe); + /* * Make call identifying target USB device and type of transfer. */ - aid_t opening_request = async_send_4(pipe->hc_phone, + aid_t opening_request = async_send_3(pipe->hc_phone, DEV_IFACE_ID(USBHC_DEV_IFACE), ipc_method, pipe->wire->address, pipe->endpoint_no, - pipe->max_packet_size, NULL); if (opening_request == 0) { + pipe_end_transaction(pipe); return ENOMEM; } @@ -226,4 +245,11 @@ */ int rc = async_data_write_start(pipe->hc_phone, buffer, size); + + /* + * Since now on, someone else might access the backing phone + * without breaking the transfer IPC protocol. + */ + pipe_end_transaction(pipe); + if (rc != EOK) { async_wait_for(opening_request, NULL); @@ -260,8 +286,4 @@ } - if (!usb_pipe_is_session_started(pipe)) { - return EBADF; - } - if (pipe->direction != USB_DIRECTION_OUT) { return EBADF; @@ -272,7 +294,35 @@ } - int rc = usb_pipe_write_no_check(pipe, buffer, size); + int rc; + + rc = pipe_add_ref(pipe); + if (rc != EOK) { + return rc; + } + + rc = usb_pipe_write_no_check(pipe, buffer, size); + + pipe_drop_ref(pipe); return rc; +} + +/** Try to clear endpoint halt of default control pipe. + * + * @param pipe Pipe for control endpoint zero. + */ +static void clear_self_endpoint_halt(usb_pipe_t *pipe) +{ + assert(pipe != NULL); + + if (!pipe->auto_reset_halt || (pipe->endpoint_no != 0)) { + return; + } + + + /* Prevent indefinite recursion. */ + pipe->auto_reset_halt = false; + usb_request_clear_endpoint_halt(pipe, 0); + pipe->auto_reset_halt = true; } @@ -293,11 +343,13 @@ void *data_buffer, size_t data_buffer_size, size_t *data_transfered_size) { + /* Ensure serialization over the phone. */ + pipe_start_transaction(pipe); + /* * Make call identifying target USB device and control transfer type. */ - aid_t opening_request = async_send_4(pipe->hc_phone, + aid_t opening_request = async_send_3(pipe->hc_phone, DEV_IFACE_ID(USBHC_DEV_IFACE), IPC_M_USBHC_CONTROL_READ, pipe->wire->address, pipe->endpoint_no, - pipe->max_packet_size, NULL); if (opening_request == 0) { @@ -311,4 +363,5 @@ setup_buffer, setup_buffer_size); if (rc != EOK) { + pipe_end_transaction(pipe); async_wait_for(opening_request, NULL); return rc; @@ -322,4 +375,12 @@ data_buffer, data_buffer_size, &data_request_call); + + /* + * Since now on, someone else might access the backing phone + * without breaking the transfer IPC protocol. + */ + pipe_end_transaction(pipe); + + if (data_request == 0) { async_wait_for(opening_request, NULL); @@ -379,8 +440,4 @@ } - if (!usb_pipe_is_session_started(pipe)) { - return EBADF; - } - if ((pipe->direction != USB_DIRECTION_BOTH) || (pipe->transfer_type != USB_TRANSFER_CONTROL)) { @@ -388,8 +445,21 @@ } + int rc; + + rc = pipe_add_ref(pipe); + if (rc != EOK) { + return rc; + } + size_t act_size = 0; - int rc = usb_pipe_control_read_no_check(pipe, + rc = usb_pipe_control_read_no_check(pipe, setup_buffer, setup_buffer_size, data_buffer, data_buffer_size, &act_size); + + if (rc == ESTALL) { + clear_self_endpoint_halt(pipe); + } + + pipe_drop_ref(pipe); if (rc != EOK) { @@ -418,14 +488,17 @@ void *data_buffer, size_t data_buffer_size) { + /* Ensure serialization over the phone. */ + pipe_start_transaction(pipe); + /* * Make call identifying target USB device and control transfer type. */ - aid_t opening_request = async_send_5(pipe->hc_phone, + aid_t opening_request = async_send_4(pipe->hc_phone, DEV_IFACE_ID(USBHC_DEV_IFACE), IPC_M_USBHC_CONTROL_WRITE, pipe->wire->address, pipe->endpoint_no, data_buffer_size, - pipe->max_packet_size, NULL); if (opening_request == 0) { + pipe_end_transaction(pipe); return ENOMEM; } @@ -437,4 +510,5 @@ setup_buffer, setup_buffer_size); if (rc != EOK) { + pipe_end_transaction(pipe); async_wait_for(opening_request, NULL); return rc; @@ -447,8 +521,15 @@ rc = async_data_write_start(pipe->hc_phone, data_buffer, data_buffer_size); + + /* All data sent, pipe can be released. */ + pipe_end_transaction(pipe); + if (rc != EOK) { async_wait_for(opening_request, NULL); return rc; } + } else { + /* No data to send, we can release the pipe for others. */ + pipe_end_transaction(pipe); } @@ -491,8 +572,4 @@ } - if (!usb_pipe_is_session_started(pipe)) { - return EBADF; - } - if ((pipe->direction != USB_DIRECTION_BOTH) || (pipe->transfer_type != USB_TRANSFER_CONTROL)) { @@ -500,6 +577,19 @@ } - int rc = usb_pipe_control_write_no_check(pipe, + int rc; + + rc = pipe_add_ref(pipe); + if (rc != EOK) { + return rc; + } + + rc = usb_pipe_control_write_no_check(pipe, setup_buffer, setup_buffer_size, data_buffer, data_buffer_size); + + if (rc == ESTALL) { + clear_self_endpoint_halt(pipe); + } + + pipe_drop_ref(pipe); return rc; Index: uspace/lib/usb/src/recognise.c =================================================================== --- uspace/lib/usb/src/recognise.c (revision ef354b6778a2049a1546b354af20cf92410bf74c) +++ uspace/lib/usb/src/recognise.c (revision e50cd7f06f4f69de26916ce998bb262dbcd8bec0) @@ -404,15 +404,5 @@ child->driver_data = dev_data; - rc = usb_pipe_start_session(&ctrl_pipe); - if (rc != EOK) { - goto failure; - } - rc = usb_device_create_match_ids(&ctrl_pipe, &child->match_ids); - if (rc != EOK) { - goto failure; - } - - rc = usb_pipe_end_session(&ctrl_pipe); if (rc != EOK) { goto failure; Index: uspace/lib/usb/src/request.c =================================================================== --- uspace/lib/usb/src/request.c (revision ef354b6778a2049a1546b354af20cf92410bf74c) +++ uspace/lib/usb/src/request.c (revision e50cd7f06f4f69de26916ce998bb262dbcd8bec0) @@ -871,4 +871,18 @@ } +/** Clear halt bit of an endpoint pipe (after pipe stall). + * + * @param pipe Control pipe. + * @param ep_index Endpoint index (in native endianness). + * @return Error code. + */ +int usb_request_clear_endpoint_halt(usb_pipe_t *pipe, uint16_t ep_index) +{ + return usb_request_clear_feature(pipe, + USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_ENDPOINT, + uint16_host2usb(USB_FEATURE_SELECTOR_ENDPOINT_HALT), + uint16_host2usb(ep_index)); +} + /** * @}