Changeset a4e18e1 in mainline

Timestamp:

2011-04-07T15:04:16Z (14 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

Files:

• .bzrignore (modified) (1 diff)
• uspace/drv/ohci/batch.c (modified) (1 diff)
• uspace/drv/ohci/hc.c (modified) (2 diffs)
• uspace/drv/ohci/hc.h (modified) (3 diffs)
• uspace/drv/ohci/hw_struct/completion_codes.h (added)
• uspace/drv/ohci/hw_struct/endpoint_descriptor.h (added)
• uspace/drv/ohci/hw_struct/hcca.h (added)
• uspace/drv/ohci/hw_struct/iso_transfer_descriptor.h (added)
• uspace/drv/ohci/hw_struct/transfer_descriptor.h (added)
• uspace/drv/ohci/iface.c (modified) (2 diffs)
• uspace/drv/pciintel/pci.c (modified) (1 diff)
• uspace/drv/uhci-hcd/batch.c (modified) (8 diffs)
• uspace/drv/uhci-hcd/batch.h (modified) (2 diffs)
• uspace/drv/uhci-hcd/hc.c (modified) (7 diffs)
• uspace/drv/uhci-hcd/hc.h (modified) (2 diffs)
• uspace/drv/uhci-hcd/hw_struct/queue_head.h (modified) (1 diff)
• uspace/drv/uhci-hcd/iface.c (modified) (12 diffs)
• uspace/drv/uhci-hcd/transfer_list.h (modified) (1 diff)
• uspace/drv/uhci-hcd/utils/malloc32.h (modified) (1 diff)
• uspace/drv/uhci-rhd/main.c (modified) (5 diffs)
• uspace/drv/uhci-rhd/port.c (modified) (5 diffs)
• uspace/drv/uhci-rhd/root_hub.c (modified) (3 diffs)
• uspace/drv/uhci-rhd/root_hub.h (modified) (1 diff)
• uspace/drv/usbmid/explore.c (modified) (6 diffs)
• uspace/drv/usbmid/usbmid.c (modified) (5 diffs)
• uspace/drv/usbmid/usbmid.h (modified) (2 diffs)
• uspace/lib/usb/Makefile (modified) (1 diff)
• uspace/lib/usb/include/usb/devdrv.h (modified) (5 diffs)
• uspace/lib/usb/include/usb/host/batch.h (modified) (3 diffs)
• uspace/lib/usb/include/usb/host/device_keeper.h (modified) (3 diffs)
• uspace/lib/usb/include/usb/host/endpoint.h (added)
• uspace/lib/usb/include/usb/host/usb_endpoint_manager.h (moved) (moved from uspace/lib/usb/include/usb/host/bandwidth.h ) (2 diffs)
• uspace/lib/usb/include/usb/pipes.h (modified) (1 diff)
• uspace/lib/usb/src/devdrv.c (modified) (10 diffs)
• uspace/lib/usb/src/host/batch.c (modified) (2 diffs)
• uspace/lib/usb/src/host/device_keeper.c (modified) (12 diffs)
• uspace/lib/usb/src/host/endpoint.c (added)
• uspace/lib/usb/src/host/usb_endpoint_manager.c (moved) (moved from uspace/lib/usb/src/host/bandwidth.c ) (6 diffs)
• uspace/lib/usb/src/hub.c (modified) (6 diffs)
• uspace/lib/usb/src/pipesinit.c (modified) (3 diffs)
• uspace/srv/hw/irc/apic/apic.c (modified) (1 diff)
• uspace/srv/hw/irc/i8259/i8259.c (modified) (1 diff)

.bzrignore

@@ -93 +93 @@
 ./uspace/drv/usbhub/usbhub
 ./uspace/drv/usbhid/usbhid
+./uspace/drv/usbkbd/usbkbd
 ./uspace/drv/usbmid/usbmid
 ./uspace/drv/usbmouse/usbmouse

uspace/drv/ohci/batch.c

@@ -73 +73 @@
         CHECK_NULL_DISPOSE_RETURN(instance,
             "Failed to allocate batch instance.\n");
-        usb_transfer_batch_init(instance, target, transfer_type, speed, max_packet_size,
-            buffer, NULL, buffer_size, NULL, setup_size, func_in,
-            func_out, arg, fun, NULL);
+        usb_transfer_batch_init(instance, target, transfer_type, speed,
+            max_packet_size, buffer, NULL, buffer_size, NULL, setup_size,
+            func_in, func_out, arg, fun, NULL, NULL);
 
         if (buffer_size > 0) {

uspace/drv/ohci/hc.c

@@ -92 +92 @@
         instance->ddf_instance = fun;
         usb_device_keeper_init(&instance->manager);
-        ret = bandwidth_init(&instance->bandwidth, BANDWIDTH_AVAILABLE_USB11,
-            bandwidth_count_usb11);
-        CHECK_RET_RETURN(ret, "Failed to initialize bandwidth allocator: %s.\n",
+        ret = usb_endpoint_manager_init(&instance->ep_manager,
+            BANDWIDTH_AVAILABLE_USB11);
+        CHECK_RET_RETURN(ret, "Failed to initialize endpoint manager: %s.\n",
             ret, str_error(ret));
 
@@ -183 +183 @@
          * maintain reset for at least the time specified in USB spec (50 ms)*/
         async_usleep(50000);
+
+        /* turn off legacy emulation */
+        volatile uint32_t *ohci_emulation_reg =
+            (uint32_t*)((char*)instance->registers + 0x100);
+        usb_log_info("OHCI legacy register status %p: %x.\n",
+                ohci_emulation_reg, *ohci_emulation_reg);
+        *ohci_emulation_reg = 0;
+
 }
 /*----------------------------------------------------------------------------*/

uspace/drv/ohci/hc.h

@@ -42 +42 @@
 #include <usb/usb.h>
 #include <usb/host/device_keeper.h>
-#include <usb/host/bandwidth.h>
+#include <usb/host/usb_endpoint_manager.h>
 #include <usbhc_iface.h>
 
@@ -48 +48 @@
 #include "ohci_regs.h"
 #include "root_hub.h"
+#include "hw_struct/hcca.h"
 
 typedef struct hc {
@@ -55 +56 @@
         ddf_fun_t *ddf_instance;
         usb_device_keeper_t manager;
-        bandwidth_t bandwidth;
+        usb_endpoint_manager_t ep_manager;
         fid_t interrupt_emulator;
 } hc_t;

uspace/drv/ohci/iface.c

@@ -162 +162 @@
             address, endpoint, usb_str_transfer_type(transfer_type),
             usb_str_speed(speed), direction, size, max_packet_size, interval);
-        return bandwidth_reserve(&hc->bandwidth, address, endpoint, direction,
-            speed, transfer_type, max_packet_size, size, interval);
+        // TODO use real endpoint here!
+        return usb_endpoint_manager_register_ep(&hc->ep_manager,NULL, 0);
 }
 /*----------------------------------------------------------------------------*/
@@ -183 +183 @@
         usb_log_debug("Unregister endpoint %d:%d %d.\n",
             address, endpoint, direction);
