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

Timestamp:

2011-04-07T15:04:16Z (15 years ago)

Author:

Matus Dekanek <smekideki@…>

Branches:

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

Children:

36cd378

Parents:

9d06563 (diff), a82889e (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:

partial merge form usb/development

Location:

uspace/lib/usb/src

Files:

• devdrv.c (modified) (10 diffs)
• host/batch.c (modified) (2 diffs)
• host/device_keeper.c (modified) (12 diffs)
• host/endpoint.c (added)
• host/usb_endpoint_manager.c (moved) (moved from uspace/lib/usb/src/host/bandwidth.c ) (6 diffs)
• hub.c (modified) (6 diffs)
• pipesinit.c (modified) (3 diffs)

uspace/lib/usb/src/devdrv.c

@@ -36 +36 @@
 #include <usb/request.h>
 #include <usb/debug.h>
+#include <usb/dp.h>
 #include <errno.h>
 #include <str_error.h>
@@ -86 +87 @@
  * @return Number of pipes (excluding default control pipe).
  */
-static size_t count_other_pipes(usb_driver_t *drv)
+static size_t count_other_pipes(usb_endpoint_description_t **endpoints)
 {
         size_t count = 0;
-        if (drv->endpoints == NULL) {
+        if (endpoints == NULL) {
                 return 0;
         }
 
-        while (drv->endpoints[count] != NULL) {
+        while (endpoints[count] != NULL) {
                 count++;
         }
@@ -106 +107 @@
  * @return Error code.
  */
-static int initialize_other_pipes(usb_driver_t *drv, usb_device_t *dev)
+static int initialize_other_pipes(usb_endpoint_description_t **endpoints,
+    usb_device_t *dev)
 {
         int rc;
-        dev->interface_no = usb_device_get_assigned_interface(dev->ddf_dev);
-
-        size_t pipe_count = count_other_pipes(drv);
+
+        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) {
@@ -133 +138 @@
                 }
 
-                dev->pipes[i].description = drv->endpoints[i];
+                dev->pipes[i].description = endpoints[i];
                 dev->pipes[i].interface_no = dev->interface_no;
+                dev->pipes[i].interface_setting = 0;
         }
 
@@ -178 +184 @@
         usb_hc_connection_close(&hc_conn);
 
+        dev->pipes_count = pipe_count;
+
         return EOK;
 
@@ -227 +235 @@
         }
 
+        /* 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.
@@ -257 +268 @@
 
         if (driver->endpoints != NULL) {
-                rc = initialize_other_pipes(driver, dev);
+                rc = initialize_other_pipes(driver->endpoints, dev);
         }
 
@@ -271 +282 @@
 
         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;
+
+        return EOK;
 }
 
@@ -301 +436 @@
         dev->descriptors.configuration = NULL;
 
+        dev->pipes_count = 0;
+        dev->pipes = NULL;
+
         rc = initialize_pipes(dev);
         if (rc != EOK) {
@@ -307 +445 @@
         }
 
+        (void) initialize_alternate_interfaces(dev);
+
         return driver->ops->add_device(dev);
+}
+
+/** Destroy existing pipes of a USB device.
+ *
+ * @param dev Device where to destroy the pipes.
+ * @return Error code.
+ */
+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);
+        dev->pipes = NULL;
+        dev->pipes_count = 0;
+
+        return EOK;
+}
+
+/** Change interface setting of a device.
+ * This function selects new alternate setting of an interface by issuing
+ * proper USB command to the device and also creates new USB pipes
+ * under @c dev->pipes.
+ *
+ * @warning This function is intended for drivers working at interface level.
+ * For drivers controlling the whole device, you need to change interface
+ * manually using usb_request_set_interface() and creating new pipes
+ * with usb_pipe_initialize_from_configuration().
+ *
+ * @param dev USB device.
+ * @param alternate_setting Alternate setting to choose.
+ * @param endpoints New endpoint descriptions.
+ * @return Error code.
+ */
+int usb_device_select_interface(usb_device_t *dev, uint8_t alternate_setting,
+    usb_endpoint_description_t **endpoints)
+{
+        if (dev->interface_no < 0) {
+                return EINVAL;
+        }
+
+        int rc;
+
+        /* TODO: more transactional behavior. */
+
+        /* Destroy existing pipes. */
+        rc = destroy_current_pipes(dev);
+        if (rc != EOK) {
+                return rc;
+        }
+
+        /* Change the interface itself. */
+        rc = usb_request_set_interface(&dev->ctrl_pipe, dev->interface_no,
+            alternate_setting);
+        if (rc != EOK) {
+                return rc;
+        }
+
+        /* Create new pipes. */
+        rc = initialize_other_pipes(endpoints, dev);
+
+        return rc;
 }
 

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

