Changeset dc4c19e in mainline for uspace/lib/usb/src

Timestamp:

2011-04-10T12:18:09Z (15 years ago)

Author:

Lubos Slovak <lubos.slovak@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

60c0573

Parents:

a49e171 (diff), 82e8861 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Development changes

Location:

uspace/lib/usb/src

Files:

• devdrv.c (modified) (7 diffs)
• devpoll.c (modified) (1 diff)
• host/batch.c (modified) (3 diffs)
• host/device_keeper.c (modified) (3 diffs)
• host/endpoint.c (modified) (4 diffs)
• host/usb_endpoint_manager.c (modified) (3 diffs)
• hub.c (modified) (8 diffs)
• pipepriv.c (added)
• pipepriv.h (added)
• pipes.c (modified) (6 diffs)
• pipesinit.c (modified) (5 diffs)
• pipesio.c (modified) (19 diffs)
• recognise.c (modified) (1 diff)

uspace/lib/usb/src/devdrv.c

@@ -72 +72 @@
 }
 
-/** 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 +98 @@
  */
 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) {
-                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_device_t *dev, int alternate_setting)
+{
+        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);
+            dev->interface_no, alternate_setting,
+            &pipes, &pipes_count);
+
         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;
+                    "Failed to create endpoint pipes for `%s': %s.\n",
+                    dev->ddf_dev->name, str_error(rc));
+                return rc;
+        }
+
+        dev->pipes = pipes;
+        dev->pipes_count = pipes_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;
 }
 
@@ -239 +161 @@
 
         /*
-         * For further actions, we need open session on default control pipe.
+         * We will do some querying of the device, it is worth to prepare
+         * the long transfer.
          */
-        rc = usb_pipe_start_session(&dev->ctrl_pipe);
-        if (rc != EOK) {
-                usb_log_error("Failed to start an IPC session: %s.\n",
+        rc = usb_pipe_start_long_transfer(&dev->ctrl_pipe);
+        if (rc != EOK) {
+                usb_log_error("Failed to start transfer: %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",
+        /* Retrieve the descriptors. */
+        rc = usb_device_retrieve_descriptors(&dev->ctrl_pipe,
+            &dev->descriptors);
+        if (rc != EOK) {
+                usb_log_error("Failed to retrieve standard device " \
+                    "descriptors of %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);
+                rc = initialize_other_pipes(driver->endpoints, dev, 0);
+        }
+
+        usb_pipe_end_long_transfer(&dev->ctrl_pipe);
 
         /* Rollback actions. */
@@ -291 +205 @@
  * @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)
+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
@@ -343 +259 @@
 
         alternates->alternative_count
-            = count_alternate_interfaces(dev->descriptors.configuration,
+            = usb_interface_count_alternates(dev->descriptors.configuration,
             dev->descriptors.configuration_size, dev->interface_no);
 
@@ -457 +373 @@
 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;
@@ -535 +425 @@
 
         /* 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 pipe with opened session.
+ * @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);
+        assert(usb_pipe_is_session_started(ctrl_pipe));
+
+        descriptors->configuration = NULL;
+
+        int rc;
+
+        /* Get the device descriptor. */
+        rc = usb_request_get_device_descriptor(ctrl_pipe, &descriptors->device);
+        if (rc != EOK) {
+                return rc;
+        }
+
+        /* Get the full configuration descriptor. */
+        rc = usb_request_get_full_configuration_descriptor_alloc(
+            ctrl_pipe, 0, (void **) &descriptors->configuration,
+            &descriptors->configuration_size);
+        if (rc != EOK) {
+                return rc;
+        }
+
+        return EOK;
+}
+
+/** 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;
 }
 

uspace/lib/usb/src/devpoll.c

@@ -77 +77 @@
                 int rc;
 
-                rc = usb_pipe_start_session(pipe);
-                if (rc != EOK) {
-                        failed_attempts++;
-                        continue;
-                }
-
                 size_t actual_size;
                 rc = usb_pipe_read(pipe, polling_data->buffer,
                     polling_data->request_size, &actual_size);
 
-                /* Quit the session regardless of errors. */
-                usb_pipe_end_session(pipe);
                 
 //              if (rc == ESTALL) {

uspace/lib/usb/src/host/batch.c

@@ -63 +63 @@
         instance->transfer_type = transfer_type;
         instance->speed = speed;
-        instance->direction = USB_DIRECTION_BOTH;
+        instance->direction = ep->direction;
         instance->callback_in = func_in;
         instance->callback_out = func_out;
@@ -79 +79 @@
         instance->error = EOK;
         instance->ep = ep;
+        endpoint_use(instance->ep);
 }
 /*----------------------------------------------------------------------------*/
@@ -86 +87 @@
  *
  */
-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);
 }

uspace/lib/usb/src/host/device_keeper.c

@@ -54 +54 @@
         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);
+        // TODO: is this hack enough?
+        // (it is needed to allow smooth registration at default address)
+        instance->devices[0].occupied = true;
 }
 /*----------------------------------------------------------------------------*/
@@ -102 +94 @@
 }
 /*----------------------------------------------------------------------------*/
-/** 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);
-}
 /*----------------------------------------------------------------------------*/
 /** Get a free USB address
@@ -264 +200 @@
         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);
-}
 /**
  * @}

uspace/lib/usb/src/host/endpoint.c

@@ -34 +34 @@
  */
 