-        return bandwidth_release(&hc->bandwidth, address, endpoint, direction);
-
-        return ENOTSUP;
+        return usb_endpoint_manager_unregister_ep(&hc->ep_manager, address,
+            endpoint, direction);
 }
 /*----------------------------------------------------------------------------*/

uspace/drv/pciintel/pci.c

@@ -107 +107 @@
         }
 
-        size_t i;
-        for (i = 0; i < dev_data->hw_resources.count; i++) {
-                if (dev_data->hw_resources.resources[i].type == INTERRUPT) {
-                        int irq = dev_data->hw_resources.resources[i].res.interrupt.irq;
-                        int rc = async_req_1_0(irc_phone, IRC_ENABLE_INTERRUPT, irq);
+        size_t i = 0;
+        hw_resource_list_t *res = &dev_data->hw_resources;
+        for (; i < res->count; i++) {
+                if (res->resources[i].type == INTERRUPT) {
+                        const int irq = res->resources[i].res.interrupt.irq;
+                        const int rc =
+                            async_req_1_0(irc_phone, IRC_ENABLE_INTERRUPT, irq);
                         if (rc != EOK) {
                                 async_hangup(irc_phone);

uspace/drv/uhci-hcd/batch.c

@@ -49 +49 @@
         td_t *tds;
         size_t transfers;
-        usb_device_keeper_t *manager;
 } uhci_batch_t;
 
@@ -73 +72 @@
  * @param[in] func_out function to call on outbound transaction completion
  * @param[in] arg additional parameter to func_in or func_out
- * @param[in] manager Pointer to toggle management structure.
+ * @param[in] ep Pointer to endpoint toggle management structure.
  * @return Valid pointer if all substructures were successfully created,
  * NULL otherwise.
@@ -86 +85 @@
     char* setup_buffer, size_t setup_size,
     usbhc_iface_transfer_in_callback_t func_in,
-    usbhc_iface_transfer_out_callback_t func_out, void *arg,
-    usb_device_keeper_t *manager
+    usbhc_iface_transfer_out_callback_t func_out, void *arg, endpoint_t *ep
     )
 {
@@ -105 +103 @@
         CHECK_NULL_DISPOSE_RETURN(instance,
             "Failed to allocate batch instance.\n");
-        usb_transfer_batch_init(instance, target, transfer_type, speed, max_packet_size,
+        usb_transfer_batch_init(instance, target,
+            transfer_type, speed, max_packet_size,
             buffer, NULL, buffer_size, NULL, setup_size, func_in,
-            func_out, arg, fun, NULL);
+            func_out, arg, fun, ep, NULL);
 
 
@@ -114 +113 @@
             "Failed to allocate batch instance.\n");
         bzero(data, sizeof(uhci_batch_t));
-        data->manager = manager;
         instance->private_data = data;
 
@@ -180 +178 @@
                             instance, i, data->tds[i].status);
                         td_print_status(&data->tds[i]);
-
-                        usb_device_keeper_set_toggle(data->manager,
-                            instance->target, instance->direction,
-                            td_toggle(&data->tds[i]));
+                        if (instance->ep != NULL)
+                                endpoint_toggle_set(instance->ep,
+                                    td_toggle(&data->tds[i]));
                         if (i > 0)
                                 goto substract_ret;
@@ -310 +307 @@
 
         const bool low_speed = instance->speed == USB_SPEED_LOW;
-        int toggle = usb_device_keeper_get_toggle(
-            data->manager, instance->target, instance->direction);
+        int toggle = endpoint_toggle_get(instance->ep);
         assert(toggle == 0 || toggle == 1);
 
@@ -342 +338 @@
         }
         td_set_ioc(&data->tds[transfer - 1]);
-        usb_device_keeper_set_toggle(data->manager, instance->target,
-            instance->direction, toggle);
+        endpoint_toggle_set(instance->ep, toggle);
 }
 /*----------------------------------------------------------------------------*/

uspace/drv/uhci-hcd/batch.h

@@ -35 +35 @@
 #define DRV_UHCI_BATCH_H
 
-#include <adt/list.h>
-
 #include <usbhc_iface.h>
 #include <usb/usb.h>
 #include <usb/host/device_keeper.h>
+#include <usb/host/endpoint.h>
 #include <usb/host/batch.h>
 
@@ -57 +56 @@
     usbhc_iface_transfer_out_callback_t func_out,
                 void *arg,
-                usb_device_keeper_t *manager
+                endpoint_t *ep
                 );
 

uspace/drv/uhci-hcd/hc.c

@@ -66 +66 @@
 static int hc_interrupt_emulator(void *arg);
 static int hc_debug_checker(void *arg);
-
+#if 0
 static bool usb_is_allowed(
     bool low_speed, usb_transfer_type_t transfer, size_t size);
+#endif
 /*----------------------------------------------------------------------------*/
 /** Initialize UHCI hcd driver structure
@@ -239 +240 @@
         usb_log_debug("Initialized device manager.\n");
 
-        ret = bandwidth_init(&instance->bandwidth, BANDWIDTH_AVAILABLE_USB11,
-            bandwidth_count_usb11);
+        ret =
+            usb_endpoint_manager_init(&instance->ep_manager,
+                BANDWIDTH_AVAILABLE_USB11);
         assert(ret == EOK);
 
@@ -326 +328 @@
         assert(instance);
         assert(batch);
-        const int low_speed = (batch->speed == USB_SPEED_LOW);
-        if (!usb_is_allowed(
-            low_speed, batch->transfer_type, batch->max_packet_size)) {
-                usb_log_error("Invalid USB transfer specified %s %d %zu.\n",
-                    usb_str_speed(batch->speed), batch->transfer_type,
-                    batch->max_packet_size);
-                return ENOTSUP;
-        }
-        /* Check available bandwidth */
-        if (batch->transfer_type == USB_TRANSFER_INTERRUPT ||
-            batch->transfer_type == USB_TRANSFER_ISOCHRONOUS) {
-                int ret =
-                    bandwidth_use(&instance->bandwidth, batch->target.address,
-                    batch->target.endpoint, batch->direction);
-                if (ret != EOK) {
-                        usb_log_warning("Failed(%d) to use reserved bw: %s.\n",
-                            ret, str_error(ret));
-                }
-        }
 
         transfer_list_t *list =
@@ -398 +381 @@
                         case USB_TRANSFER_INTERRUPT:
                         case USB_TRANSFER_ISOCHRONOUS: {
+/*
                                 int ret = bandwidth_free(&instance->bandwidth,
                                     batch->target.address,
@@ -406 +390 @@
                                             "reserved bw: %s.\n", ret,
                                             str_error(ret));
+*/
                                 }
                         default:
@@ -529 +514 @@
  * @return True if transaction is allowed by USB specs, false otherwise
  */
+#if 0
 bool usb_is_allowed(
     bool low_speed, usb_transfer_type_t transfer, size_t size)
@@ -546 +532 @@
         return false;
 }