@@ -54 +54 @@
     void *arg,
     ddf_fun_t *fun,
+                endpoint_t *ep,
     void *private_data
     )
@@ -77 +78 @@
         instance->next_step = NULL;
         instance->error = EOK;
-
+        instance->ep = ep;
 }
 /*----------------------------------------------------------------------------*/

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

@@ -56 +56 @@
                 instance->devices[i].control_used = 0;
                 instance->devices[i].handle = 0;
-                instance->devices[i].toggle_status[0] = 0;
-                instance->devices[i].toggle_status[1] = 0;
-        }
+                list_initialize(&instance->devices[i].endpoints);
+        }
+}
+/*----------------------------------------------------------------------------*/
+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);
 }
 /*----------------------------------------------------------------------------*/
@@ -66 +75 @@
  * @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)
+void usb_device_keeper_reserve_default_address(
+    usb_device_keeper_t *instance, usb_speed_t speed)
 {
         assert(instance);
@@ -101 +110 @@
  * Really ugly one.
  */
-void usb_device_keeper_reset_if_need(usb_device_keeper_t *instance,
-    usb_target_t target, const uint8_t *data)
+void usb_device_keeper_reset_if_need(
+    usb_device_keeper_t *instance, usb_target_t target, const uint8_t *data)
 {
         assert(instance);
@@ -119 +128 @@
                 /* 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 */
-                        instance->devices[target.address].toggle_status[0] &=
-                            ~(1 << data[4]);
-                        instance->devices[target.address].toggle_status[1] &=
-                            ~(1 << data[4]);
+                                endpoint_toggle_reset_filtered(
+                                    current, data[4]);
+                                current = current->next;
+                        }
                 }
         break;
@@ -131 +145 @@
                 /* target must be device */
                 if ((data[0] & 0xf) == 0) {
-                        instance->devices[target.address].toggle_status[0] = 0;
-                        instance->devices[target.address].toggle_status[1] = 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 current value of endpoint toggle.
- *
- * @param[in] instance Device keeper structure to use.
- * @param[in] target Device and endpoint used.
- * @return Error code
- */
-int usb_device_keeper_get_toggle(usb_device_keeper_t *instance,
-    usb_target_t target, usb_direction_t direction)
-{
-        assert(instance);
-        /* only control pipes are bi-directional and those do not need toggle */
-        if (direction == USB_DIRECTION_BOTH)
-                return ENOENT;
-        int ret;
-        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) {
-                usb_log_error("Invalid data when asking for toggle value.\n");
-                ret = EINVAL;
-        } else {
-                ret = (instance->devices[target.address].toggle_status[direction]
-                        >> target.endpoint) & 1;
-        }
-        fibril_mutex_unlock(&instance->guard);
-        return ret;
-}
-/*----------------------------------------------------------------------------*/
-/** Set current value of endpoint toggle.
- *
- * @param[in] instance Device keeper structure to use.
- * @param[in] target Device and endpoint used.
- * @param[in] toggle Toggle value.
- * @return Error code.
- */
-int usb_device_keeper_set_toggle(usb_device_keeper_t *instance,
-    usb_target_t target, usb_direction_t direction, bool toggle)
-{
-        assert(instance);
-        /* only control pipes are bi-directional and those do not need toggle */
-        if (direction == USB_DIRECTION_BOTH)
-                return ENOENT;
-        int ret;
-        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) {
-                usb_log_error("Invalid data when setting toggle value.\n");
-                ret = EINVAL;
-        } else {
-                if (toggle) {
-                        instance->devices[target.address].toggle_status[direction]
-                            |= (1 << target.endpoint);
-                } else {
-                        instance->devices[target.address].toggle_status[direction]
-                            &= ~(1 << target.endpoint);
-                }
-                ret = EOK;
-        }
-        fibril_mutex_unlock(&instance->guard);
-        return ret;
 }
 /*----------------------------------------------------------------------------*/