+#include <assert.h>
 #include <errno.h>
 #include <usb/host/endpoint.h>
@@ -49 +50 @@
         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);
         return EOK;
 }
@@ -56 +59 @@
 {
         assert(instance);
-        list_remove(&instance->same_device_eps);
+        assert(!instance->active);
         free(instance);
+}
+/*----------------------------------------------------------------------------*/
+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);
 }
 /*----------------------------------------------------------------------------*/
@@ -73 +95 @@
 }
 /*----------------------------------------------------------------------------*/
-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)
+        if (instance->address == target.address &&
+            (instance->endpoint == target.endpoint || target.endpoint == 0))
                 instance->toggle = 0;
 }

uspace/lib/usb/src/host/usb_endpoint_manager.c

@@ -31 +31 @@
 #include <errno.h>
 
+#include <usb/debug.h>
 #include <usb/host/usb_endpoint_manager.h>
 
@@ -80 +81 @@
         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);
 }
 /*----------------------------------------------------------------------------*/
@@ -230 +239 @@
         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;
+        }
+}

uspace/lib/usb/src/hub.c

@@ -40 +40 @@
 #include <errno.h>
 #include <assert.h>
+#include <usb/debug.h>
+
+/** 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 +59 @@
         } 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 +153 @@
  * 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 +186 @@
     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 +229 @@
         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 +289 @@
         }
 
-
-
         /*
          * And now inform the host controller about the handle.
@@ -325 +296 @@
                 .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 +320 @@
          * 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;

uspace/lib/usb/src/pipes.c

@@ -41 +41 @@
 #include <errno.h>
 #include <assert.h>
+#include "pipepriv.h"
 
 #define IPC_AGAIN_DELAY (1000 * 2) /* 2ms */
@@ -241 +242 @@
  * necessary.
  *
+ * @deprecated
+ * Obsoleted with introduction of usb_pipe_start_long_transfer
+ *
  * @param pipe Endpoint pipe to start the session on.
  * @return Error code.
@@ -246 +250 @@
 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 +257 @@
 /** Ends a session on the endpoint pipe.
  *
+ * @deprecated
+ * Obsoleted with introduction of usb_pipe_end_long_transfer
+ *
  * @see usb_pipe_start_session
  *
@@ -272 +267 @@
 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 +281 @@
 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);
 }
 

uspace/lib/usb/src/pipesinit.c

@@ -356 +356 @@
         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;
 
         return EOK;
@@ -413 +416 @@
         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 +437 @@
                 }
         }
-        usb_pipe_end_session(pipe);
+        usb_pipe_end_long_transfer(pipe);
         if (rc != EOK) {
                 return rc;
@@ -461 +459 @@
     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 +487 @@
         }
 
-#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
 }
 

uspace/lib/usb/src/pipesio.c

@@ -49 +49 @@
 #include <assert.h>
 #include <usbhc_iface.h>
+#include "pipepriv.h"
 
 /** Request an in transfer, no checking of input parameters.
@@ -78 +79 @@
         }
 
+        /* 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 +100 @@
         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 +156 @@
 
         if (buffer == NULL) {
-                        return EINVAL;
+                return EINVAL;
         }
 
         if (size == 0) {
                 return EINVAL;
-        }
-
-        if (!usb_pipe_is_session_started(pipe)) {
-                return EBADF;
         }
 
@@ -165 +171 @@
         }
 
+        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 +225 @@
         }
 
+        /* 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 +244 @@
          */
         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 +285 @@
         }
 
-        if (!usb_pipe_is_session_started(pipe)) {
-                return EBADF;
-        }
-
         if (pipe->direction != USB_DIRECTION_OUT) {
                 return EBADF;
@@ -272 +293 @@
         }
 
-        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;
@@ -293 +323 @@
     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 +343 @@
             setup_buffer, setup_buffer_size);
         if (rc != EOK) {
+                pipe_end_transaction(pipe);
                 async_wait_for(opening_request, NULL);
                 return rc;
@@ -322 +355 @@
             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 +420 @@
         }
 
-        if (!usb_pipe_is_session_started(pipe)) {
-                return EBADF;
-        }
-
         if ((pipe->direction != USB_DIRECTION_BOTH)
             || (pipe->transfer_type != USB_TRANSFER_CONTROL)) {
@@ -388 +425 @@
         }
 
+        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);
+
+        pipe_drop_ref(pipe);
 
         if (rc != EOK) {
@@ -418 +464 @@
     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 +486 @@
             setup_buffer, setup_buffer_size);
         if (rc != EOK) {
+                pipe_end_transaction(pipe);
                 async_wait_for(opening_request, NULL);
                 return rc;
@@ -447 +497 @@
                 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 +548 @@
         }
 
-        if (!usb_pipe_is_session_started(pipe)) {
-                return EBADF;
-        }
-
         if ((pipe->direction != USB_DIRECTION_BOTH)
             || (pipe->transfer_type != USB_TRANSFER_CONTROL)) {
@@ -500 +553 @@
         }
 
-        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);
+
+        pipe_drop_ref(pipe);
 
         return rc;

uspace/lib/usb/src/recognise.c

@@ -404 +404 @@
         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;