+#endif
 /**
  * @}

uspace/drv/uhci-hcd/hc.h

@@ -43 +43 @@
 #include <usbhc_iface.h>
 #include <usb/host/device_keeper.h>
-#include <usb/host/bandwidth.h>
+#include <usb/host/usb_endpoint_manager.h>
 
 #include "batch.h"
@@ -85 +85 @@
 typedef struct hc {
         usb_device_keeper_t manager;
-        bandwidth_t bandwidth;
+        usb_endpoint_manager_t ep_manager;
 
         regs_t *registers;

uspace/drv/uhci-hcd/hw_struct/queue_head.h

@@ -39 +39 @@
 
 #include "link_pointer.h"
-#include "utils/malloc32.h"
 
 typedef struct queue_head {

uspace/drv/uhci-hcd/iface.c

@@ -36 +36 @@
 
 #include <usb/debug.h>
+#include <usb/host/endpoint.h>
 
 #include "iface.h"
@@ -54 +55 @@
         usb_device_keeper_reserve_default_address(&hc->manager, speed);
         return EOK;
+#if 0
+        endpoint_t *ep = malloc(sizeof(endpoint_t));
+        if (ep == NULL)
+                return ENOMEM;
+        const size_t max_packet_size = speed == USB_SPEED_LOW ? 8 : 64;
+        endpoint_init(ep, USB_TRANSFER_CONTROL, speed, max_packet_size);
+        int ret;
+try_retgister:
+        ret = usb_endpoint_manager_register_ep(&hc->ep_manager,
+            USB_ADDRESS_DEFAULT, 0, USB_DIRECTION_BOTH, ep, endpoint_destroy, 0);
+        if (ret == EEXISTS) {
+                async_usleep(1000);
+                goto try_retgister;
+        }
+        if (ret != EOK) {
+                endpoint_destroy(ep);
+        }
+        return ret;
+#endif
 }
 /*----------------------------------------------------------------------------*/
@@ -67 +87 @@
         assert(hc);
         usb_log_debug("Default address release.\n");
+//      return usb_endpoint_manager_unregister_ep(&hc->ep_manager,
+//          USB_ADDRESS_DEFAULT, 0, USB_DIRECTION_BOTH);
         usb_device_keeper_release_default_address(&hc->manager);
         return EOK;
@@ -137 +159 @@
         const usb_speed_t speed =
             usb_device_keeper_get_speed(&hc->manager, address);
-        size_t size = max_packet_size;
+        const size_t size =
+            (transfer_type == USB_TRANSFER_INTERRUPT
+            || transfer_type == USB_TRANSFER_ISOCHRONOUS) ?
+            max_packet_size : 0;
+        int ret;
+
+        endpoint_t *ep = malloc(sizeof(endpoint_t));
+        if (ep == NULL)
+                return ENOMEM;
+        ret = endpoint_init(ep, address, endpoint, direction,
+            transfer_type, speed, max_packet_size);
+        if (ret != EOK) {
+                free(ep);
+                return ret;
+        }
 
         usb_log_debug("Register endpoint %d:%d %s %s(%d) %zu(%zu) %u.\n",
             address, endpoint, usb_str_transfer_type(transfer_type),
             usb_str_speed(speed), direction, size, max_packet_size, interval);
-        return bandwidth_reserve(&hc->bandwidth, address, endpoint, direction,
-            speed, transfer_type, max_packet_size, size, interval);
+
+        ret = usb_endpoint_manager_register_ep(&hc->ep_manager, ep, size);
+        if (ret != EOK) {
+                endpoint_destroy(ep);
+        } else {
+                usb_device_keeper_add_ep(&hc->manager, address, ep);
+        }
+        return ret;
 }
 /*----------------------------------------------------------------------------*/
@@ -154 +196 @@
         usb_log_debug("Unregister endpoint %d:%d %d.\n",
             address, endpoint, direction);
-        return bandwidth_release(&hc->bandwidth, address, endpoint, direction);
+        return usb_endpoint_manager_unregister_ep(&hc->ep_manager, address,
+            endpoint, direction);
 }
 /*----------------------------------------------------------------------------*/
@@ -175 +218 @@
         hc_t *hc = fun_to_hc(fun);
         assert(hc);
-        usb_speed_t speed =
-            usb_device_keeper_get_speed(&hc->manager, target.address);
 
         usb_log_debug("Interrupt OUT %d:%d %zu(%zu).\n",
             target.address, target.endpoint, size, max_packet_size);
 
+        size_t res_bw;
+        endpoint_t *ep = usb_endpoint_manager_get_ep(&hc->ep_manager,
+            target.address, target.endpoint, USB_DIRECTION_OUT, &res_bw);
+        if (ep == NULL) {
+                usb_log_error("Endpoint(%d:%d) not registered for INT OUT.\n",
+                        target.address, target.endpoint);
+                return ENOENT;
+        }
+        const size_t bw = bandwidth_count_usb11(ep->speed, ep->transfer_type,
+            size, ep->max_packet_size);
+        if (res_bw < bw)
+        {
+                usb_log_error("Endpoint(%d:%d) INT IN needs %zu bw "
+                    "but only %zu is reserved.\n",
+                    target.address, target.endpoint, bw, res_bw);
+                return ENOENT;
+        }
+        assert(ep->speed ==
+            usb_device_keeper_get_speed(&hc->manager, target.address));
+        assert(ep->max_packet_size == max_packet_size);
+        assert(ep->transfer_type == USB_TRANSFER_INTERRUPT);
+
         usb_transfer_batch_t *batch =
-            batch_get(fun, target, USB_TRANSFER_INTERRUPT, max_packet_size,
-                speed, data, size, NULL, 0, NULL, callback, arg, &hc->manager);
+            batch_get(fun, target, ep->transfer_type, ep->max_packet_size,
+                ep->speed, data, size, NULL, 0, NULL, callback, arg, ep);
         if (!batch)
                 return ENOMEM;
@@ -212 +275 @@
         hc_t *hc = fun_to_hc(fun);
         assert(hc);
-        usb_speed_t speed =
-            usb_device_keeper_get_speed(&hc->manager, target.address);
+
         usb_log_debug("Interrupt IN %d:%d %zu(%zu).\n",
             target.address, target.endpoint, size, max_packet_size);
 
+        size_t res_bw;
+        endpoint_t *ep = usb_endpoint_manager_get_ep(&hc->ep_manager,
+            target.address, target.endpoint, USB_DIRECTION_IN, &res_bw);
+        if (ep == NULL) {
+                usb_log_error("Endpoint(%d:%d) not registered for INT IN.\n",
+                    target.address, target.endpoint);
+                return ENOENT;
+        }
+        const size_t bw = bandwidth_count_usb11(ep->speed, ep->transfer_type,
+            size, ep->max_packet_size);
+        if (res_bw < bw)
+        {
+                usb_log_error("Endpoint(%d:%d) INT IN needs %zu bw "
+                    "but only %zu bw is reserved.\n",
+                    target.address, target.endpoint, bw, res_bw);
+                return ENOENT;
+        }
+
+        assert(ep->speed ==
+            usb_device_keeper_get_speed(&hc->manager, target.address));
+        assert(ep->max_packet_size == max_packet_size);
+        assert(ep->transfer_type == USB_TRANSFER_INTERRUPT);
+
         usb_transfer_batch_t *batch =