@@ -208 +165 @@
  * @return Free address, or error code.
  */
-usb_address_t device_keeper_get_free_address(usb_device_keeper_t *instance,
-    usb_speed_t speed)
+usb_address_t device_keeper_get_free_address(
+    usb_device_keeper_t *instance, usb_speed_t speed)
 {
         assert(instance);
@@ -229 +186 @@
         instance->devices[new_address].occupied = true;
         instance->devices[new_address].speed = speed;
-        instance->devices[new_address].toggle_status[0] = 0;
-        instance->devices[new_address].toggle_status[1] = 0;
         instance->last_address = new_address;
         fibril_mutex_unlock(&instance->guard);
@@ -259 +214 @@
  * @param[in] address Device address
  */
-void usb_device_keeper_release(usb_device_keeper_t *instance,
-    usb_address_t address)
+void usb_device_keeper_release(
+    usb_device_keeper_t *instance, usb_address_t address)
 {
         assert(instance);
@@ -278 +233 @@
  * @return USB Address, or error code.
  */
-usb_address_t usb_device_keeper_find(usb_device_keeper_t *instance,
-    devman_handle_t handle)
+usb_address_t usb_device_keeper_find(
+    usb_device_keeper_t *instance, devman_handle_t handle)
 {
         assert(instance);
@@ -301 +256 @@
  * @return USB speed.
  */
-usb_speed_t usb_device_keeper_get_speed(usb_device_keeper_t *instance,
-    usb_address_t address)
+usb_speed_t usb_device_keeper_get_speed(
+    usb_device_keeper_t *instance, usb_address_t address)
 {
         assert(instance);
@@ -310 +265 @@
 }
 /*----------------------------------------------------------------------------*/
-void usb_device_keeper_use_control(usb_device_keeper_t *instance,
-    usb_target_t target)
+void usb_device_keeper_use_control(
+    usb_device_keeper_t *instance, usb_target_t target)
 {
         assert(instance);
@@ -323 +278 @@
 }
 /*----------------------------------------------------------------------------*/
-void usb_device_keeper_release_control(usb_device_keeper_t *instance,
-    usb_target_t target)
+void usb_device_keeper_release_control(
+    usb_device_keeper_t *instance, usb_target_t target)
 {
         assert(instance);

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

@@ -1 +1 @@
 /*
  * Copyright (c) 2011 Jan Vesely
- * All rights reserved.
+ * All rights eps.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -27 +27 @@
  */
 
+#include <bool.h>
 #include <assert.h>
 #include <errno.h>
-#include <usb/host/bandwidth.h>
-
+
+#include <usb/host/usb_endpoint_manager.h>
+
+#define BUCKET_COUNT 7
+
+#define MAX_KEYS (3)
 typedef struct {
-        usb_address_t address;
-        usb_endpoint_t endpoint;
-        usb_direction_t direction;
-} __attribute__((aligned (sizeof(unsigned long)))) transfer_t;
-/*----------------------------------------------------------------------------*/
-typedef struct {
-        transfer_t transfer;
         link_t link;
-        bool used;
-        size_t required;
-} transfer_status_t;
-/*----------------------------------------------------------------------------*/
-#define BUCKET_COUNT 7
-#define MAX_KEYS (sizeof(transfer_t) / sizeof(unsigned long))
-/*----------------------------------------------------------------------------*/
-static hash_index_t transfer_hash(unsigned long key[])
+        size_t bw;
+        endpoint_t *ep;
+} node_t;
+/*----------------------------------------------------------------------------*/
+static hash_index_t node_hash(unsigned long key[])
 {
         hash_index_t hash = 0;
@@ -58 +53 @@
 }
 /*----------------------------------------------------------------------------*/
-static int transfer_compare(
-    unsigned long key[], hash_count_t keys, link_t *item)
+static int node_compare(unsigned long key[], hash_count_t keys, link_t *item)
 {
         assert(item);
-        transfer_status_t *status =
-            hash_table_get_instance(item, transfer_status_t, link);
-        const size_t bytes =
-            keys < MAX_KEYS ? keys * sizeof(unsigned long) : sizeof(transfer_t);
-        return bcmp(key, &status->transfer, bytes);
-}
-/*----------------------------------------------------------------------------*/
-static void transfer_remove(link_t *item)
+        node_t *node = hash_table_get_instance(item, node_t, link);
+        assert(node);
+        assert(node->ep);
+        bool match = true;
+        switch (keys) {
+        case 3:
+                match = match && (key[2] == node->ep->direction);
+        case 2:
+                match = match && (key[1] == (unsigned long)node->ep->endpoint);
+        case 1:
+                match = match && (key[0] == (unsigned long)node->ep->address);
+                break;
+        default:
+                match = false;
+        }
+        return match;
+}
+/*----------------------------------------------------------------------------*/
+static void node_remove(link_t *item)
 {
         assert(item);
-        transfer_status_t *status =
-            hash_table_get_instance(item, transfer_status_t, link);
-        assert(status);
-        free(status);
-}
-/*----------------------------------------------------------------------------*/
-hash_table_operations_t op = {
-        .hash = transfer_hash,
-        .compare = transfer_compare,
-        .remove_callback = transfer_remove,
+        node_t *node = hash_table_get_instance(item, node_t, link);
+        endpoint_destroy(node->ep);
+        free(node);
+}
+/*----------------------------------------------------------------------------*/
+static hash_table_operations_t op = {
+        .hash = node_hash,
+        .compare = node_compare,
+        .remove_callback = node_remove,
 };
 /*----------------------------------------------------------------------------*/
@@ -87 +91 @@
     size_t size, size_t max_packet_size)
 {
+        /* We care about bandwidth only for interrupt and isochronous. */
+        if ((type != USB_TRANSFER_INTERRUPT)
+            && (type != USB_TRANSFER_ISOCHRONOUS)) {
+                return 0;
+        }
+
         const unsigned packet_count =
             (size + max_packet_size - 1) / max_packet_size;
@@ -120 +130 @@
 }
 /*----------------------------------------------------------------------------*/
-int bandwidth_init(bandwidth_t *instance, size_t bandwidth,
-    size_t (*usage_fnc)(usb_speed_t, usb_transfer_type_t, size_t, size_t))
+int usb_endpoint_manager_init(usb_endpoint_manager_t *instance,
+    size_t available_bandwidth)
 {
         assert(instance);
         fibril_mutex_initialize(&instance->guard);
-        instance->free = bandwidth;
-        instance->usage_fnc = usage_fnc;
+        fibril_condvar_initialize(&instance->change);
+        instance->free_bw = available_bandwidth;
         bool ht =
-            hash_table_create(&instance->reserved, BUCKET_COUNT, MAX_KEYS, &op);
+            hash_table_create(&instance->ep_table, BUCKET_COUNT, MAX_KEYS, &op);
         return ht ? EOK : ENOMEM;
 }
 /*----------------------------------------------------------------------------*/
-void bandwidth_destroy(bandwidth_t *instance)
-{
-        hash_table_destroy(&instance->reserved);
-}
-/*----------------------------------------------------------------------------*/
-int bandwidth_reserve(bandwidth_t *instance, usb_address_t address,
-    usb_endpoint_t endpoint, usb_direction_t direction, usb_speed_t speed,
-    usb_transfer_type_t transfer_type, size_t max_packet_size, size_t size,
-    unsigned interval)
-{
-        if (transfer_type != USB_TRANSFER_ISOCHRONOUS &&
-            transfer_type != USB_TRANSFER_INTERRUPT) {
-                return ENOTSUP;
-        }
-
-        assert(instance);
-        assert(instance->usage_fnc);
-
-        transfer_t trans = {
-                .address = address,
-                .endpoint = endpoint,
-                .direction = direction,
-        };
+void usb_endpoint_manager_destroy(usb_endpoint_manager_t *instance)
+{
+        hash_table_destroy(&instance->ep_table);
+}
+/*----------------------------------------------------------------------------*/
+int usb_endpoint_manager_register_ep(usb_endpoint_manager_t *instance,
+    endpoint_t *ep, size_t data_size)
+{
+        assert(ep);
+        size_t bw = bandwidth_count_usb11(ep->speed, ep->transfer_type,
+            data_size, ep->max_packet_size);
+        assert(instance);
+
+        unsigned long key[MAX_KEYS] =
+            {ep->address, ep->endpoint, ep->direction};
         fibril_mutex_lock(&instance->guard);
-        const size_t required =
-            instance->usage_fnc(speed, transfer_type, size, max_packet_size);
-
-        if (required > instance->free) {
+
+        link_t *item =
+            hash_table_find(&instance->ep_table, key);
+        if (item != NULL) {
+                fibril_mutex_unlock(&instance->guard);
+                return EEXISTS;
+        }
+
+        if (bw > instance->free_bw) {
                 fibril_mutex_unlock(&instance->guard);
                 return ENOSPC;
         }
 
-        link_t *item =
-            hash_table_find(&instance->reserved, (unsigned long*)&trans);
-        if (item != NULL) {
-                fibril_mutex_unlock(&instance->guard);
-                return EEXISTS;
-        }
-
-        transfer_status_t *status = malloc(sizeof(transfer_status_t));
-        if (status == NULL) {
+        node_t *node = malloc(sizeof(node_t));
+        if (node == NULL) {
                 fibril_mutex_unlock(&instance->guard);
                 return ENOMEM;
         }
 
-        status->transfer = trans;
-        status->required = required;
-        status->used = false;
-        link_initialize(&status->link);
-
-        hash_table_insert(&instance->reserved,
-            (unsigned long*)&status->transfer, &status->link);
-        instance->free -= required;
+        node->bw = bw;
+        node->ep = ep;
+        link_initialize(&node->link);
+
+        hash_table_insert(&instance->ep_table, key, &node->link);
+        instance->free_bw -= bw;
         fibril_mutex_unlock(&instance->guard);
+        fibril_condvar_broadcast(&instance->change);
         return EOK;
-        /* TODO: compute bandwidth used */
-}
-/*----------------------------------------------------------------------------*/
-int bandwidth_release(bandwidth_t *instance, usb_address_t address,
-    usb_endpoint_t endpoint, usb_direction_t direction)
-{
-        assert(instance);
-        transfer_t trans = {
-                .address = address,
-                .endpoint = endpoint,
-                .direction = direction,
-        };
+}
+/*----------------------------------------------------------------------------*/
+int usb_endpoint_manager_unregister_ep(usb_endpoint_manager_t *instance,
+    usb_address_t address, usb_endpoint_t endpoint, usb_direction_t direction)
+{
+        assert(instance);
+        unsigned long key[MAX_KEYS] = {address, endpoint, direction};
+
         fibril_mutex_lock(&instance->guard);
-        link_t *item =
-            hash_table_find(&instance->reserved, (unsigned long*)&trans);
+        link_t *item = hash_table_find(&instance->ep_table, key);
         if (item == NULL) {
                 fibril_mutex_unlock(&instance->guard);
@@ -207 +201 @@
         }
 
-        transfer_status_t *status =
-            hash_table_get_instance(item, transfer_status_t, link);
-
-        instance->free += status->required;
-
-        hash_table_remove(&instance->reserved,
-            (unsigned long*)&trans, MAX_KEYS);
+        node_t *node = hash_table_get_instance(item, node_t, link);
+        instance->free_bw += node->bw;
+        hash_table_remove(&instance->ep_table, key, MAX_KEYS);
 
         fibril_mutex_unlock(&instance->guard);
+        fibril_condvar_broadcast(&instance->change);
         return EOK;
-        /* TODO: compute bandwidth freed */
-}
-/*----------------------------------------------------------------------------*/
-int bandwidth_use(bandwidth_t *instance, usb_address_t address,
-    usb_endpoint_t endpoint, usb_direction_t direction)
-{
-        assert(instance);
-        transfer_t trans = {
-                .address = address,
-                .endpoint = endpoint,
-                .direction = direction,
-        };
+}
+/*----------------------------------------------------------------------------*/
+endpoint_t * usb_endpoint_manager_get_ep(usb_endpoint_manager_t *instance,
+    usb_address_t address, usb_endpoint_t endpoint, usb_direction_t direction,
+    size_t *bw)
+{
+        assert(instance);
+        unsigned long key[MAX_KEYS] = {address, endpoint, direction};
+
         fibril_mutex_lock(&instance->guard);
-        link_t *item =
-            hash_table_find(&instance->reserved, (unsigned long*)&trans);
-        int ret = EOK;
-        if (item != NULL) {
-                transfer_status_t *status =
-                    hash_table_get_instance(item, transfer_status_t, link);
-                assert(status);
-                if (status->used) {
-                        ret = EINPROGRESS;
-                }
-                status->used = true;
-        } else {
-                ret = EINVAL;
-        }
+        link_t *item = hash_table_find(&instance->ep_table, key);
+        if (item == NULL) {
+                fibril_mutex_unlock(&instance->guard);
+                return NULL;
+        }
+        node_t *node = hash_table_get_instance(item, node_t, link);
+        if (bw)
+                *bw = node->bw;
+
         fibril_mutex_unlock(&instance->guard);
-        return ret;
-}
-/*----------------------------------------------------------------------------*/
-int bandwidth_free(bandwidth_t *instance, usb_address_t address,
-    usb_endpoint_t endpoint, usb_direction_t direction)
-{
-        assert(instance);
-        transfer_t trans = {
-                .address = address,
-                .endpoint = endpoint,
-                .direction = direction,
-        };
-        fibril_mutex_lock(&instance->guard);
-        link_t *item =
-            hash_table_find(&instance->reserved, (unsigned long*)&trans);
-        int ret = EOK;
-        if (item != NULL) {
-                transfer_status_t *status =
-                    hash_table_get_instance(item, transfer_status_t, link);
-                assert(status);
-                if (!status->used) {
-                        ret = ENOENT;
-                }
-                status->used = false;
-        } else {
-                ret = EINVAL;
-        }
-        fibril_mutex_unlock(&instance->guard);
-        return ret;
-}
+        return node->ep;
+}

uspace/lib/usb/src/hub.c

@@ -142 +142 @@
             DEV_IFACE_ID(USBHC_DEV_IFACE),
             IPC_M_USBHC_RELEASE_ADDRESS, address);
+}
+
+static void unregister_control_endpoint_on_default_address(
+    usb_hc_connection_t *connection)
+{
+        usb_device_connection_t dev_conn;
+        int rc = usb_device_connection_initialize_on_default_address(&dev_conn,
+            connection);
+        if (rc != EOK) {
+                return;
+        }
+
+        usb_pipe_t ctrl_pipe;
+        rc = usb_pipe_initialize_default_control(&ctrl_pipe, &dev_conn);
+        if (rc != EOK) {
+                return;
+        }
+
+        usb_pipe_unregister(&ctrl_pipe, connection);
 }
 
@@ -235 +254 @@
                 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;
+                goto leave_release_default_address;
+        }
         rc = usb_pipe_probe_default_control(&ctrl_pipe);
         if (rc != EOK) {
@@ -244 +272 @@
         if (rc != EOK) {
                 rc = ENOTCONN;
-                goto leave_release_default_address;
+                goto leave_unregister_endpoint;
         }
 
@@ -256 +284 @@
 
         /*
+         * 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);
+
 
         /*
@@ -273 +316 @@
         }
 
+
+
         /*
          * And now inform the host controller about the handle.
@@ -308 +353 @@
         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);

uspace/lib/usb/src/pipesinit.c

@@ -121 +121 @@
     usb_endpoint_mapping_t *mapping, size_t mapping_count,
     usb_endpoint_description_t *found_endpoint,
-    int interface_number)
+    int interface_number, int interface_setting)
 {
         while (mapping_count > 0) {
@@ -127 +127 @@
                     || (mapping->interface_no == interface_number);
 
+                bool interface_setting_fits = (mapping->interface_setting < 0)
+                    || (mapping->interface_setting == interface_setting);
+
                 bool endpoint_descriptions_fits = endpoint_fits_description(
                     mapping->description, found_endpoint);
 
-                if (interface_number_fits && endpoint_descriptions_fits) {
+                if (interface_number_fits
+                    && interface_setting_fits
+                    && endpoint_descriptions_fits) {
                         return mapping;
                 }
@@ -181 +186 @@
          */
         usb_endpoint_mapping_t *ep_mapping = find_endpoint_mapping(mapping,
-            mapping_count, &description, interface->interface_number);
+            mapping_count, &description,
+            interface->interface_number, interface->alternate_setting);
         if (ep_mapping == NULL) {
                 return ENOENT;