-            batch_get(fun, target, USB_TRANSFER_INTERRUPT, max_packet_size,
-                speed, data, size, NULL, 0, callback, NULL, arg, &hc->manager);
+            batch_get(fun, target, ep->transfer_type, ep->max_packet_size,
+                ep->speed, data, size, NULL, 0, callback, NULL, arg, ep);
         if (!batch)
                 return ENOMEM;
@@ -248 +333 @@
         hc_t *hc = fun_to_hc(fun);
         assert(hc);
-        usb_speed_t speed =
-            usb_device_keeper_get_speed(&hc->manager, target.address);
 
         usb_log_debug("Bulk OUT %d:%d %zu(%zu).\n",
             target.address, target.endpoint, size, max_packet_size);
 
+        endpoint_t *ep = usb_endpoint_manager_get_ep(&hc->ep_manager,
+            target.address, target.endpoint, USB_DIRECTION_OUT, NULL);
+        if (ep == NULL) {
+                usb_log_error("Endpoint(%d:%d) not registered for BULK OUT.\n",
+                        target.address, target.endpoint);
+                return ENOENT;
+        }
+        assert(ep->speed ==
+            usb_device_keeper_get_speed(&hc->manager, target.address));
+        assert(ep->max_packet_size == max_packet_size);
+        assert(ep->transfer_type == USB_TRANSFER_BULK);
+
         usb_transfer_batch_t *batch =
-            batch_get(fun, target, USB_TRANSFER_BULK, max_packet_size, speed,
-                data, size, NULL, 0, NULL, callback, arg, &hc->manager);
+            batch_get(fun, target, ep->transfer_type, ep->max_packet_size,
+                ep->speed, data, size, NULL, 0, NULL, callback, arg, ep);
         if (!batch)
                 return ENOMEM;
@@ -285 +380 @@
         hc_t *hc = fun_to_hc(fun);
         assert(hc);
-        usb_speed_t speed =
-            usb_device_keeper_get_speed(&hc->manager, target.address);
         usb_log_debug("Bulk IN %d:%d %zu(%zu).\n",
             target.address, target.endpoint, size, max_packet_size);
 
+        endpoint_t *ep = usb_endpoint_manager_get_ep(&hc->ep_manager,
+            target.address, target.endpoint, USB_DIRECTION_IN, NULL);
+        if (ep == NULL) {
+                usb_log_error("Endpoint(%d:%d) not registered for BULK IN.\n",
+                        target.address, target.endpoint);
+                return ENOENT;
+        }
+        assert(ep->speed ==
+            usb_device_keeper_get_speed(&hc->manager, target.address));
+        assert(ep->max_packet_size == max_packet_size);
+        assert(ep->transfer_type == USB_TRANSFER_BULK);
+
         usb_transfer_batch_t *batch =
-            batch_get(fun, target, USB_TRANSFER_BULK, max_packet_size, speed,
-                data, size, NULL, 0, callback, NULL, arg, &hc->manager);
+            batch_get(fun, target, ep->transfer_type, ep->max_packet_size,
+                ep->speed, data, size, NULL, 0, callback, NULL, arg, ep);
         if (!batch)
                 return ENOMEM;
@@ -328 +433 @@
         usb_log_debug("Control WRITE (%d) %d:%d %zu(%zu).\n",
             speed, target.address, target.endpoint, size, max_packet_size);
+        endpoint_t *ep = usb_endpoint_manager_get_ep(&hc->ep_manager,
+            target.address, target.endpoint, USB_DIRECTION_BOTH, NULL);
+        if (ep == NULL) {
+                usb_log_warning("Endpoint(%d:%d) not registered for CONTROL.\n",
+                        target.address, target.endpoint);
+        }
 
         if (setup_size != 8)
@@ -334 +445 @@
         usb_transfer_batch_t *batch =
             batch_get(fun, target, USB_TRANSFER_CONTROL, max_packet_size, speed,
-                data, size, setup_data, setup_size, NULL, callback, arg,
-                &hc->manager);
+                data, size, setup_data, setup_size, NULL, callback, arg, ep);
         if (!batch)
                 return ENOMEM;
@@ -373 +483 @@
         usb_log_debug("Control READ(%d) %d:%d %zu(%zu).\n",
             speed, target.address, target.endpoint, size, max_packet_size);
+        endpoint_t *ep = usb_endpoint_manager_get_ep(&hc->ep_manager,
+            target.address, target.endpoint, USB_DIRECTION_BOTH, NULL);
+        if (ep == NULL) {
+                usb_log_warning("Endpoint(%d:%d) not registered for CONTROL.\n",
+                        target.address, target.endpoint);
+        }
         usb_transfer_batch_t *batch =
             batch_get(fun, target, USB_TRANSFER_CONTROL, max_packet_size, speed,
-                data, size, setup_data, setup_size, callback, NULL, arg,
-                &hc->manager);
+                data, size, setup_data, setup_size, callback, NULL, arg, ep);
         if (!batch)
                 return ENOMEM;

uspace/drv/uhci-hcd/transfer_list.h

@@ -39 +39 @@
 #include "batch.h"
 #include "hw_struct/queue_head.h"
+#include "utils/malloc32.h"
 
 typedef struct transfer_list

uspace/drv/uhci-hcd/utils/malloc32.h

@@ -36 +36 @@
 
 #include <assert.h>
+#include <errno.h>
 #include <malloc.h>
 #include <mem.h>

uspace/drv/uhci-rhd/main.c

@@ -44 +44 @@
 
 #define NAME "uhci-rhd"
+
 static int hc_get_my_registers(ddf_dev_t *dev,
     uintptr_t *io_reg_address, size_t *io_reg_size);
-#if 0
 /*----------------------------------------------------------------------------*/
-static int usb_iface_get_hc_handle(ddf_fun_t *fun, devman_handle_t *handle)
-{
-        assert(fun);
-        assert(fun->driver_data);
-        assert(handle);
-
-        *handle = ((uhci_root_hub_t*)fun->driver_data)->hc_handle;
-
-        return EOK;
-}
-/*----------------------------------------------------------------------------*/
-static usb_iface_t uhci_rh_usb_iface = {
-        .get_hc_handle = usb_iface_get_hc_handle,
-        .get_address = usb_iface_get_address_hub_impl
-};
-/*----------------------------------------------------------------------------*/
-static ddf_dev_ops_t uhci_rh_ops = {
-        .interfaces[USB_DEV_IFACE] = &uhci_rh_usb_iface,
-};
-#endif
-/*----------------------------------------------------------------------------*/
-/** Initialize a new ddf driver instance of UHCI root hub.
- *
- * @param[in] device DDF instance of the device to initialize.
- * @return Error code.
- */
-static int uhci_rh_add_device(ddf_dev_t *device)
-{
-        if (!device)
-                return ENOTSUP;
-
-        usb_log_debug2("%s called device %d\n", __FUNCTION__, device->handle);
-
-        //device->ops = &uhci_rh_ops;
-        uintptr_t io_regs = 0;
-        size_t io_size = 0;
-
-        int ret = hc_get_my_registers(device, &io_regs, &io_size);
-        if (ret != EOK) {
-                usb_log_error("Failed to get registers from parent HC: %s.\n",
-                    str_error(ret));
-        }
-        usb_log_debug("I/O regs at %#X (size %zu).\n", io_regs, io_size);
-
-        uhci_root_hub_t *rh = malloc(sizeof(uhci_root_hub_t));
-        if (!rh) {
-                usb_log_error("Failed to allocate driver instance.\n");
-                return ENOMEM;
-        }
-
-        ret = uhci_root_hub_init(rh, (void*)io_regs, io_size, device);
-        if (ret != EOK) {
-                usb_log_error("Failed to initialize driver instance: %s.\n",
-                    str_error(ret));
-                free(rh);
-                return ret;
-        }
-
-        device->driver_data = rh;
-        usb_log_info("Controlling root hub `%s' (%llu).\n",
-            device->name, device->handle);
-        return EOK;
-}
+static int uhci_rh_add_device(ddf_dev_t *device);
 /*----------------------------------------------------------------------------*/
 static driver_ops_t uhci_rh_driver_ops = {
@@ -132 +70 @@
 {
         printf(NAME ": HelenOS UHCI root hub driver.\n");
+        usb_log_enable(USB_LOG_LEVEL_DEFAULT, NAME);
+        return ddf_driver_main(&uhci_rh_driver);
+}
+/*----------------------------------------------------------------------------*/
+/** Initialize a new ddf driver instance of UHCI root hub.
+ *
+ * @param[in] device DDF instance of the device to initialize.
+ * @return Error code.
+ */
+static int uhci_rh_add_device(ddf_dev_t *device)
+{
+        if (!device)
+                return EINVAL;
 
-        usb_log_enable(USB_LOG_LEVEL_DEFAULT, NAME);
+        usb_log_debug2("%s called device %d\n", __FUNCTION__, device->handle);
 
-        return ddf_driver_main(&uhci_rh_driver);
+        uintptr_t io_regs = 0;
+        size_t io_size = 0;
+        uhci_root_hub_t *rh = NULL;
+        int ret = EOK;
+
+#define CHECK_RET_FREE_RH_RETURN(ret, message...) \
+if (ret != EOK) { \
+        usb_log_error(message); \
+        if (rh) \
+                free(rh); \
+        return ret; \
+} else (void)0
+
+        ret = hc_get_my_registers(device, &io_regs, &io_size);
+        CHECK_RET_FREE_RH_RETURN(ret,
+            "Failed(%d) to get registers from HC: %s.\n", ret, str_error(ret));
+        usb_log_debug("I/O regs at %#x (size %zu).\n", io_regs, io_size);
+
+        rh = malloc(sizeof(uhci_root_hub_t));
+        ret = (rh == NULL) ? ENOMEM : EOK;
+        CHECK_RET_FREE_RH_RETURN(ret,
+            "Failed to allocate rh driver instance.\n");
+
+        ret = uhci_root_hub_init(rh, (void*)io_regs, io_size, device);
+        CHECK_RET_FREE_RH_RETURN(ret,
+            "Failed(%d) to initialize rh driver instance: %s.\n",
+            ret, str_error(ret));
+
+        device->driver_data = rh;
+        usb_log_info("Controlling root hub '%s' (%llu).\n",
+            device->name, device->handle);
+        return EOK;
 }
 /*----------------------------------------------------------------------------*/
@@ -156 +138 @@
         }
 
-        int rc;
-
         hw_resource_list_t hw_resources;
-        rc = hw_res_get_resource_list(parent_phone, &hw_resources);
-        if (rc != EOK) {
-                goto leave;
+        int ret = hw_res_get_resource_list(parent_phone, &hw_resources);
+        if (ret != EOK) {
+                async_hangup(parent_phone);
+                return ret;
         }
 
@@ -168 +149 @@
         bool io_found = false;
 
-        size_t i;
-        for (i = 0; i < hw_resources.count; i++) {
+        size_t i = 0;
+        for (; i < hw_resources.count; i++) {
                 hw_resource_t *res = &hw_resources.resources[i];
-                switch (res->type)
-                {
-                case IO_RANGE:
-                        io_address = (uintptr_t) res->res.io_range.address;
+                if (res->type == IO_RANGE) {
+                        io_address = res->res.io_range.address;
                         io_size = res->res.io_range.size;
                         io_found = true;
-
-                default:
-                        break;
                 }
         }
+        async_hangup(parent_phone);
 
         if (!io_found) {
-                rc = ENOENT;
-                goto leave;
+                return ENOENT;
         }
-
         if (io_reg_address != NULL) {
                 *io_reg_address = io_address;
@@ -194 +169 @@
                 *io_reg_size = io_size;
         }
-        rc = EOK;
-
-leave:
-        async_hangup(parent_phone);
-        return rc;
+        return EOK;
 }
 /**

uspace/drv/uhci-rhd/port.c

@@ -43 +43 @@
 #include "port.h"
 
+static int uhci_port_check(void *port);
+static int uhci_port_reset_enable(int portno, void *arg);
 static int uhci_port_new_device(uhci_port_t *port, usb_speed_t speed);
 static int uhci_port_remove_device(uhci_port_t *port);
 static int uhci_port_set_enabled(uhci_port_t *port, bool enabled);
-static int uhci_port_check(void *port);
-static int uhci_port_reset_enable(int portno, void *arg);
 static void uhci_port_print_status(
     uhci_port_t *port, const port_status_t value);
@@ -74 +74 @@
         pio_write_16(port->address, value);
 }
-
 /*----------------------------------------------------------------------------*/
 /** Initialize UHCI root hub port instance.
@@ -259 +258 @@
 
         usb_address_t dev_addr;
-        int rc = usb_hc_new_device_wrapper(port->rh, &port->hc_connection,
+        int ret = usb_hc_new_device_wrapper(port->rh, &port->hc_connection,
             speed, uhci_port_reset_enable, port->number, port,
             &dev_addr, &port->attached_device, NULL, NULL, NULL);
 
-        if (rc != EOK) {
+        if (ret != EOK) {
                 usb_log_error("%s: Failed(%d) to add device: %s.\n",
-                    port->id_string, rc, str_error(rc));
+                    port->id_string, ret, str_error(ret));
                 uhci_port_set_enabled(port, false);
-                return rc;
+                return ret;
         }
 
@@ -287 +286 @@
 int uhci_port_remove_device(uhci_port_t *port)
 {
-        usb_log_error("%s: Don't know how to remove device %d.\n",
-            port->id_string, (unsigned int)port->attached_device);
-        return EOK;
+        usb_log_error("%s: Don't know how to remove device %llu.\n",
+            port->id_string, port->attached_device);
+        return ENOTSUP;
 }
 /*----------------------------------------------------------------------------*/
@@ -341 +340 @@
             (value & STATUS_CONNECTED_CHANGED) ? " CONNECTED-CHANGE," : "",
             (value & STATUS_CONNECTED) ? " CONNECTED," : "",
-            (value & STATUS_ALWAYS_ONE) ? " ALWAYS ONE" : " ERROR: NO ALWAYS ONE"
+            (value & STATUS_ALWAYS_ONE) ? " ALWAYS ONE" : " ERR: NO ALWAYS ONE"
         );
 }

uspace/drv/uhci-rhd/root_hub.c

@@ -51 +51 @@
         assert(instance);
         assert(rh);
-        int ret;
 
         /* Allow access to root hub port registers */
         assert(sizeof(port_status_t) * UHCI_ROOT_HUB_PORT_COUNT <= size);
         port_status_t *regs;
-        ret = pio_enable(addr, size, (void**)&regs);
+        int ret = pio_enable(addr, size, (void**)&regs);
         if (ret < 0) {
                 usb_log_error(
@@ -84 +83 @@
  *
  * @param[in] instance Root hub structure to use.
- * @return Error code.
  */
-int uhci_root_hub_fini(uhci_root_hub_t* instance)
+void uhci_root_hub_fini(uhci_root_hub_t* instance)
 {
         assert(instance);
@@ -93 +91 @@
                 uhci_port_fini(&instance->ports[i]);
         }
-        return EOK;
 }
 /*----------------------------------------------------------------------------*/

uspace/drv/uhci-rhd/root_hub.h

@@ -50 +50 @@
   uhci_root_hub_t *instance, void *addr, size_t size, ddf_dev_t *rh);
 
-int uhci_root_hub_fini(uhci_root_hub_t *instance);
+void uhci_root_hub_fini(uhci_root_hub_t *instance);
 #endif
 /**

uspace/drv/usbmid/explore.c

@@ -48 +48 @@
 };
 
-/** Find starting indexes of all interface descriptors in a configuration.
- *
- * @param config_descriptor Full configuration descriptor.
- * @param config_descriptor_size Size of @p config_descriptor in bytes.
- * @param interface_positions Array where to store indexes of interfaces.
- * @param interface_count Size of @p interface_positions array.
- * @return Number of found interfaces.
- * @retval (size_t)-1 Error occured.
- */
-static size_t find_interface_descriptors(uint8_t *config_descriptor,
-    size_t config_descriptor_size,
-    size_t *interface_positions, size_t interface_count)
+/** Tell whether given interface is already in the list.
+ *
+ * @param list List of usbmid_interface_t members to be searched.
+ * @param interface_no Interface number caller is looking for.
+ * @return Interface @p interface_no is already present in the list.
+ */
+static bool interface_in_list(link_t *list, int interface_no)
 {
-        if (interface_count == 0) {
-                return (size_t) -1;
-        }
-
+        link_t *l;
+        for (l = list->next; l != list; l = l->next) {
+                usbmid_interface_t *iface
+                    = list_get_instance(l, usbmid_interface_t, link);
+                if (iface->interface_no == interface_no) {
+                        return true;
+                }
+        }
+
+        return false;
+}
+
+/** Create list of interfaces from configuration descriptor.
+ *
+ * @param config_descriptor Configuration descriptor.
+ * @param config_descriptor_size Size of configuration descriptor in bytes.
+ * @param list List where to add the interfaces.
+ */
+static void create_interfaces(uint8_t *config_descriptor,
+    size_t config_descriptor_size, link_t *list)
+{
         usb_dp_parser_data_t data = {
                 .data = config_descriptor,
@@ -75 +87 @@
         };
 
-        uint8_t *interface = usb_dp_get_nested_descriptor(&parser, &data,
+        uint8_t *interface_ptr = usb_dp_get_nested_descriptor(&parser, &data,
             data.data);
-        if (interface == NULL) {
-                return (size_t) -1;
-        }
-        if (interface[1] != USB_DESCTYPE_INTERFACE) {
-                return (size_t) -1;
-        }
-
-        size_t found_interfaces = 0;
-        interface_positions[found_interfaces] = interface - config_descriptor;
-        found_interfaces++;
-
-        while (interface != NULL) {
-                interface = usb_dp_get_sibling_descriptor(&parser, &data,
-                    data.data, interface);
-                if ((interface != NULL)
-                    && (found_interfaces < interface_count)
-                    && (interface[1] == USB_DESCTYPE_INTERFACE)) {
-                        interface_positions[found_interfaces]
-                            = interface - config_descriptor;
-                        found_interfaces++;
-                }
-        }
-
-        return found_interfaces;
+        if (interface_ptr == NULL) {
+                return;
+        }
+
+        do {
+                if (interface_ptr[1] != USB_DESCTYPE_INTERFACE) {
+                        goto next_descriptor;
+                }
+
+                usb_standard_interface_descriptor_t *interface
+                    = (usb_standard_interface_descriptor_t *) interface_ptr;
+
+                /* Skip alternate interfaces. */
+                if (!interface_in_list(list, interface->interface_number)) {
+                        usbmid_interface_t *iface
+                            = malloc(sizeof(usbmid_interface_t));
+                        if (iface == NULL) {
+                                break;
+                        }
+                        link_initialize(&iface->link);
+                        iface->fun = NULL;
+                        iface->interface_no = interface->interface_number;
+                        iface->interface = interface;
+
+                        list_append(&iface->link, list);
+                }
+
+                /* TODO: add the alternatives and create match ids from them
+                 * as well.
+                 */
+
+next_descriptor:
+                interface_ptr = usb_dp_get_sibling_descriptor(&parser, &data,
+                    data.data, interface_ptr);
+
+        } while (interface_ptr != NULL);
+
 }
 
@@ -130 +155 @@
             (usb_standard_configuration_descriptor_t *) config_descriptor_raw;
 
-        size_t *interface_descriptors
-            = malloc(sizeof(size_t) * config_descriptor->interface_count);
-        if (interface_descriptors == NULL) {
-                usb_log_error("Out of memory (wanted %zuB).\n",
-                    sizeof(size_t) * config_descriptor->interface_count);
-                free(config_descriptor_raw);
-                return false;
-        }
-        size_t interface_descriptors_count
-            = find_interface_descriptors(
-            config_descriptor_raw, config_descriptor_size,
-            interface_descriptors, config_descriptor->interface_count);
-
-        if (interface_descriptors_count == (size_t) -1) {
-                usb_log_error("Problem parsing configuration descriptor.\n");
-                free(interface_descriptors);
-                return false;
-        }
-
         /* Select the first configuration */
         rc = usb_request_set_configuration(&dev->ctrl_pipe,
@@ -155 +161 @@
                 usb_log_error("Failed to set device configuration: %s.\n",
                     str_error(rc));
-                free(interface_descriptors);
-                return false;
-        }
-
+                return false;
+        }
 
         /* Create control function */
@@ -164 +168 @@
         if (ctl_fun == NULL) {
                 usb_log_error("Failed to create control function.\n");
-                free(interface_descriptors);
                 return false;
         }
@@ -174 +177 @@
                 usb_log_error("Failed to bind control function: %s.\n",
                     str_error(rc));
-                free(interface_descriptors);
-                return false;
-        }
-
-        /* Spawn interface children */
-        size_t i;
-        for (i = 0; i < interface_descriptors_count; i++) {
-                usb_standard_interface_descriptor_t *interface
-                    = (usb_standard_interface_descriptor_t *)
-                    (config_descriptor_raw + interface_descriptors[i]);
-                usb_log_debug2("Interface descriptor at index %zu (type %d).\n",
-                    interface_descriptors[i], (int) interface->descriptor_type);
+                return false;
+        }
+
+        /* Create interface children. */
+        link_t interface_list;
+        list_initialize(&interface_list);
+        create_interfaces(config_descriptor_raw, config_descriptor_size,
+            &interface_list);
+
+        link_t *link;
+        for (link = interface_list.next; link != &interface_list;
+            link = link->next) {
+                usbmid_interface_t *iface = list_get_instance(link,
+                    usbmid_interface_t, link);
+
                 usb_log_info("Creating child for interface %d (%s).\n",
-                    (int) interface->interface_number,
-                    usb_str_class(interface->interface_class));
-                rc = usbmid_spawn_interface_child(dev, &dev->descriptors.device,
-                    interface);
+                    (int) iface->interface_no,
+                    usb_str_class(iface->interface->interface_class));
+
+                rc = usbmid_spawn_interface_child(dev, iface,
+                    &dev->descriptors.device, iface->interface);
                 if (rc != EOK) {
                         usb_log_error("Failed to create interface child: %s.\n",

uspace/drv/usbmid/usbmid.c

@@ -79 +79 @@
 };
 
-/** Create new interface for USB MID device.
- *
- * @param fun Backing generic DDF device function (representing interface).
- * @param iface_no Interface number.
- * @return New interface.
- * @retval NULL Error occured.
- */
-usbmid_interface_t *usbmid_interface_create(ddf_fun_t *fun, int iface_no)
-{
-        usbmid_interface_t *iface = malloc(sizeof(usbmid_interface_t));
-        if (iface == NULL) {
-                usb_log_error("Out of memory (wanted %zuB).\n",
-                    sizeof(usbmid_interface_t));
-                return NULL;
-        }
-
-        iface->fun = fun;
-        iface->interface_no = iface_no;
-
-        return iface;
-}
-
 
 /** Spawn new child device from one interface.
  *
  * @param parent Parent MID device.
+ * @param iface Interface information.
  * @param device_descriptor Device descriptor.
  * @param interface_descriptor Interface descriptor.
@@ -110 +89 @@
  */
 int usbmid_spawn_interface_child(usb_device_t *parent,
+    usbmid_interface_t *iface,
     const usb_standard_device_descriptor_t *device_descriptor,
     const usb_standard_interface_descriptor_t *interface_descriptor)
@@ -115 +95 @@
         ddf_fun_t *child = NULL;
         char *child_name = NULL;
-        usbmid_interface_t *child_as_interface = NULL;
         int rc;
 
@@ -137 +116 @@
         }
 
+        iface->fun = child;
 
-
-        child_as_interface = usbmid_interface_create(child,
-            (int) interface_descriptor->interface_number);
-        if (child_as_interface == NULL) {
-                rc = ENOMEM;
-                goto error_leave;
-        }
-
-        child->driver_data = child_as_interface;
+        child->driver_data = iface;
         child->ops = &child_device_ops;
 
@@ -172 +144 @@
                 free(child_name);
         }
-        if (child_as_interface != NULL) {
-                free(child_as_interface);
-        }
 
         return rc;

uspace/drv/usbmid/usbmid.h

@@ -37 +37 @@
 #define USBMID_H_
 
+#include <adt/list.h>
 #include <ddf/driver.h>
 #include <usb/usb.h>
@@ -49 +50 @@
         /** Function container. */
         ddf_fun_t *fun;
-
+        /** Interface descriptor. */
+        usb_standard_interface_descriptor_t *interface;
         /** Interface number. */
         int interface_no;
+        /** List link. */
+        link_t link;
 } usbmid_interface_t;
 
-usbmid_interface_t *usbmid_interface_create(ddf_fun_t *, int);
 bool usbmid_explore_device(usb_device_t *);
-int usbmid_spawn_interface_child(usb_device_t *,
+int usbmid_spawn_interface_child(usb_device_t *, usbmid_interface_t *,
     const usb_standard_device_descriptor_t *,
     const usb_standard_interface_descriptor_t *);

uspace/lib/usb/Makefile

@@ -54 +54 @@
         src/host/device_keeper.c \
         src/host/batch.c \
-        src/host/bandwidth.c
+        src/host/endpoint.c \
+        src/host/usb_endpoint_manager.c
 
 include $(USPACE_PREFIX)/Makefile.common

uspace/lib/usb/include/usb/devdrv.h

@@ -47 +47 @@
 } usb_device_descriptors_t;
 
+/** Wrapper for data related to alternate interface setting.
+ * The pointers will typically point inside configuration descriptor and
+ * thus you shall not deallocate them.
+ */
+typedef struct {
+        /** Interface descriptor. */
+        usb_standard_interface_descriptor_t *interface;
+        /** Pointer to start of descriptor tree bound with this interface. */
+        uint8_t *nested_descriptors;
+        /** Size of data pointed by nested_descriptors in bytes. */
+        size_t nested_descriptors_size;
+} usb_alternate_interface_descriptors_t;
+
+/** Alternate interface settings. */
+typedef struct {
+        /** Array of alternate interfaces descriptions. */
+        usb_alternate_interface_descriptors_t *alternatives;
+        /** Size of @c alternatives array. */
+        size_t alternative_count;
+        /** Index of currently selected one. */
+        size_t current;
+} usb_alternate_interfaces_t;
+
 /** USB device structure. */
 typedef struct {
@@ -56 +79 @@
          */
         usb_endpoint_mapping_t *pipes;
+        /** Number of other endpoint pipes. */
+        size_t pipes_count;
         /** Current interface.
          * Usually, drivers operate on single interface only.
@@ -61 +86 @@
          */
         int interface_no;
+
+        /** Alternative interfaces.
+         * Set to NULL when the driver controls whole device
+         * (i.e. more (or any) interfaces).
+         */
+        usb_alternate_interfaces_t *alternate_interfaces;
 
         /** Some useful descriptors. */
@@ -92 +123 @@
          */
         const char *name;
-        /** Expected endpoints description, excluding default control endpoint.
+        /** Expected endpoints description.
+         * This description shall exclude default control endpoint (pipe zero)
+         * and must be NULL terminated.
+         * When only control endpoint is expected, you may set NULL directly
+         * without creating one item array containing NULL.
          *
-         * It MUST be of size expected_enpoints_count(excluding default ctrl) + 1
-         * where the last record MUST BE NULL, otherwise catastrophic things may
-         * happen.
+         * When the driver expect single interrupt in endpoint,
+         * the initialization may look like this:
+\code
+static usb_endpoint_description_t poll_endpoint_description = {
+        .transfer_type = USB_TRANSFER_INTERRUPT,
+        .direction = USB_DIRECTION_IN,
+        .interface_class = USB_CLASS_HUB,
+        .interface_subclass = 0,
+        .interface_protocol = 0,
+        .flags = 0
+};
+
+static usb_endpoint_description_t *hub_endpoints[] = {
+        &poll_endpoint_description,
+        NULL
+};
+
+static usb_driver_t hub_driver = {
+        .endpoints = hub_endpoints,
+        ...
+};
+\endcode
          */
         usb_endpoint_description_t **endpoints;
@@ -105 +159 @@
 int usb_driver_main(usb_driver_t *);
 
+int usb_device_select_interface(usb_device_t *, uint8_t,
+    usb_endpoint_description_t **);
+
 typedef bool (*usb_polling_callback_t)(usb_device_t *,
     uint8_t *, size_t, void *);
 typedef void (*usb_polling_terminted_callback_t)(usb_device_t *, bool, void *);
-
 
 int usb_device_auto_poll(usb_device_t *, size_t,

uspace/lib/usb/include/usb/host/batch.h

@@ -39 +39 @@
 #include <usbhc_iface.h>
 #include <usb/usb.h>
+#include <usb/host/endpoint.h>
 
 typedef struct usb_transfer_batch usb_transfer_batch_t;
@@ -60 +61 @@
         ddf_fun_t *fun;
         void *arg;
+        endpoint_t *ep;
         void *private_data;
 };
@@ -78 +80 @@
     void *arg,
     ddf_fun_t *fun,
+                endpoint_t *ep,
     void *private_data
 );

uspace/lib/usb/include/usb/host/device_keeper.h

@@ -40 +40 @@
 #ifndef LIBUSB_HOST_DEVICE_KEEPER_H
 #define LIBUSB_HOST_DEVICE_KEEPER_H
+
+#include <adt/list.h>
 #include <devman.h>
 #include <fibril_synch.h>
 #include <usb/usb.h>
+#include <usb/host/endpoint.h>
 
 /** Number of USB address for array dimensions. */
@@ -51 +54 @@
         usb_speed_t speed;
         bool occupied;
+        link_t endpoints;
         uint16_t control_used;
-        uint16_t toggle_status[2];
         devman_handle_t handle;
 };
@@ -68 +71 @@
 void usb_device_keeper_init(usb_device_keeper_t *instance);
 
-void usb_device_keeper_reserve_default_address(usb_device_keeper_t *instance,
-    usb_speed_t speed);
+void usb_device_keeper_add_ep(
+    usb_device_keeper_t *instance, usb_address_t address, endpoint_t *ep);
+
+void usb_device_keeper_reserve_default_address(
+    usb_device_keeper_t *instance, usb_speed_t speed);
 
 void usb_device_keeper_release_default_address(usb_device_keeper_t *instance);
 
 void usb_device_keeper_reset_if_need(usb_device_keeper_t *instance,
-    usb_target_t target,
-    const uint8_t *setup_data);
-
-int usb_device_keeper_get_toggle(usb_device_keeper_t *instance,
-    usb_target_t target, usb_direction_t direction);
-
-int usb_device_keeper_set_toggle(usb_device_keeper_t *instance,
-    usb_target_t target, usb_direction_t direction, bool toggle);
+    usb_target_t target, const uint8_t *setup_data);
 
 usb_address_t device_keeper_get_free_address(usb_device_keeper_t *instance,

uspace/lib/usb/include/usb/host/usb_endpoint_manager.h

@@ -37 +37 @@
  * This structure shall simplify the management.
  */
-#ifndef LIBUSB_HOST_BANDWIDTH_H
-#define LIBUSB_HOST_BANDWIDTH_H
+#ifndef LIBUSB_HOST_USB_ENDPOINT_MANAGER_H
+#define LIBUSB_HOST_YSB_ENDPOINT_MANAGER_H
 
 #include <adt/hash_table.h>
 #include <fibril_synch.h>
 #include <usb/usb.h>
+#include <usb/host/endpoint.h>
 
 #define BANDWIDTH_TOTAL_USB11 12000000
 #define BANDWIDTH_AVAILABLE_USB11 ((BANDWIDTH_TOTAL_USB11 / 10) * 9)
 
-typedef struct bandwidth {
-        hash_table_t reserved;
+typedef struct usb_endpoint_manager {
+        hash_table_t ep_table;
         fibril_mutex_t guard;
-        size_t free;
-        size_t (*usage_fnc)(usb_speed_t, usb_transfer_type_t, size_t, size_t);
-} bandwidth_t;
+        fibril_condvar_t change;
+        size_t free_bw;
+} usb_endpoint_manager_t;
 
 size_t bandwidth_count_usb11(usb_speed_t speed, usb_transfer_type_t type,
     size_t size, size_t max_packet_size);
 
-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);
 
-void bandwidth_destroy(bandwidth_t *instance);
+void usb_endpoint_manager_destroy(usb_endpoint_manager_t *instance);
 
-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);
+int usb_endpoint_manager_register_ep(usb_endpoint_manager_t *instance,
+    endpoint_t *ep, size_t data_size);
 
-int bandwidth_release(bandwidth_t *instance, usb_address_t address,
-    usb_endpoint_t endpoint, usb_direction_t direction);
+int usb_endpoint_manager_register_ep_wait(usb_endpoint_manager_t *instance,
+    usb_address_t address, usb_endpoint_t ep, usb_direction_t direction,
+    void *data, void (*data_remove_callback)(void* data, void* arg), void *arg,
+    size_t bw);
 
-int bandwidth_use(bandwidth_t *instance, usb_address_t address,
-    usb_endpoint_t endpoint, usb_direction_t direction);
+int usb_endpoint_manager_unregister_ep(usb_endpoint_manager_t *instance,
+    usb_address_t address, usb_endpoint_t ep, usb_direction_t direction);
 
-int bandwidth_free(bandwidth_t *instance, usb_address_t address,
-    usb_endpoint_t endpoint, usb_direction_t direction);
+endpoint_t * usb_endpoint_manager_get_ep(usb_endpoint_manager_t *instance,
+    usb_address_t address, usb_endpoint_t ep, usb_direction_t direction,
+    size_t *bw);
 
 #endif
@@ -80 +82 @@
  * @}
  */
+

uspace/lib/usb/include/usb/pipes.h

@@ -107 +107 @@
         /** Interface number the endpoint must belong to (-1 for any). */
         int interface_no;
+        /** Alternate interface setting to choose. */
+        int interface_setting;
         /** Found descriptor fitting the description. */
         usb_standard_endpoint_descriptor_t *descriptor;

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;

uspace/srv/hw/irc/apic/apic.c

@@ -87 +87 @@
                         async_answer_0(callid, EOK);
                         break;
+                case IPC_M_PHONE_HUNGUP:
+                        /* The other side has hung up. */
+                        async_answer_0(callid, EOK);
+                        return;
                 default:
                         async_answer_0(callid, EINVAL);

uspace/srv/hw/irc/i8259/i8259.c

@@ -121 +121 @@
                         async_answer_0(callid, EOK);
                         break;
+                case IPC_M_PHONE_HUNGUP:
+                        /* The other side has hung up. */
+                        async_answer_0(callid, EOK);
+                        return;
                 default:
                         async_answer_0(callid, EINVAL);