Changeset 50ba203 in mainline

Timestamp:

2011-02-20T15:46:48Z (13 years ago)

Author:

Matus Dekanek <smekideki@…>

Branches:

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

Children:

6bb83c7

Parents:

d81ef61c (diff), 0c00dac (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:

merge with usb/development

Location:

uspace

Files:

• app/tester/adt/usbaddrkeep.c (modified) (1 diff)
• app/usbinfo/info.c (modified) (4 diffs)
• app/usbinfo/main.c (modified) (1 diff)
• app/virtusbkbd/kbdconfig.c (modified) (1 diff)
• drv/uhci-hcd/Makefile (modified) (1 diff)
• drv/uhci-hcd/batch.c (added)
• drv/uhci-hcd/batch.h (moved) (moved from uspace/drv/uhci-hcd/tracker.h ) (4 diffs)
• drv/uhci-hcd/iface.c (modified) (4 diffs)
• drv/uhci-hcd/root_hub.c (modified) (2 diffs)
• drv/uhci-hcd/tracker.c (deleted)
• drv/uhci-hcd/transfer_list.c (modified) (2 diffs)
• drv/uhci-hcd/transfer_list.h (modified) (2 diffs)
• drv/uhci-hcd/uhci.c (modified) (3 diffs)
• drv/uhci-hcd/uhci.h (modified) (3 diffs)
• drv/uhci-hcd/uhci_struct/queue_head.h (modified) (1 diff)
• drv/uhci-hcd/uhci_struct/transfer_descriptor.c (modified) (2 diffs)
• drv/uhci-hcd/uhci_struct/transfer_descriptor.h (modified) (1 diff)
• drv/uhci-hcd/utils/malloc32.h (modified) (2 diffs)
• drv/uhci-rhd/port.c (modified) (10 diffs)
• drv/uhci-rhd/port.h (modified) (2 diffs)
• drv/usbhid/hid.h (modified) (1 diff)
• drv/usbhid/main.c (modified) (13 diffs)
• drv/usbhub/usbhub.c (modified) (7 diffs)
• drv/usbhub/usbhub.h (modified) (3 diffs)
• drv/vhc/conn.h (modified) (2 diffs)
• drv/vhc/connhost.c (modified) (15 diffs)
• drv/vhc/devices.c (modified) (4 diffs)
• drv/vhc/devices.h (modified) (1 diff)
• drv/vhc/hc.c (modified) (2 diffs)
• drv/vhc/hc.h (modified) (1 diff)
• drv/vhc/hub.c (modified) (2 diffs)
• lib/c/generic/async.c (modified) (1 diff)
• lib/c/generic/str_error.c (modified) (2 diffs)
• lib/c/include/async.h (modified) (1 diff)
• lib/c/include/errno.h (modified) (1 diff)
• lib/drv/generic/remote_usbhc.c (modified) (22 diffs)
• lib/drv/include/usbhc_iface.h (modified) (6 diffs)
• lib/usb/Makefile (modified) (1 diff)
• lib/usb/include/usb/addrkeep.h (modified) (1 diff, 1 prop)
• lib/usb/include/usb/classes/hid.h (modified) (1 diff)
• lib/usb/include/usb/classes/hub.h (modified) (3 diffs)
• lib/usb/include/usb/hcdhubd.h (deleted)
• lib/usb/include/usb/hub.h (moved) (moved from uspace/lib/usb/include/usb/hcd.h ) (2 diffs)
• lib/usb/include/usb/pipes.h (modified) (6 diffs)
• lib/usb/include/usb/recognise.h (added)
• lib/usb/include/usb/usb.h (modified) (1 diff)
• lib/usb/include/usb/usbdevice.h (added)
• lib/usb/include/usb/usbdrv.h (modified) (1 diff)
• lib/usb/src/addrkeep.c (modified) (1 diff)
• lib/usb/src/dump.c (modified) (1 diff)
• lib/usb/src/hcdhubd.c (deleted)
• lib/usb/src/hcdrv.c (deleted)
• lib/usb/src/hub.c (added)
• lib/usb/src/localdrv.c (deleted)
• lib/usb/src/pipes.c (modified) (4 diffs)
• lib/usb/src/pipesinit.c (added)
• lib/usb/src/pipesio.c (added)
• lib/usb/src/recognise.c (modified) (15 diffs)
• lib/usb/src/remotedrv.c (deleted)
• lib/usb/src/usb.c (modified) (1 diff)
• lib/usb/src/usbdevice.c (added)
• lib/usb/src/usbdrv.c (modified) (11 diffs)
• lib/usbvirt/Makefile (modified) (1 diff)

uspace/app/tester/adt/usbaddrkeep.c

@@ -29 +29 @@
 #include <stdio.h>
 #include <stdlib.h>
-#include <usb/hcd.h>
+#include <usb/addrkeep.h>
 #include <errno.h>
 #include "../tester.h"

uspace/app/usbinfo/info.c

@@ -39 +39 @@
 #include <usb/usbdrv.h>
 #include <usb/pipes.h>
+#include <usb/recognise.h>
 #include <usb/request.h>
 #include "usbinfo.h"
@@ -47 +48 @@
         usb_device_connection_t wire;
         usb_endpoint_pipe_t ctrl_pipe;
-        ctrl_pipe.hc_phone = -1;
-
-        int hc_phone = devman_device_connect(hc_handle, 0);
-        if (hc_phone < 0) {
-                fprintf(stderr,
-                    NAME ": failed to connect to host controller (%zu): %s.\n",
-                        (size_t) hc_handle, str_error(hc_phone));
-                return hc_phone;
-        }
-
-        /*
-         * Dump information about possible match ids.
-         */
-        match_id_list_t match_id_list;
-        init_match_ids(&match_id_list);
-        rc = usb_drv_create_device_match_ids(hc_phone, &match_id_list, address);
-        if (rc != EOK) {
-                fprintf(stderr,
-                    NAME ": failed to fetch match ids of the device: %s.\n",
-                    str_error(rc));
-                goto leave;
-        }
-        dump_match_ids(&match_id_list);
 
         /*
@@ -95 +73 @@
                 goto leave;
         }
+
+        /*
+         * Dump information about possible match ids.
+         */
+        match_id_list_t match_id_list;
+        init_match_ids(&match_id_list);
+        rc = usb_device_create_match_ids(&ctrl_pipe, &match_id_list);
+        if (rc != EOK) {
+                fprintf(stderr,
+                    NAME ": failed to fetch match ids of the device: %s.\n",
+                    str_error(rc));
+                goto leave;
+        }
+        dump_match_ids(&match_id_list);
 
         /*
@@ -141 +133 @@
 leave:
         /* Ignoring errors here. */
-        async_hangup(hc_phone);
         usb_endpoint_pipe_end_session(&ctrl_pipe);
 

uspace/app/usbinfo/main.c

@@ -81 +81 @@
 {
         int rc;
+
+        if (str_cmp(path, "uhci") == 0) {
+                path = "/hw/pci0/00:01.2";
+        }
 
         devman_handle_t handle;

uspace/app/virtusbkbd/kbdconfig.c

@@ -61 +61 @@
         .endpoint_count = 1,
         .interface_class = USB_CLASS_HID,
-        .interface_subclass = 0,
+        .interface_subclass = USB_HID_SUBCLASS_BOOT,
         .interface_protocol = USB_HID_PROTOCOL_KEYBOARD,
         .str_interface = 0

uspace/drv/uhci-hcd/Makefile

@@ -40 +40 @@
         uhci_struct/transfer_descriptor.c \
         pci.c \
-        tracker.c
+        batch.c
 
 include $(USPACE_PREFIX)/Makefile.common

uspace/drv/uhci-hcd/batch.h

@@ -32 +32 @@
  * @brief UHCI driver
  */
-#ifndef DRV_UHCI_TRACKER_H
-#define DRV_UHCI_TRACKER_H
+#ifndef DRV_UHCI_BATCH_H
+#define DRV_UHCI_BATCH_H
 
 #include <adt/list.h>
@@ -41 +41 @@
 
 #include "uhci_struct/transfer_descriptor.h"
+#include "uhci_struct/queue_head.h"
 
 typedef enum {
@@ -47 +48 @@
 } dev_speed_t;
 
-typedef struct tracker
+typedef struct batch
 {
         link_t link;
+        dev_speed_t speed;
         usb_target_t target;
         usb_transfer_type_t transfer_type;
@@ -57 +59 @@
         };
         void *arg;
+        char *transport_buffer;
+        char *setup_buffer;
+        size_t setup_size;
         char *buffer;
-        char *packet;
         size_t buffer_size;
         size_t max_packet_size;
-        size_t packet_size;
-        size_t buffer_offset;
-        dev_speed_t speed;
+        size_t packets;
+        size_t transfered_size;
+        int error;
         device_t *dev;
-        transfer_descriptor_t *td;
-        void (*next_step)(struct tracker*);
-        unsigned toggle:1;
-} tracker_t;
+        queue_head_t *qh;
+        transfer_descriptor_t *tds;
+        void (*next_step)(struct batch*);
+} batch_t;
 
-
-tracker_t * tracker_get(device_t *dev, usb_target_t target,
+batch_t * batch_get(device_t *dev, usb_target_t target,
     usb_transfer_type_t transfer_type, size_t max_packet_size,
     dev_speed_t speed, char *buffer, size_t size,
+                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);
 
-void tracker_control_write(
-    tracker_t *instance, char* setup_buffer, size_t setup_size);
+bool batch_is_complete(batch_t *instance);
 
-void tracker_control_read(
-    tracker_t *instance, char* setup_buffer, size_t setup_size);
+void batch_control_write(batch_t *instance);
 
-void tracker_interrupt_in(tracker_t *instance);
+void batch_control_read(batch_t *instance);
 
-void tracker_interrupt_out(tracker_t *instance);
+void batch_interrupt_in(batch_t *instance);
+
+void batch_interrupt_out(batch_t *instance);
 
 /* DEPRECATED FUNCTIONS NEEDED BY THE OLD API */
-void tracker_control_setup_old(tracker_t *instance);
+void batch_control_setup_old(batch_t *instance);
 
-void tracker_control_write_data_old(tracker_t *instance);
+void batch_control_write_data_old(batch_t *instance);
 
-void tracker_control_read_data_old(tracker_t *instance);
+void batch_control_read_data_old(batch_t *instance);
 
-void tracker_control_write_status_old(tracker_t *instance);
+void batch_control_write_status_old(batch_t *instance);
 
-void tracker_control_read_status_old(tracker_t *instance);
+void batch_control_read_status_old(batch_t *instance);
 #endif
 /**

uspace/drv/uhci-hcd/iface.c

@@ -54 +54 @@
 }
 /*----------------------------------------------------------------------------*/
-static int reserve_default_address(device_t *dev)
+static int reserve_default_address(device_t *dev, bool full_speed)
 {
         assert(dev);
@@ -72 +72 @@
 }
 /*----------------------------------------------------------------------------*/
-static int request_address(device_t *dev, usb_address_t *address)
+static int request_address(device_t *dev, bool full_speed,
+    usb_address_t *address)
 {
         assert(dev);
@@ -103 +104 @@
 /*----------------------------------------------------------------------------*/
 static int interrupt_out(device_t *dev, usb_target_t target,
-    void *data, size_t size,
-    usbhc_iface_transfer_out_callback_t callback, void *arg)
+    size_t max_packet_size,
+    void *data, size_t size,
+    usbhc_iface_transfer_out_callback_t callback, void *arg)
+{
+        dev_speed_t speed = FULL_SPEED;
+
+        batch_t *batch = batch_get(dev, target, USB_TRANSFER_INTERRUPT,
+            max_packet_size, speed, data, size, NULL, 0, NULL, callback, arg);
+        if (!batch)
+                return ENOMEM;
+        batch_interrupt_out(batch);
+        return EOK;
+}
+/*----------------------------------------------------------------------------*/
+static int interrupt_in(device_t *dev, usb_target_t target,
+    size_t max_packet_size,
+    void *data, size_t size,
+    usbhc_iface_transfer_in_callback_t callback, void *arg)
+{
+        dev_speed_t speed = FULL_SPEED;
+
+        batch_t *batch = batch_get(dev, target, USB_TRANSFER_INTERRUPT,
+            max_packet_size, speed, data, size, NULL, 0, callback, NULL, arg);
+        if (!batch)
+                return ENOMEM;
+        batch_interrupt_in(batch);
+        return EOK;
+}
+/*----------------------------------------------------------------------------*/
+static int control_write(device_t *dev, usb_target_t target,
+    size_t max_packet_size,
+    void *setup_data, size_t setup_size, void *data, size_t size,
+    usbhc_iface_transfer_out_callback_t callback, void *arg)
+{
+        dev_speed_t speed = FULL_SPEED;
+
+        batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL,
+            max_packet_size, speed, data, size, setup_data, setup_size,
+            NULL, callback, arg);
+        if (!batch)
+                return ENOMEM;
+        batch_control_write(batch);
+        return EOK;
+}
+/*----------------------------------------------------------------------------*/
+static int control_read(device_t *dev, usb_target_t target,
+    size_t max_packet_size,
+    void *setup_data, size_t setup_size, void *data, size_t size,
+    usbhc_iface_transfer_in_callback_t callback, void *arg)
+{
+        dev_speed_t speed = FULL_SPEED;
+
+        batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL,
+            max_packet_size, speed, data, size, setup_data, setup_size, callback,
+            NULL, arg);
+        if (!batch)
+                return ENOMEM;
+        batch_control_read(batch);
+        return EOK;
+}
+/*----------------------------------------------------------------------------*/
+static int control_write_setup(device_t *dev, usb_target_t target,
+    size_t max_packet_size,
+    void *data, size_t size,
+    usbhc_iface_transfer_out_callback_t callback, void *arg)
+{
+        dev_speed_t speed = FULL_SPEED;
+
+        usb_log_warning("Using deprecated API %s.\n", __FUNCTION__);
+        batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL,
+            max_packet_size, speed, NULL, 0, data, size, NULL, callback, arg);
+        if (!batch)
+                return ENOMEM;
+        batch_control_setup_old(batch);
+        return EOK;
+}
+/*----------------------------------------------------------------------------*/
+static int control_write_data(device_t *dev, usb_target_t target,
+    size_t max_packet_size,
+    void *data, size_t size,
+    usbhc_iface_transfer_out_callback_t callback, void *arg)
+{
+        dev_speed_t speed = FULL_SPEED;
+
+        usb_log_warning("Using deprecated API %s.\n", __FUNCTION__);
+        batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL,
+            max_packet_size, speed, data, size, NULL, 0, NULL, callback, arg);
+        if (!batch)
+                return ENOMEM;
+        batch_control_write_data_old(batch);
+        return EOK;
+}
+/*----------------------------------------------------------------------------*/
+static int control_write_status(device_t *dev, usb_target_t target,
+    usbhc_iface_transfer_in_callback_t callback, void *arg)
 {
         size_t max_packet_size = 8;
         dev_speed_t speed = FULL_SPEED;
 
-        tracker_t *tracker = tracker_get(dev, target, USB_TRANSFER_INTERRUPT,
-            max_packet_size, speed, data, size, NULL, callback, arg);
-        if (!tracker)
-                return ENOMEM;
-        tracker_interrupt_out(tracker);
-        return EOK;
-}
-/*----------------------------------------------------------------------------*/
-static int interrupt_in(device_t *dev, usb_target_t target,
-    void *data, size_t size,
-    usbhc_iface_transfer_in_callback_t callback, void *arg)
-{
-        size_t max_packet_size = 4;
-        dev_speed_t speed = FULL_SPEED;
-
-        tracker_t *tracker = tracker_get(dev, target, USB_TRANSFER_INTERRUPT,
-            max_packet_size, speed, data, size, callback, NULL, arg);
-        if (!tracker)
-                return ENOMEM;
-        tracker_interrupt_in(tracker);
-        return EOK;
-}
-/*----------------------------------------------------------------------------*/
-static int control_write(device_t *dev, usb_target_t target,
-    void *setup_data, size_t setup_size, void *data, size_t size,
+        usb_log_warning("Using deprecated API %s.\n", __FUNCTION__);
+        batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL,
+            max_packet_size, speed, NULL, 0, NULL, 0, callback, NULL, arg);
+        if (!batch)
+                return ENOMEM;
+        batch_control_write_status_old(batch);
+        return EOK;
+}
+/*----------------------------------------------------------------------------*/
+static int control_read_setup(device_t *dev, usb_target_t target,
+    size_t max_packet_size,
+    void *data, size_t size,
+    usbhc_iface_transfer_out_callback_t callback, void *arg)
+{
+        dev_speed_t speed = FULL_SPEED;
+
+        usb_log_warning("Using deprecated API %s.\n", __FUNCTION__);
+        batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL,
+            max_packet_size, speed, NULL, 0, data, size, NULL, callback, arg);
+        if (!batch)
+                return ENOMEM;
+        batch_control_setup_old(batch);
+        return EOK;
+}
+/*----------------------------------------------------------------------------*/
+static int control_read_data(device_t *dev, usb_target_t target,
+    size_t max_packet_size,
+    void *data, size_t size,
+    usbhc_iface_transfer_in_callback_t callback, void *arg)
+{
+        dev_speed_t speed = FULL_SPEED;
+
+        usb_log_warning("Using deprecated API %s.\n", __FUNCTION__);
+        batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL,
+            max_packet_size, speed, data, size, NULL, 0, callback, NULL, arg);
+        if (!batch)
+                return ENOMEM;
+        batch_control_read_data_old(batch);
+        return EOK;
+}
+/*----------------------------------------------------------------------------*/
+static int control_read_status(device_t *dev, usb_target_t target,
     usbhc_iface_transfer_out_callback_t callback, void *arg)
 {
@@ -139 +250 @@
         dev_speed_t speed = FULL_SPEED;
 
-        tracker_t *tracker = tracker_get(dev, target, USB_TRANSFER_CONTROL,
-            max_packet_size, speed, data, size, NULL, callback, arg);
-        if (!tracker)
-                return ENOMEM;
-        tracker_control_write(tracker, setup_data, setup_size);
-        return EOK;
-}
-/*----------------------------------------------------------------------------*/
-static int control_read(device_t *dev, usb_target_t target,
-    void *setup_data, size_t setup_size, void *data, size_t size,
-    usbhc_iface_transfer_in_callback_t callback, void *arg)
-{
-        size_t max_packet_size = 8;
-        dev_speed_t speed = FULL_SPEED;
-
-        tracker_t *tracker = tracker_get(dev, target, USB_TRANSFER_CONTROL,
-            max_packet_size, speed, data, size, callback, NULL, arg);
-        if (!tracker)
-                return ENOMEM;
-        tracker_control_read(tracker, setup_data, setup_size);
-        return EOK;
-}
-/*----------------------------------------------------------------------------*/
-static int control_write_setup(device_t *dev, usb_target_t target,
-    void *data, size_t size,
-    usbhc_iface_transfer_out_callback_t callback, void *arg)
-{
-        usb_log_warning("Using deprecated API control write setup.\n");
-        tracker_t *tracker = tracker_get(dev, target, USB_TRANSFER_CONTROL,
-            8, FULL_SPEED, data, size, NULL, callback, arg);
-        if (!tracker)
-                return ENOMEM;
-        tracker_control_setup_old(tracker);
-        return EOK;
-}
-/*----------------------------------------------------------------------------*/
-static int control_write_data(device_t *dev, usb_target_t target,
-    void *data, size_t size,
-    usbhc_iface_transfer_out_callback_t callback, void *arg)
-{
-        tracker_t *tracker = tracker_get(dev, target, USB_TRANSFER_CONTROL,
-            size, FULL_SPEED, data, size, NULL, callback, arg);
-        if (!tracker)
-                return ENOMEM;
-        tracker_control_write_data_old(tracker);
-        return EOK;
-}
-/*----------------------------------------------------------------------------*/
-static int control_write_status(device_t *dev, usb_target_t target,
-    usbhc_iface_transfer_in_callback_t callback, void *arg)
-{
-        tracker_t *tracker = tracker_get(dev, target, USB_TRANSFER_CONTROL,
-            0, FULL_SPEED, NULL, 0, callback, NULL, arg);
-        if (!tracker)
-                return ENOMEM;
-        tracker_control_write_status_old(tracker);
-        return EOK;
-}
-/*----------------------------------------------------------------------------*/
-static int control_read_setup(device_t *dev, usb_target_t target,
-    void *data, size_t size,
-    usbhc_iface_transfer_out_callback_t callback, void *arg)
-{
-        usb_log_warning("Using deprecated API control read setup.\n");
-        tracker_t *tracker = tracker_get(dev, target, USB_TRANSFER_CONTROL,
-            8, FULL_SPEED, data, size, NULL, callback, arg);
-        if (!tracker)
-                return ENOMEM;
-        tracker_control_setup_old(tracker);
-        return EOK;
-}
-/*----------------------------------------------------------------------------*/
-static int control_read_data(device_t *dev, usb_target_t target,
-    void *data, size_t size,
-    usbhc_iface_transfer_in_callback_t callback, void *arg)
-{
-        tracker_t *tracker = tracker_get(dev, target, USB_TRANSFER_CONTROL,
-            size, FULL_SPEED, data, size, callback, NULL, arg);
-        if (!tracker)
-                return ENOMEM;
-        tracker_control_read_data_old(tracker);
-        return EOK;
-}
-/*----------------------------------------------------------------------------*/
-static int control_read_status(device_t *dev, usb_target_t target,
-    usbhc_iface_transfer_out_callback_t callback, void *arg)
-{
-        tracker_t *tracker = tracker_get(dev, target, USB_TRANSFER_CONTROL,
-            0, FULL_SPEED, NULL, 0, NULL, callback, arg);
-        if (!tracker)
-                return ENOMEM;
-        tracker_control_read_status_old(tracker);
+        usb_log_warning("Using deprecated API %s.\n", __FUNCTION__);
+        batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL,
+            max_packet_size, speed, NULL, 0, NULL, 0, NULL, callback, arg);
+        if (!batch)
+                return ENOMEM;
+        batch_control_read_status_old(batch);
         return EOK;
 }

uspace/drv/uhci-hcd/root_hub.c

@@ -35 +35 @@
 #include <errno.h>
 #include <stdio.h>
-
 #include <usb_iface.h>
-
 #include <usb/debug.h>
 
 #include "root_hub.h"
+
+extern device_ops_t child_ops;
 /*----------------------------------------------------------------------------*/
-static int usb_iface_get_hc_handle(device_t *dev, devman_handle_t *handle)
-{
-  assert(dev);
-  assert(dev->parent != NULL);
-
-  device_t *parent = dev->parent;
-
-  if (parent->ops && parent->ops->interfaces[USB_DEV_IFACE]) {
-    usb_iface_t *usb_iface
-        = (usb_iface_t *) parent->ops->interfaces[USB_DEV_IFACE];
-    assert(usb_iface != NULL);
-    if (usb_iface->get_hc_handle) {
-      int rc = usb_iface->get_hc_handle(parent, handle);
-      return rc;
-    }
-  }
-
-  return ENOTSUP;
-}
-/*----------------------------------------------------------------------------*/
-static usb_iface_t usb_iface = {
-  .get_hc_handle = usb_iface_get_hc_handle
-};
-
-static device_ops_t rh_ops = {
-        .interfaces[USB_DEV_IFACE] = &usb_iface
-};
-
 int setup_root_hub(device_t **device, device_t *hc)
 {
@@ -108 +80 @@
         hub->name = name;
         hub->parent = hc;
-        hub->ops = &rh_ops;
+        hub->ops = &child_ops;
 
         *device = hub;

uspace/drv/uhci-hcd/transfer_list.c

@@ -51 +51 @@
 
         queue_head_init(instance->queue_head);
+        list_initialize(&instance->batch_list);
+        fibril_mutex_initialize(&instance->guard);
         return EOK;
 }
@@ -58 +60 @@
         assert(instance);
         assert(next);
-        instance->next = next;
         if (!instance->queue_head)
                 return;
-        queue_head_add_next(instance->queue_head, next->queue_head_pa);
+        queue_head_append_qh(instance->queue_head, next->queue_head_pa);
+        instance->queue_head->element = instance->queue_head->next_queue;
 }
 /*----------------------------------------------------------------------------*/
-void transfer_list_add_tracker(transfer_list_t *instance, tracker_t *tracker)
+void transfer_list_add_batch(transfer_list_t *instance, batch_t *batch)
 {
         assert(instance);
-        assert(tracker);
+        assert(batch);
 
-        uint32_t pa = (uintptr_t)addr_to_phys(tracker->td);
+        uint32_t pa = (uintptr_t)addr_to_phys(batch->qh);
         assert((pa & LINK_POINTER_ADDRESS_MASK) == pa);
+        pa |= LINK_POINTER_QUEUE_HEAD_FLAG;
 
+        batch->qh->next_queue = instance->queue_head->next_queue;
 
-        if (instance->queue_head->element & LINK_POINTER_TERMINATE_FLAG) {
-                usb_log_debug2("Adding td(%X:%X) to queue %s first.\n",
-                        tracker->td->status, tracker->td->device, instance->name);
+        fibril_mutex_lock(&instance->guard);
+
+        if (instance->queue_head->element == instance->queue_head->next_queue) {
                 /* there is nothing scheduled */
-                instance->last_tracker = tracker;
+                list_append(&batch->link, &instance->batch_list);
                 instance->queue_head->element = pa;
-                usb_log_debug2("Added td(%X:%X) to queue %s first.\n",
-                        tracker->td->status, tracker->td->device, instance->name);
+                usb_log_debug2("Added batch(%p) to queue %s first.\n",
+                        batch, instance->name);
+                fibril_mutex_unlock(&instance->guard);
                 return;
         }
-        usb_log_debug2("Adding td(%X:%X) to queue %s last.%p\n",
-            tracker->td->status, tracker->td->device, instance->name,
-            instance->last_tracker);
-        /* now we can be sure that last_tracker is a valid pointer */
-        instance->last_tracker->td->next = pa;
-        instance->last_tracker = tracker;
+        /* now we can be sure that there is someting scheduled */
+        assert(!list_empty(&instance->batch_list));
+        batch_t *first = list_get_instance(
+                  instance->batch_list.next, batch_t, link);
+        batch_t *last = list_get_instance(
+            instance->batch_list.prev, batch_t, link);
+        queue_head_append_qh(last->qh, pa);
+        list_append(&batch->link, &instance->batch_list);
+        usb_log_debug2("Added batch(%p) to queue %s last, first is %p.\n",
+                batch, instance->name, first );
+        fibril_mutex_unlock(&instance->guard);
+}
+/*----------------------------------------------------------------------------*/
+static void transfer_list_remove_batch(
+    transfer_list_t *instance, batch_t *batch)
+{
+        assert(instance);
+        assert(batch);
+        assert(instance->queue_head);
+        assert(batch->qh);
 
-        usb_log_debug2("Added td(%X:%X) to queue %s last.\n",
-                tracker->td->status, tracker->td->device, instance->name);
+        /* I'm the first one here */
+        if (batch->link.prev == &instance->batch_list) {
+                usb_log_debug("Removing tracer %p was first, next element %x.\n",
+                        batch, batch->qh->next_queue);
+                instance->queue_head->element = batch->qh->next_queue;
+        } else {
+                usb_log_debug("Removing tracer %p was NOT first, next element %x.\n",
+                        batch, batch->qh->next_queue);
+                batch_t *prev = list_get_instance(batch->link.prev, batch_t, link);
+                prev->qh->next_queue = batch->qh->next_queue;
+        }
+        list_remove(&batch->link);
+}
+/*----------------------------------------------------------------------------*/
+void transfer_list_check(transfer_list_t *instance)
+{
+        assert(instance);
+        fibril_mutex_lock(&instance->guard);
+        link_t *current = instance->batch_list.next;
+        while (current != &instance->batch_list) {
+                link_t *next = current->next;
+                batch_t *batch = list_get_instance(current, batch_t, link);
 
-        /* check again, may be use atomic compare and swap */
-        if (instance->queue_head->element & LINK_POINTER_TERMINATE_FLAG) {
-                instance->queue_head->element = pa;
-                usb_log_debug2("Added td(%X:%X) to queue first2 %s.\n",
-                        tracker->td->status, tracker->td->device, instance->name);
+                if (batch_is_complete(batch)) {
+                        transfer_list_remove_batch(instance, batch);
+                        batch->next_step(batch);
+                }
+                current = next;
         }
+        fibril_mutex_unlock(&instance->guard);
 }
 /**

uspace/drv/uhci-hcd/transfer_list.h

@@ -35 +35 @@
 #define DRV_UHCI_TRANSFER_LIST_H
 
+#include <fibril_synch.h>
+
 #include "uhci_struct/queue_head.h"
-#include "tracker.h"
+
+#include "batch.h"
 
 typedef struct transfer_list
 {
-        tracker_t *last_tracker;
-
+        fibril_mutex_t guard;
         queue_head_t *queue_head;
         uint32_t queue_head_pa;
         struct transfer_list *next;
         const char *name;
+        link_t batch_list;
 } transfer_list_t;
 
@@ -57 +60 @@
         queue_head_dispose(instance->queue_head);
 }
+void transfer_list_check(transfer_list_t *instance);
 
-
-void transfer_list_add_tracker(transfer_list_t *instance, tracker_t *tracker);
-
+void transfer_list_add_batch(transfer_list_t *instance, batch_t *batch);
 #endif
 /**

uspace/drv/uhci-hcd/uhci.c

@@ -89 +89 @@
         pio_write_32(&instance->registers->flbaseadd, (uint32_t)pa);
 
-        list_initialize(&instance->tracker_list);
-        fibril_mutex_initialize(&instance->tracker_list_mutex);
+        list_initialize(&instance->batch_list);
+        fibril_mutex_initialize(&instance->batch_list_mutex);
 
         instance->cleaner = fibril_create(uhci_clean_finished, instance);
@@ -152 +152 @@
 }
 /*----------------------------------------------------------------------------*/
-int uhci_schedule(uhci_t *instance, tracker_t *tracker)
-{
-        assert(instance);
-        assert(tracker);
-        const int low_speed = (tracker->speed == LOW_SPEED);
+int uhci_schedule(uhci_t *instance, batch_t *batch)
+{
+        assert(instance);
+        assert(batch);
+        const int low_speed = (batch->speed == LOW_SPEED);
         if (!allowed_usb_packet(
-            low_speed, tracker->transfer_type, tracker->packet_size)) {
+            low_speed, batch->transfer_type, batch->max_packet_size)) {
                 usb_log_warning("Invalid USB packet specified %s SPEED %d %zu.\n",
-                          low_speed ? "LOW" : "FULL" , tracker->transfer_type,
-                    tracker->packet_size);
+                          low_speed ? "LOW" : "FULL" , batch->transfer_type,
+                    batch->max_packet_size);
                 return ENOTSUP;
         }
         /* TODO: check available bandwith here */
 
-        usb_log_debug2("Scheduler(%d) acquiring tracker list mutex.\n",
-            fibril_get_id());
-        fibril_mutex_lock(&instance->tracker_list_mutex);
-        usb_log_debug2("Scheduler(%d) acquired tracker list mutex.\n",
-            fibril_get_id());
-
         transfer_list_t *list =
-            instance->transfers[low_speed][tracker->transfer_type];
+            instance->transfers[low_speed][batch->transfer_type];
         assert(list);
-        transfer_list_add_tracker(list, tracker);
-        list_append(&tracker->link, &instance->tracker_list);
-
-        usb_log_debug2("Scheduler(%d) releasing tracker list mutex.\n",
-            fibril_get_id());
-        fibril_mutex_unlock(&instance->tracker_list_mutex);
-        usb_log_debug2("Scheduler(%d) released tracker list mutex.\n",
-            fibril_get_id());
+        transfer_list_add_batch(list, batch);
 
         return EOK;
@@ -194 +181 @@
 
         while(1) {
-                LIST_INITIALIZE(done_trackers);
-                /* tracker iteration */
-
-                usb_log_debug2("Cleaner(%d) acquiring tracker list mutex.\n",
-                    fibril_get_id());
-                fibril_mutex_lock(&instance->tracker_list_mutex);
-                usb_log_debug2("Cleaner(%d) acquired tracker list mutex.\n",
-                    fibril_get_id());
-
-                link_t *current = instance->tracker_list.next;
-                while (current != &instance->tracker_list)
-                {
-
-                        link_t *next = current->next;
-                        tracker_t *tracker = list_get_instance(current, tracker_t, link);
-
-                        assert(current == &tracker->link);
-                        assert(tracker);
-                        assert(tracker->next_step);
-                        assert(tracker->td);
-
-                        if (!transfer_descriptor_is_active(tracker->td)) {
-                                usb_log_info("Found inactive tracker with status: %x:%x.\n",
-                                    tracker->td->status, tracker->td->device);
-                                list_remove(current);
-                                list_append(current, &done_trackers);
-                        }
-                        current = next;
-                }
-
-                usb_log_debug2("Cleaner(%d) releasing tracker list mutex.\n",
-                    fibril_get_id());
-                fibril_mutex_unlock(&instance->tracker_list_mutex);
-                usb_log_debug2("Cleaner(%d) released tracker list mutex.\n",
-                    fibril_get_id());
-
-                while (!list_empty(&done_trackers)) {
-                        tracker_t *tracker = list_get_instance(
-                          done_trackers.next, tracker_t, link);
-                        list_remove(&tracker->link);
-                        tracker->next_step(tracker);
-                }
+                transfer_list_check(&instance->transfers_interrupt);
+                transfer_list_check(&instance->transfers_control_slow);
+                transfer_list_check(&instance->transfers_control_full);
+                transfer_list_check(&instance->transfers_bulk_full);
                 async_usleep(UHCI_CLEANER_TIMEOUT);
         }

uspace/drv/uhci-hcd/uhci.h

@@ -44 +44 @@
 
 #include "transfer_list.h"
-#include "tracker.h"
+#include "batch.h"
 
 typedef struct uhci_regs {
@@ -81 +81 @@
         link_pointer_t *frame_list;
 
-        link_t tracker_list;
-        fibril_mutex_t tracker_list_mutex;
+        link_t batch_list;
+        fibril_mutex_t batch_list_mutex;
 
         transfer_list_t transfers_bulk_full;
@@ -113 +113 @@
   void *arg );
 
-int uhci_schedule(uhci_t *instance, tracker_t *tracker);
+int uhci_schedule(uhci_t *instance, batch_t *batch);
 
 static inline uhci_t * dev_to_uhci(device_t *dev)

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

@@ -55 +55 @@
 }
 
-static inline void queue_head_add_next(queue_head_t *instance, uint32_t next_queue_pa)
+static inline void queue_head_append_qh(queue_head_t *instance, uint32_t pa)
 {
-        if (next_queue_pa) {
-                instance->next_queue = (next_queue_pa & LINK_POINTER_ADDRESS_MASK)
-                  | LINK_POINTER_QUEUE_HEAD_FLAG;
+        if (pa) {
+                instance->next_queue = (pa & LINK_POINTER_ADDRESS_MASK)
+                    | LINK_POINTER_QUEUE_HEAD_FLAG;
         }
 }
 
-static inline queue_head_t * queue_head_get()
-        { return malloc32(sizeof(queue_head_t)); }
+static inline void queue_head_element_qh(queue_head_t *instance, uint32_t pa)
+{
+        if (pa) {
+                instance->next_queue = (pa & LINK_POINTER_ADDRESS_MASK)
+                    | LINK_POINTER_QUEUE_HEAD_FLAG;
+        }
+}
+
+static inline void queue_head_element_td(queue_head_t *instance, uint32_t pa)
+{
+        if (pa) {
+                instance->element = (pa & LINK_POINTER_ADDRESS_MASK);
+        }
+}
+
+static inline queue_head_t * queue_head_get() {
+        queue_head_t *ret = malloc32(sizeof(queue_head_t));
+        if (ret)
+                queue_head_init(ret);
+        return ret;
+}
 
 static inline void queue_head_dispose(queue_head_t *head)

uspace/drv/uhci-hcd/uhci_struct/transfer_descriptor.c

@@ -40 +40 @@
 void transfer_descriptor_init(transfer_descriptor_t *instance,
     int error_count, size_t size, bool toggle, bool isochronous,
-    usb_target_t target, int pid, void *buffer)
+    usb_target_t target, int pid, void *buffer, transfer_descriptor_t *next)
 {
         assert(instance);
 
-        instance->next = 0 | LINK_POINTER_TERMINATE_FLAG;
+        instance->next = 0
+            | LINK_POINTER_VERTICAL_FLAG
+            | ((next != NULL) ? addr_to_phys(next) : LINK_POINTER_TERMINATE_FLAG);
 
         instance->status = 0
@@ -80 +82 @@
 #endif
 }
-
-static inline usb_transaction_outcome_t convert_outcome(uint32_t status)
-{
-        /*TODO: refactor into something sane */
-        /*TODO: add additional usb_errors to usb_outcome_t */
-
-        if (status & TD_STATUS_ERROR_STALLED)
-                return USB_OUTCOME_CRCERROR;
-
-        if (status & TD_STATUS_ERROR_BUFFER)
-                return USB_OUTCOME_CRCERROR;
-
-        if (status & TD_STATUS_ERROR_BABBLE)
-                return USB_OUTCOME_BABBLE;
-
-        if (status & TD_STATUS_ERROR_NAK)
-                return USB_OUTCOME_CRCERROR;
-
-  if (status & TD_STATUS_ERROR_CRC)
-                return USB_OUTCOME_CRCERROR;
-
-        if (status & TD_STATUS_ERROR_BIT_STUFF)
-                return USB_OUTCOME_CRCERROR;
-
-//      assert((((status >> TD_STATUS_ERROR_POS) & TD_STATUS_ERROR_MASK)
-//      | TD_STATUS_ERROR_RESERVED) == TD_STATUS_ERROR_RESERVED);
-        return USB_OUTCOME_OK;
-}
 /*----------------------------------------------------------------------------*/
 int transfer_descriptor_status(transfer_descriptor_t *instance)
 {
         assert(instance);
-        if (convert_outcome(instance->status))
-                return EINVAL; //TODO: use sane error value here
+
+        if ((instance->status & TD_STATUS_ERROR_STALLED) != 0)
+                return EIO;
+
+        if ((instance->status & TD_STATUS_ERROR_CRC) != 0)
+                return EAGAIN;
+
+        if ((instance->status & TD_STATUS_ERROR_BUFFER) != 0)
+                return EAGAIN;
+
+        if ((instance->status & TD_STATUS_ERROR_BABBLE) != 0)
+                return EIO;
+
+        if ((instance->status & TD_STATUS_ERROR_NAK) != 0)
+                return EAGAIN;
+
+        if ((instance->status & TD_STATUS_ERROR_BIT_STUFF) != 0)
+                return EAGAIN;
+
         return EOK;
 }

uspace/drv/uhci-hcd/uhci_struct/transfer_descriptor.h

@@ -93 +93 @@
 void transfer_descriptor_init(transfer_descriptor_t *instance,
     int error_count, size_t size, bool toggle, bool isochronous,
-    usb_target_t target, int pid, void *buffer);
+    usb_target_t target, int pid, void *buffer, transfer_descriptor_t * next);
 
 int transfer_descriptor_status(transfer_descriptor_t *instance);
+
+static inline size_t transfer_descriptor_actual_size(
+    transfer_descriptor_t *instance)
+{
+        assert(instance);
+        return
+            ((instance->status >> TD_STATUS_ACTLEN_POS) + 1) & TD_STATUS_ACTLEN_MASK;
+}
 
 static inline bool transfer_descriptor_is_active(

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

@@ -45 +45 @@
 #define UHCI_REQUIRED_PAGE_SIZE 4096
 
-static inline void * addr_to_phys(void *addr)
+static inline uintptr_t addr_to_phys(void *addr)
 {
         uintptr_t result;
@@ -51 +51 @@
 
         assert(ret == 0);
-        return (void*)(result | ((uintptr_t)addr & 0xfff));
+        return (result | ((uintptr_t)addr & 0xfff));
 }
 

uspace/drv/uhci-rhd/port.c

@@ -33 +33 @@
  */
 #include <errno.h>
+#include <str_error.h>
 
 #include <usb/usb.h>    /* usb_address_t */
-#include <usb/usbdrv.h> /* usb_drv_*     */
+#include <usb/usbdevice.h>
+#include <usb/hub.h>
+#include <usb/request.h>
 #include <usb/debug.h>
+#include <usb/recognise.h>
 
 #include "port.h"
@@ -56 +60 @@
         port->attached_device = 0;
         port->rh = rh;
-        port->hc_phone = parent_phone;
+        int rc = usb_hc_connection_initialize_from_device(
+            &port->hc_connection, rh);
+        if (rc != EOK) {
+                usb_log_error("Failed to initialize connection to HC.");
+                return rc;
+        }
 
         port->checker = fibril_create(uhci_port_check, port);
@@ -96 +105 @@
 
                 if (port_status & STATUS_CONNECTED_CHANGED) {
+                        int rc = usb_hc_connection_open(
+                            &port_instance->hc_connection);
+                        if (rc != EOK) {
+                                usb_log_error("Failed to connect to HC.");
+                                goto next;
+                        }
+
                         if (port_status & STATUS_CONNECTED) {
                                 /* new device */
@@ -102 +118 @@
                                 uhci_port_remove_device(port_instance);
                         }
+
+                        rc = usb_hc_connection_close(
+                            &port_instance->hc_connection);
+                        if (rc != EOK) {
+                                usb_log_error("Failed to disconnect from HC.");
+                                goto next;
+                        }
                 }
+        next:
                 async_usleep(port_instance->wait_period_usec);
         }
@@ -111 +135 @@
 {
         assert(port);
-        assert(port->hc_phone);
+        assert(usb_hc_connection_is_opened(&port->hc_connection));
 
         usb_log_info("Adding new device on port %d.\n", port->number);
 
         /* get address of the future device */
-        const usb_address_t usb_address = usb_drv_request_address(port->hc_phone);
+        const usb_address_t usb_address = usb_hc_request_address(
+            &port->hc_connection, true);
 
         if (usb_address <= 0) {
@@ -126 +151 @@
 
         /* get default address */
-        int ret = usb_drv_reserve_default_address(port->hc_phone);
+        int ret = usb_hc_reserve_default_address(&port->hc_connection, true);
         if (ret != EOK) {
                 usb_log_error("Failed to reserve default address on port %d.\n",
                     port->number);
-                int ret2 =
-                  usb_drv_release_address(port->hc_phone, usb_address);
+                int ret2 = usb_hc_unregister_device(&port->hc_connection,
+                    usb_address);
                 if (ret2 != EOK) {
                         usb_log_fatal("Failed to return requested address on port %d.\n",
@@ -172 +197 @@
         }
 
-        /* assign address to device */
-        ret = usb_drv_req_set_address(port->hc_phone, 0, usb_address);
+        /*
+         * Initialize connection to the device.
+         */
+        /* FIXME: check for errors. */
+        usb_device_connection_t new_dev_connection;
+        usb_endpoint_pipe_t new_dev_ctrl_pipe;
+        usb_device_connection_initialize_on_default_address(
+            &new_dev_connection, &port->hc_connection);
+        usb_endpoint_pipe_initialize_default_control(&new_dev_ctrl_pipe,
+            &new_dev_connection);
+
+        /*
+         * Assign new address to the device. This function updates
+         * the backing connection to still point to the same device.
+         */
+        /* FIXME: check for errors. */
+        usb_endpoint_pipe_start_session(&new_dev_ctrl_pipe);
+        ret = usb_request_set_address(&new_dev_ctrl_pipe, usb_address);
+        usb_endpoint_pipe_end_session(&new_dev_ctrl_pipe);
 
         if (ret != EOK) { /* address assigning went wrong */
                 usb_log_error("Failed(%d) to assign address to the device.\n", ret);
                 uhci_port_set_enabled(port, false);
-                int release = usb_drv_release_default_address(port->hc_phone);
+                int release = usb_hc_release_default_address(&port->hc_connection);
                 if (release != EOK) {
                         usb_log_error("Failed to release default address on port %d.\n",
@@ -192 +234 @@
 
         /* release default address */
-        ret = usb_drv_release_default_address(port->hc_phone);
+        ret = usb_hc_release_default_address(&port->hc_connection);
         if (ret != EOK) {
                 usb_log_error("Failed to release default address on port %d.\n",
@@ -204 +246 @@
         assert(port->attached_device == 0);
 
-        ret = usb_drv_register_child_in_devman(port->hc_phone, port->rh,
-          usb_address, &port->attached_device);
+        ret = usb_device_register_child_in_devman(new_dev_connection.address,
+            new_dev_connection.hc_handle, port->rh, &port->attached_device);
 
         if (ret != EOK) { /* something went wrong */
@@ -215 +257 @@
                 port->number, usb_address, port->attached_device);
 
-        ret =
-          usb_drv_bind_address(port->hc_phone, usb_address, port->attached_device);
+        /*
+         * Register the device in the host controller.
+         */
+        usb_hc_attached_device_t new_device = {
+                .address = new_dev_connection.address,
+                .handle = port->attached_device
+        };
+
+        ret = usb_hc_register_device(&port->hc_connection, &new_device);
         // TODO: proper error check here
         assert(ret == EOK);

uspace/drv/uhci-rhd/port.h

@@ -38 +38 @@
 #include <driver.h> /* device_t */
 #include <stdint.h>
+#include <usb/usbdevice.h>
 
 #include "port_status.h"
@@ -46 +47 @@
         unsigned number;
         unsigned wait_period_usec;
-        int hc_phone;
+        usb_hc_connection_t hc_connection;
         device_t *rh;
         devman_handle_t attached_device;

uspace/drv/usbhid/hid.h

@@ -69 +69 @@
         device_t *device;
         usb_hid_configuration_t *conf;
-        usb_address_t address;
         usb_hid_report_parser_t *parser;
 
         usb_device_connection_t wire;
+        usb_endpoint_pipe_t ctrl_pipe;
         usb_endpoint_pipe_t poll_pipe;
 } usb_hid_dev_kbd_t;

uspace/drv/usbhid/main.c

@@ -45 +45 @@
 #include <str_error.h>
 #include <fibril.h>
+#include <usb/debug.h>
+#include <usb/classes/classes.h>
 #include <usb/classes/hid.h>
 #include <usb/classes/hidparser.h>
-#include <usb/devreq.h>
+#include <usb/request.h>
 #include <usb/descriptor.h>
 #include <io/console.h>
@@ -60 +62 @@
 
 #define GUESSED_POLL_ENDPOINT 1
+
+/** Keyboard polling endpoint description for boot protocol class. */
+static usb_endpoint_description_t poll_endpoint_description = {
+        .transfer_type = USB_TRANSFER_INTERRUPT,
+        .direction = USB_DIRECTION_IN,
+        .interface_class = USB_CLASS_HID,
+        .interface_subclass = USB_HID_SUBCLASS_BOOT,
+        .interface_protocol = USB_HID_PROTOCOL_KEYBOARD,
+        .flags = 0
+};
 
 static void default_connection_handler(device_t *, ipc_callid_t, ipc_call_t *);
@@ -262 +274 @@
 }
 
-# if 0
 /*
  * Kbd functions
@@ -281 +292 @@
                 
                 // get the descriptor from the device
-                int rc = usb_drv_req_get_descriptor(kbd_dev->device->parent_phone,
-                    kbd_dev->address, USB_REQUEST_TYPE_CLASS, USB_DESCTYPE_HID_REPORT, 
-                    0, i, kbd_dev->conf->interfaces[i].report_desc, length, 
+                int rc = usb_request_get_descriptor(&kbd_dev->ctrl_pipe,
+                    USB_REQUEST_TYPE_CLASS, USB_DESCTYPE_HID_REPORT,
+                    i, 0,
+                    kbd_dev->conf->interfaces[i].report_desc, length,
                     &actual_size);
 
@@ -303 +315 @@
         usb_standard_configuration_descriptor_t config_desc;
         
-        int rc = usb_drv_req_get_bare_configuration_descriptor(
-            kbd_dev->device->parent_phone, kbd_dev->address, 0, &config_desc);
+        int rc;
+        rc = usb_request_get_bare_configuration_descriptor(&kbd_dev->ctrl_pipe,
+            0, &config_desc);
         
         if (rc != EOK) {
@@ -318 +331 @@
         size_t transferred = 0;
         // get full configuration descriptor
-        rc = usb_drv_req_get_full_configuration_descriptor(
-            kbd_dev->device->parent_phone, kbd_dev->address, 0, descriptors,
+        rc = usb_request_get_full_configuration_descriptor(&kbd_dev->ctrl_pipe,
+            0, descriptors,
             config_desc.total_length, &transferred);
         
@@ -329 +342 @@
         }
         
+        /*
+         * Initialize the interrupt in endpoint.
+         */
+        usb_endpoint_mapping_t endpoint_mapping[1] = {
+                {
+                        .pipe = &kbd_dev->poll_pipe,
+                        .description = &poll_endpoint_description
+                }
+        };
+        rc = usb_endpoint_pipe_initialize_from_configuration(
+            endpoint_mapping, 1,
+            descriptors, config_desc.total_length,
+            &kbd_dev->wire);
+        if (rc != EOK) {
+                usb_log_error("Failed to initialize poll pipe: %s.\n",
+                    str_error(rc));
+                return rc;
+        }
+        if (!endpoint_mapping[0].present) {
+                usb_log_warning("Not accepting device, " \
+                    "not boot-protocol keyboard.\n");
+                return EREFUSED;
+        }
+
+
+
+
         kbd_dev->conf = (usb_hid_configuration_t *)calloc(1, 
             sizeof(usb_hid_configuration_t));
@@ -336 +376 @@
         }
         
-        rc = usbkbd_parse_descriptors(descriptors, transferred, kbd_dev->conf);
+        /*rc = usbkbd_parse_descriptors(descriptors, transferred, kbd_dev->conf);
         free(descriptors);
         if (rc != EOK) {
@@ -343 +383 @@
         }
 
-        // get and report descriptors
+        // get and report descriptors*/
         rc = usbkbd_get_report_descriptor(kbd_dev);
         if (rc != EOK) {
@@ -360 +400 @@
      *    as the endpoint for polling
          */
-        
+
         return EOK;
 }
-#endif
+
 static usb_hid_dev_kbd_t *usbkbd_init_device(device_t *dev)
 {
+        int rc;
+
         usb_hid_dev_kbd_t *kbd_dev = (usb_hid_dev_kbd_t *)calloc(1, 
             sizeof(usb_hid_dev_kbd_t));
@@ -376 +418 @@
         kbd_dev->device = dev;
 
-        // get phone to my HC and save it as my parent's phone
-        // TODO: maybe not a good idea if DDF will use parent_phone
-        int rc = kbd_dev->device->parent_phone = usb_drv_hc_connect_auto(dev, 0);
-        if (rc < 0) {
-                printf("Problem setting phone to HC.\n");
-                goto error_leave;
-        }
-
-        rc = kbd_dev->address = usb_drv_get_my_address(dev->parent_phone, dev);
-        if (rc < 0) {
-                printf("Problem getting address of the device.\n");
-                goto error_leave;
-        }
-
-        // doesn't matter now that we have no address
-//      if (kbd_dev->address < 0) {
-//              fprintf(stderr, NAME ": No device address!\n");
-//              free(kbd_dev);
-//              return NULL;
-//      }
-
-        /*
-         * will need all descriptors:
-         * 1) choose one configuration from configuration descriptors 
-         *    (set it to the device)
-         * 2) set endpoints from endpoint descriptors
-         */
-
-
-        // TODO: get descriptors, parse descriptors and save endpoints
-        //usbkbd_process_descriptors(kbd_dev);
-        usb_drv_req_set_configuration(
-          kbd_dev->device->parent_phone, kbd_dev->address, 1);
-
-
-
         /*
          * Initialize the backing connection to the host controller.
@@ -425 +431 @@
          * Initialize device pipes.
          */
-        rc = usb_endpoint_pipe_initialize(&kbd_dev->poll_pipe, &kbd_dev->wire,
-            GUESSED_POLL_ENDPOINT, USB_TRANSFER_INTERRUPT, USB_DIRECTION_IN);
-        if (rc != EOK) {
-                printf("Failed to initialize interrupt in pipe: %s.\n",
+        rc = usb_endpoint_pipe_initialize_default_control(&kbd_dev->ctrl_pipe,
+            &kbd_dev->wire);
+        if (rc != EOK) {
+                printf("Failed to initialize default control pipe: %s.\n",
                     str_error(rc));
                 goto error_leave;
         }
 
+        /*
+         * will need all descriptors:
+         * 1) choose one configuration from configuration descriptors
+         *    (set it to the device)
+         * 2) set endpoints from endpoint descriptors
+         */
+
+        // TODO: get descriptors, parse descriptors and save endpoints
+        usb_endpoint_pipe_start_session(&kbd_dev->ctrl_pipe);
+        //usb_request_set_configuration(&kbd_dev->ctrl_pipe, 1);
+        rc = usbkbd_process_descriptors(kbd_dev);
+        usb_endpoint_pipe_end_session(&kbd_dev->ctrl_pipe);
+        if (rc != EOK) {
+                goto error_leave;
+        }
 
         return kbd_dev;
@@ -590 +611 @@
 int main(int argc, char *argv[])
 {
+        usb_log_enable(USB_LOG_LEVEL_INFO, "usbhid");
         return driver_main(&kbd_driver);
 }

uspace/drv/usbhub/usbhub.c

@@ -36 +36 @@
 #include <bool.h>
 #include <errno.h>
+#include <str_error.h>
 
 #include <usb_iface.h>
 #include <usb/usbdrv.h>
 #include <usb/descriptor.h>
+#include <usb/recognise.h>
 #include <usb/devreq.h>
 #include <usb/request.h>
@@ -76 +78 @@
         result->device = device;
 
+<<<<<<< TREE
         result->usb_device = usb_new(usb_hcd_attached_device_info_t);
         
+=======
+
+        dprintf(USB_LOG_LEVEL_DEBUG, "phone to hc = %d", hc);
+        if (hc < 0) {
+                return result;
+        }
+        //get some hub info
+        usb_address_t addr = usb_drv_get_my_address(hc, device);
+        dprintf(USB_LOG_LEVEL_DEBUG, "address of newly created hub = %d", addr);
+        /*if(addr<0){
+                //return result;
+
+        }*/
+
+        result->address = addr;
+
+>>>>>>> MERGE-SOURCE
         // get hub descriptor
 
@@ -148 +168 @@
         int port;
         int opResult;
+<<<<<<< TREE
         //usb_target_t target;
         //target.address = hub_info->usb_device->address;
         //target.endpoint = 0;
+=======
+        usb_target_t target;
+        target.address = hub_info->address;
+        target.endpoint = 0;
+>>>>>>> MERGE-SOURCE
 
         //get configuration descriptor
@@ -212 +238 @@
         dprintf(USB_LOG_LEVEL_INFO, "hub dev added");
         dprintf(USB_LOG_LEVEL_DEBUG, "\taddress %d, has %d ports ",
-                        hub_info->usb_device->address,
+                        hub_info->address,
                         hub_info->port_count);
         dprintf(USB_LOG_LEVEL_DEBUG, "\tused configuration %d",config_descriptor.configuration_number);
@@ -317 +343 @@
         }
 
+        devman_handle_t hc_handle;
+        opResult = usb_drv_find_hc(hub->device, &hc_handle);
+        if (opResult != EOK) {
+                usb_log_error("Failed to get handle of host controller: %s.\n",
+                    str_error(opResult));
+                return;
+        }
+
         devman_handle_t child_handle;
-        opResult = usb_drv_register_child_in_devman(hc, hub->device,
-            new_device_address, &child_handle);
+        opResult = usb_device_register_child_in_devman(new_device_address,
+            hc_handle, hub->device, &child_handle);
         if (opResult != EOK) {
                 dprintf(USB_LOG_LEVEL_ERROR, "could not start driver for new device");
@@ -472 +506 @@
                 /*
                 usb_target_t target;
-                target.address = hub_info->usb_device->address;
+                target.address = hub_info->address;
                 target.endpoint = 1;/// \TODO get from endpoint descriptor
                 dprintf(USB_LOG_LEVEL_INFO, "checking changes for hub at addr %d",
@@ -515 +549 @@
                         if (interrupt) {
                                 usb_hub_process_interrupt(
+<<<<<<< TREE
                                         hub_info, port);
+=======
+                                        hub_info, hc, port, hub_info->address);
+>>>>>>> MERGE-SOURCE
                         }
                 }

uspace/drv/usbhub/usbhub.h

@@ -36 +36 @@
 #define DRV_USBHUB_USBHUB_H
 
+#include <ipc/devman.h>
+#include <usb/usb.h>
+#include <driver.h>
+
 #define NAME "usbhub"
 
+<<<<<<< TREE
 #include "usb/hcdhubd.h"
 
 #include <usb/pipes.h>
 
+=======
+>>>>>>> MERGE-SOURCE
 /** basic information about device attached to hub */
 typedef struct{
@@ -62 +69 @@
         /** attached device handles, for each port one */
         usb_hub_attached_device_t * attached_devs;
-        /** General usb device info. */
-        usb_hcd_attached_device_info_t * usb_device;
+        /** USB address of the hub. */
+        usb_address_t address;
         /** General device info*/
         device_t * device;
+<<<<<<< TREE
         /** connection to hcd */
         usb_device_connection_t connection;
@@ -71 +79 @@
         usb_hub_endpoints_t endpoints;
 
+=======
+>>>>>>> MERGE-SOURCE
 } usb_hub_info_t;
 

uspace/drv/vhc/conn.h

@@ -37 +37 @@
 
 #include <usb/usb.h>
-#include <usb/hcdhubd.h>
 #include <usbhc_iface.h>
 #include "vhcd.h"
@@ -44 +43 @@
 void connection_handler_host(sysarg_t);
 
-usb_hcd_transfer_ops_t vhc_transfer_ops;
 usbhc_iface_t vhc_iface;
 

uspace/drv/vhc/connhost.c

@@ -36 +36 @@
 #include <errno.h>
 #include <usb/usb.h>
-#include <usb/hcd.h>
+#include <usb/addrkeep.h>
 
 #include "vhcd.h"
@@ -64 +64 @@
 
 static void universal_callback(void *buffer, size_t size,
-    usb_transaction_outcome_t outcome, void *arg)
+    int outcome, void *arg)
 {
         transfer_info_t *transfer = (transfer_info_t *) arg;
@@ -107 +107 @@
 
 static void control_abort_prematurely(control_transfer_info_t *transfer,
-    size_t size, usb_transaction_outcome_t outcome)
+    size_t size, int outcome)
 {
         switch (transfer->direction) {
@@ -127 +127 @@
 
 static void control_callback_two(void *buffer, size_t size,
-    usb_transaction_outcome_t outcome, void *arg)
+    int outcome, void *arg)
 {
         control_transfer_info_t *ctrl_transfer = (control_transfer_info_t *) arg;
 
-        if (outcome != USB_OUTCOME_OK) {
+        if (outcome != EOK) {
                 control_abort_prematurely(ctrl_transfer, outcome, size);
                 free(ctrl_transfer);
@@ -165 +165 @@
 
 static void control_callback_one(void *buffer, size_t size,
-    usb_transaction_outcome_t outcome, void *arg)
+    int outcome, void *arg)
 {
         control_transfer_info_t *transfer = (control_transfer_info_t *) arg;
 
-        if (outcome != USB_OUTCOME_OK) {
+        if (outcome != EOK) {
                 control_abort_prematurely(transfer, outcome, size);
                 free(transfer);
@@ -276 +276 @@
 
 static int interrupt_out(device_t *dev, usb_target_t target,
+    size_t max_packet_size,
     void *data, size_t size,
     usbhc_iface_transfer_out_callback_t callback, void *arg)
@@ -285 +286 @@
 
 static int interrupt_in(device_t *dev, usb_target_t target,
+    size_t max_packet_size,
     void *data, size_t size,
     usbhc_iface_transfer_in_callback_t callback, void *arg)
@@ -294 +296 @@
 
 static int control_write_setup(device_t *dev, usb_target_t target,
+    size_t max_packet_size,
     void *data, size_t size,
     usbhc_iface_transfer_out_callback_t callback, void *arg)
@@ -303 +306 @@
 
 static int control_write_data(device_t *dev, usb_target_t target,
+    size_t max_packet_size,
     void *data, size_t size,
     usbhc_iface_transfer_out_callback_t callback, void *arg)
@@ -320 +324 @@
 
 static int control_write(device_t *dev, usb_target_t target,
+    size_t max_packet_size,
     void *setup_packet, size_t setup_packet_size,
     void *data, size_t data_size,
@@ -337 +342 @@
 
 static int control_read_setup(device_t *dev, usb_target_t target,
+    size_t max_packet_size,
     void *data, size_t size,
     usbhc_iface_transfer_out_callback_t callback, void *arg)
@@ -346 +352 @@
 
 static int control_read_data(device_t *dev, usb_target_t target,
+    size_t max_packet_size,
     void *data, size_t size,
     usbhc_iface_transfer_in_callback_t callback, void *arg)
@@ -363 +370 @@
 
 static int control_read(device_t *dev, usb_target_t target,
+    size_t max_packet_size,
     void *setup_packet, size_t setup_packet_size,
     void *data, size_t data_size,
@@ -382 +390 @@
 
 
-static int reserve_default_address(device_t *dev)
+static int reserve_default_address(device_t *dev, bool ignored)
 {
         usb_address_keeping_reserve_default(&addresses);
@@ -394 +402 @@
 }
 
-static int request_address(device_t *dev, usb_address_t *address)
+static int request_address(device_t *dev, bool ignored, usb_address_t *address)
 {
         usb_address_t addr = usb_address_keeping_request(&addresses);

uspace/drv/vhc/devices.c

@@ -112 +112 @@
  * @param transaction Transaction to be sent over the bus.
  */
-usb_transaction_outcome_t virtdev_send_to_all(transaction_t *transaction)
+int virtdev_send_to_all(transaction_t *transaction)
 {
         /* For easier debugging. */
@@ -126 +126 @@
                         assert(false && "unreachable branch in switch()");
         }
-        usb_transaction_outcome_t outcome = USB_OUTCOME_BABBLE;
+        int outcome = EBADCHECKSUM;
 
         link_t *pos;
@@ -185 +185 @@
                  */
                 if (rc == EOK) {
-                        outcome = USB_OUTCOME_OK;
+                        outcome = EOK;
                 }
         }
@@ -221 +221 @@
                                 break;
                 }
-                outcome = USB_OUTCOME_OK;
+                outcome = EOK;
         }
         

uspace/drv/vhc/devices.h

@@ -54 +54 @@
 virtdev_connection_t *virtdev_find(sysarg_t);
 void virtdev_destroy_device(virtdev_connection_t *);
-usb_transaction_outcome_t virtdev_send_to_all(transaction_t *);
+int virtdev_send_to_all(transaction_t *);
 
 #endif

uspace/drv/vhc/hc.c

@@ -89 +89 @@
  */
 static void process_transaction_with_outcome(transaction_t * transaction,
-    usb_transaction_outcome_t outcome)
+    int outcome)
 {
         usb_log_debug2("Transaction " TRANSACTION_FORMAT " done: %s.\n",
             TRANSACTION_PRINTF(*transaction),
-            usb_str_transaction_outcome(outcome));
+            str_error(outcome));
         
         transaction->callback(transaction->buffer, transaction->actual_len,
@@ -127 +127 @@
                     TRANSACTION_PRINTF(*transaction), ports);
 
-                usb_transaction_outcome_t outcome;
+                int outcome;
                 outcome = virtdev_send_to_all(transaction);
                 

uspace/drv/vhc/hc.h

@@ -47 +47 @@
  */
 typedef void (*hc_transaction_done_callback_t)(void *buffer, size_t size,
-    usb_transaction_outcome_t outcome, void *arg);
+    int outcome, void *arg);
 
 /** Pending transaction details. */

uspace/drv/vhc/hub.c

@@ -41 +41 @@
 #include <driver.h>
 #include <usb/usbdrv.h>
+#include <usb/recognise.h>
 
 #include "hub.h"
@@ -93 +94 @@
 
         devman_handle_t hub_handle;
-        usb_drv_register_child_in_devman(hc, hc_dev, hub_address, &hub_handle);
+        usb_device_register_child_in_devman(hub_address, hc_dev->handle,
+            hc_dev, &hub_handle);
+        //usb_drv_register_child_in_devman(hc, hc_dev, hub_address, &hub_handle);
         usb_drv_bind_address(hc, hub_address, hub_handle);
 

uspace/lib/c/generic/async.c

@@ -1567 +1567 @@
 }
 
+/** Start IPC_M_DATA_READ using the async framework.
+ *
+ * @param phoneid Phone that will be used to contact the receiving side.
+ * @param dst Address of the beginning of the destination buffer.
+ * @param size Size of the destination buffer (in bytes).
+ * @param dataptr Storage of call data (arg 2 holds actual data size).
+ * @return Hash of the sent message or 0 on error.
+ */
+aid_t async_data_read(int phoneid, void *dst, size_t size, ipc_call_t *dataptr)
+{
+        return async_send_2(phoneid, IPC_M_DATA_READ, (sysarg_t) dst,
+            (sysarg_t) size, dataptr);
+}
+
 /** Wrapper for IPC_M_DATA_READ calls using the async framework.
  *

uspace/lib/c/generic/str_error.c

@@ -33 +33 @@
  */
 
+#include <errno.h>
 #include <str_error.h>
 #include <stdio.h>
@@ -63 +64 @@
 static fibril_local char noerr[NOERR_LEN];
 
-const char *str_error(const int errno)
+const char *str_error(const int e)
 {
-        if ((errno <= 0) && (errno >= MIN_ERRNO))
-                return err_desc[-errno];
+        if ((e <= 0) && (e >= MIN_ERRNO))
+                return err_desc[-e];
         
-        snprintf(noerr, NOERR_LEN, "Unkown error code %d", errno);
+        /* Ad hoc descriptions of error codes interesting for USB. */
+        switch (e) {
+                case EBADCHECKSUM:
+                        return "Bad checksum";
+                case EAGAIN:
+                        return "Resource temporarily unavailable";
+                default:
+                        break;
+        }
+
+        snprintf(noerr, NOERR_LEN, "Unkown error code %d", e);
         return noerr;
 }

uspace/lib/c/include/async.h

@@ -340 +340 @@
             (arg4), (answer))
 
+extern aid_t async_data_read(int, void *, size_t, ipc_call_t *);
 extern int async_data_read_start(int, void *, size_t);
 extern bool async_data_read_receive(ipc_callid_t *, size_t *);

uspace/lib/c/include/errno.h

@@ -56 +56 @@
 #define EMLINK        (-266)
 
+/** Bad checksum. */
+#define EBADCHECKSUM  (-300)
+
 /** An API function is called while another blocking function is in progress. */
 #define EINPROGRESS  (-10036)

uspace/lib/drv/generic/remote_usbhc.c

@@ -40 +40 @@
 
 #define USB_MAX_PAYLOAD_SIZE 1020
+#define HACK_MAX_PACKET_SIZE 8
+#define HACK_MAX_PACKET_SIZE_INTERRUPT_IN 4
 
 static void remote_usbhc_get_address(device_t *, void *, ipc_callid_t, ipc_call_t *);
-static void remote_usbhc_get_buffer(device_t *, void *, ipc_callid_t, ipc_call_t *);
 static void remote_usbhc_interrupt_out(device_t *, void *, ipc_callid_t, ipc_call_t *);
 static void remote_usbhc_interrupt_in(device_t *, void *, ipc_callid_t, ipc_call_t *);
@@ -64 +65 @@
         remote_usbhc_get_address,
 
-        remote_usbhc_get_buffer,
-
         remote_usbhc_reserve_default_address,
         remote_usbhc_release_default_address,
@@ -98 +97 @@
 typedef struct {
         ipc_callid_t caller;
+        ipc_callid_t data_caller;
         void *buffer;
         void *setup_packet;
@@ -127 +127 @@
 
         trans->caller = caller;
+        trans->data_caller = 0;
         trans->buffer = NULL;
         trans->setup_packet = NULL;
@@ -155 +156 @@
 }
 
-void remote_usbhc_get_buffer(device_t *device, void *iface,
-    ipc_callid_t callid, ipc_call_t *call)
-{
-        sysarg_t buffer_hash = DEV_IPC_GET_ARG1(*call);
-        async_transaction_t * trans = (async_transaction_t *)buffer_hash;
-        if (trans == NULL) {
-                async_answer_0(callid, ENOENT);
-                return;
-        }
-        if (trans->buffer == NULL) {
-                async_answer_0(callid, EINVAL);
-                async_transaction_destroy(trans);
-                return;
-        }
-
-        ipc_callid_t cid;
-        size_t accepted_size;
-        if (!async_data_read_receive(&cid, &accepted_size)) {
-                async_answer_0(callid, EINVAL);
-                async_transaction_destroy(trans);
-                return;
-        }
-
-        if (accepted_size > trans->size) {
-                accepted_size = trans->size;
-        }
-        async_data_read_finalize(cid, trans->buffer, accepted_size);
-
-        async_answer_1(callid, EOK, accepted_size);
-
-        async_transaction_destroy(trans);
-}
-
 void remote_usbhc_reserve_default_address(device_t *device, void *iface,
     ipc_callid_t callid, ipc_call_t *call)
@@ -197 +165 @@
                 return;
         }
-
-        int rc = usb_iface->reserve_default_address(device);
+        
+        bool full_speed = DEV_IPC_GET_ARG1(*call);
+        
+        int rc = usb_iface->reserve_default_address(device, full_speed);
 
         async_answer_0(callid, rc);
@@ -227 +197 @@
                 return;
         }
+        
+        bool full_speed = DEV_IPC_GET_ARG1(*call);
 
         usb_address_t address;
-        int rc = usb_iface->request_address(device, &address);
+        int rc = usb_iface->request_address(device, full_speed, &address);
         if (rc != EOK) {
                 async_answer_0(callid, rc);
@@ -274 +246 @@
 
 static void callback_out(device_t *device,
-    usb_transaction_outcome_t outcome, void *arg)
+    int outcome, void *arg)
 {
         async_transaction_t *trans = (async_transaction_t *)arg;
@@ -284 +256 @@
 
 static void callback_in(device_t *device,
-    usb_transaction_outcome_t outcome, size_t actual_size, void *arg)
+    int outcome, size_t actual_size, void *arg)
 {
         async_transaction_t *trans = (async_transaction_t *)arg;
 
-        if (outcome != USB_OUTCOME_OK) {
+        if (outcome != EOK) {
                 async_answer_0(trans->caller, outcome);
+                if (trans->data_caller) {
+                        async_answer_0(trans->data_caller, EINTR);
+                }
                 async_transaction_destroy(trans);
                 return;
@@ -295 +270 @@
 
         trans->size = actual_size;
-        async_answer_1(trans->caller, USB_OUTCOME_OK, (sysarg_t)trans);
+
+        if (trans->data_caller) {
+                async_data_read_finalize(trans->data_caller,
+                    trans->buffer, actual_size);
+        }
+
+        async_answer_0(trans->caller, EOK);
+
+        async_transaction_destroy(trans);
 }
 
@@ -345 +328 @@
         trans->size = len;
 
-        int rc = transfer_func(device, target, buffer, len,
+        int rc = transfer_func(device, target, HACK_MAX_PACKET_SIZE,
+            buffer, len,
             callback_out, trans);
 
@@ -376 +360 @@
         };
 
+        ipc_callid_t data_callid;
+        if (!async_data_read_receive(&data_callid, &len)) {
+                async_answer_0(callid, EPARTY);
+                return;
+        }
+
         async_transaction_t *trans = async_transaction_create(callid);
         if (trans == NULL) {
@@ -381 +371 @@
                 return;
         }
+        trans->data_caller = data_callid;
         trans->buffer = malloc(len);
         trans->size = len;
 
-        int rc = transfer_func(device, target, trans->buffer, len,
+        int rc = transfer_func(device, target, HACK_MAX_PACKET_SIZE_INTERRUPT_IN,
+            trans->buffer, len,
             callback_in, trans);
 
@@ -556 +548 @@
                 .endpoint = DEV_IPC_GET_ARG2(*call)
         };
+        size_t data_buffer_len = DEV_IPC_GET_ARG3(*call);
 
         int rc;
@@ -562 +555 @@
         void *data_buffer = NULL;
         size_t setup_packet_len = 0;
-        size_t data_buffer_len = 0;
 
         rc = async_data_write_accept(&setup_packet, false,
@@ -570 +562 @@
                 return;
         }
-        rc = async_data_write_accept(&data_buffer, false,
-            1, USB_MAX_PAYLOAD_SIZE, 0, &data_buffer_len);
-        if (rc != EOK) {
-                async_answer_0(callid, rc);
-                free(setup_packet);
-                return;
+
+        if (data_buffer_len > 0) {
+                rc = async_data_write_accept(&data_buffer, false,
+                    1, USB_MAX_PAYLOAD_SIZE, 0, &data_buffer_len);
+                if (rc != EOK) {
+                        async_answer_0(callid, rc);
+                        free(setup_packet);
+                        return;
+                }
         }
 
@@ -589 +584 @@
         trans->size = data_buffer_len;
 
-        rc = usb_iface->control_write(device, target,
+        rc = usb_iface->control_write(device, target, HACK_MAX_PACKET_SIZE,
             setup_packet, setup_packet_len,
             data_buffer, data_buffer_len,
@@ -612 +607 @@
         }
 
-        size_t data_len = DEV_IPC_GET_ARG3(*call);
         usb_target_t target = {
                 .address = DEV_IPC_GET_ARG1(*call),
@@ -622 +616 @@
         void *setup_packet = NULL;
         size_t setup_packet_len = 0;
+        size_t data_len = 0;
 
         rc = async_data_write_accept(&setup_packet, false,
@@ -627 +622 @@
         if (rc != EOK) {
                 async_answer_0(callid, rc);
+                return;
+        }
+
+        ipc_callid_t data_callid;
+        if (!async_data_read_receive(&data_callid, &data_len)) {
+                async_answer_0(callid, EPARTY);
+                free(setup_packet);
                 return;
         }
@@ -636 +638 @@
                 return;
         }
+        trans->data_caller = data_callid;
         trans->setup_packet = setup_packet;
         trans->size = data_len;
@@ -645 +648 @@
         }
 
-        rc = usb_iface->control_read(device, target,
+        rc = usb_iface->control_read(device, target, HACK_MAX_PACKET_SIZE,
             setup_packet, setup_packet_len,
             trans->buffer, trans->size,

uspace/lib/drv/include/usbhc_iface.h

@@ -40 +40 @@
 #include "driver.h"
 #include <usb/usb.h>
+#include <bool.h>
 
 
@@ -66 +67 @@
  *   - argument #2 is target endpoint
  *   - argument #3 is buffer size
+ * - this call is immediately followed by IPC data read (async version)
  * - the call is not answered until the device returns some data (or until
  *   error occurs)
- * - if the call is answered with EOK, first argument of the answer is buffer
- *   hash that could be used to retrieve the actual data
  *
  * Some special methods (NO-DATA transactions) do not send any data. These
  * might behave as both OUT or IN transactions because communication parts
  * where actual buffers are exchanged are omitted.
- *
- * The mentioned data retrieval can be done any time after receiving EOK
- * answer to IN method.
- * This retrieval is done using the IPC_M_USBHC_GET_BUFFER where
- * the first argument is buffer hash from call answer.
- * This call must be immediately followed by data read-in and after the
- * data are transferred, the initial call (IPC_M_USBHC_GET_BUFFER)
- * is answered. Each buffer can be retrieved only once.
- *
+ **
  * For all these methods, wrap functions exists. Important rule: functions
  * for IN transactions have (as parameters) buffers where retrieved data
@@ -104 +96 @@
         IPC_M_USBHC_GET_ADDRESS,
 
-        /** Asks for data buffer.
-         * See explanation at usb_iface_funcs_t.
-         * This function does not have counter part in functional interface
-         * as it is handled by the remote part itself.
-         */
-        IPC_M_USBHC_GET_BUFFER,
-
 
         /** Reserve usage of default address.
@@ -223 +208 @@
 /** Callback for outgoing transfer. */
 typedef void (*usbhc_iface_transfer_out_callback_t)(device_t *,
-    usb_transaction_outcome_t, void *);
+    int, void *);
 
 /** Callback for incoming transfer. */
 typedef void (*usbhc_iface_transfer_in_callback_t)(device_t *,
-    usb_transaction_outcome_t, size_t, void *);
+    int, size_t, void *);
 
 
 /** Out transfer processing function prototype. */
-typedef int (*usbhc_iface_transfer_out_t)(device_t *, usb_target_t,
+typedef int (*usbhc_iface_transfer_out_t)(device_t *, usb_target_t, size_t,
     void *, size_t,
     usbhc_iface_transfer_out_callback_t, void *);
 
-/** Setup transfer processing function prototype. */
+/** Setup transfer processing function prototype. @deprecated */
 typedef usbhc_iface_transfer_out_t usbhc_iface_transfer_setup_t;
 
 /** In transfer processing function prototype. */
-typedef int (*usbhc_iface_transfer_in_t)(device_t *, usb_target_t,
+typedef int (*usbhc_iface_transfer_in_t)(device_t *, usb_target_t, size_t,
     void *, size_t,
     usbhc_iface_transfer_in_callback_t, void *);
@@ -247 +232 @@
         int (*tell_address)(device_t *, devman_handle_t, usb_address_t *);
 
-        int (*reserve_default_address)(device_t *);
+        int (*reserve_default_address)(device_t *, bool);
         int (*release_default_address)(device_t *);
-        int (*request_address)(device_t *, usb_address_t *);
+        int (*request_address)(device_t *, bool, usb_address_t *);
         int (*bind_address)(device_t *, usb_address_t, devman_handle_t);
         int (*release_address)(device_t *, usb_address_t);
@@ -267 +252 @@
 
         int (*control_write)(device_t *, usb_target_t,
+            size_t,
             void *, size_t, void *, size_t,
             usbhc_iface_transfer_out_callback_t, void *);
 
         int (*control_read)(device_t *, usb_target_t,
+            size_t,
             void *, size_t, void *, size_t,
             usbhc_iface_transfer_in_callback_t, void *);

uspace/lib/usb/Makefile

@@ -39 +39 @@
         src/drvpsync.c \
         src/dump.c \
-        src/hcdhubd.c \
-        src/hcdrv.c \
         src/hidparser.c \
-        src/localdrv.c \
+        src/hub.c \
         src/pipes.c \
+        src/pipesinit.c \
+        src/pipesio.c \
         src/recognise.c \
-        src/remotedrv.c \
         src/request.c \
         src/usb.c \
+        src/usbdevice.c \
         src/usbdrvreq.c \
         src/usbdrv.c \

uspace/lib/usb/include/usb/addrkeep.h

@@ -1 @@
-hcd.h
+/*
+ * Copyright (c) 2010 Vojtech Horky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @addtogroup libusb
+ * @{
+ */
+/** @file
+ * USB address keeping for host controller drivers.
+ */
+#ifndef LIBUSB_ADDRKEEP_H_
+#define LIBUSB_ADDRKEEP_H_
+
+#include <usb/usb.h>
+#include <fibril_synch.h>
+#include <devman.h>
+
+/** Info about used address. */
+typedef struct {
+        /** Linked list member. */
+        link_t link;
+        /** Address. */
+        usb_address_t address;
+        /** Corresponding devman handle. */
+        devman_handle_t devman_handle;
+} usb_address_keeping_used_t;
+
+/** Structure for keeping track of free and used USB addresses. */
+typedef struct {
+        /** Head of list of used addresses. */
+        link_t used_addresses;
+        /** Upper bound for USB addresses. */
+        usb_address_t max_address;
+        /** Mutex protecting used address. */
+        fibril_mutex_t used_addresses_guard;
+        /** Condition variable for used addresses. */
+        fibril_condvar_t used_addresses_condvar;
+
+        /** Condition variable mutex for default address. */
+        fibril_mutex_t default_condvar_guard;
+        /** Condition variable for default address. */
+        fibril_condvar_t default_condvar;
+        /** Whether is default address available. */
+        bool default_available;
+} usb_address_keeping_t;
+
+void usb_address_keeping_init(usb_address_keeping_t *, usb_address_t);
+
+void usb_address_keeping_reserve_default(usb_address_keeping_t *);
+void usb_address_keeping_release_default(usb_address_keeping_t *);
+
+usb_address_t usb_address_keeping_request(usb_address_keeping_t *);
+int usb_address_keeping_release(usb_address_keeping_t *, usb_address_t);
+void usb_address_keeping_devman_bind(usb_address_keeping_t *, usb_address_t,
+    devman_handle_t);
+usb_address_t usb_address_keeping_find(usb_address_keeping_t *,
+    devman_handle_t);
+
+#endif
+/**
+ * @}
+ */

uspace/lib/usb/include/usb/classes/hid.h

@@ -50 +50 @@
         USB_HIDREQ_SET_PROTOCOL = 11
 } usb_hid_request_t;
+
+/** USB/HID subclass constants. */
+typedef enum {
+        USB_HID_SUBCLASS_NONE = 0,
+        USB_HID_SUBCLASS_BOOT = 1
+} usb_hid_subclass_t;
 
 /** USB/HID interface protocols. */

uspace/lib/usb/include/usb/classes/hub.h

@@ -37 +37 @@
 
 #include <sys/types.h>
-#include <usb/hcdhubd.h>
-
 
 /** Hub class feature selector.
@@ -80 +78 @@
     /**
             D1...D0: Logical Power Switching Mode
-            00: Ganged power switching (all ports’ power at
+            00: Ganged power switching (all ports power at
             once)
             01: Individual port power switching
@@ -91 +89 @@
             00: Global Over-current Protection. The hub
             reports over-current as a summation of all
-            ports’ current draw, without a breakdown of
+            ports current draw, without a breakdown of
             individual port over-current status.
             01: Individual Port Over-current Protection. The

uspace/lib/usb/include/usb/hub.h

@@ -1 +1 @@
 /*
- * Copyright (c) 2010 Vojtech Horky
+ * Copyright (c) 2011 Vojtech Horky
  * All rights reserved.
  *
@@ -31 +31 @@
  */
 /** @file
- * @brief HC driver.
+ * Functions needed by hub drivers.
  */
-#ifndef LIBUSB_HCD_H_
-#define LIBUSB_HCD_H_
+#ifndef LIBUSB_HUB_H_
+#define LIBUSB_HUB_H_
 
-#include <usb/usb.h>
-#include <fibril_synch.h>
-#include <devman.h>
+#include <sys/types.h>
+#include <usb/usbdevice.h>
 
-/** Info about used address. */
+/** Info about device attached to host controller.
+ *
+ * This structure exists only to keep the same signature of
+ * usb_hc_register_device() when more properties of the device
+ * would have to be passed to the host controller.
+ */
 typedef struct {
-        /** Linked list member. */
-        link_t link;
-        /** Address. */
+        /** Device address. */
         usb_address_t address;
-        /** Corresponding devman handle. */
-        devman_handle_t devman_handle;
-} usb_address_keeping_used_t;
+        /** Devman handle of the device. */
+        devman_handle_t handle;
+} usb_hc_attached_device_t;
 
-/** Structure for keeping track of free and used USB addresses. */
-typedef struct {
-        /** Head of list of used addresses. */
-        link_t used_addresses;
-        /** Upper bound for USB addresses. */
-        usb_address_t max_address;
-        /** Mutex protecting used address. */
-        fibril_mutex_t used_addresses_guard;
-        /** Condition variable for used addresses. */
-        fibril_condvar_t used_addresses_condvar;
+int usb_hc_reserve_default_address(usb_hc_connection_t *, bool);
+int usb_hc_release_default_address(usb_hc_connection_t *);
 
-        /** Condition variable mutex for default address. */
-        fibril_mutex_t default_condvar_guard;
-        /** Condition variable for default address. */
-        fibril_condvar_t default_condvar;
-        /** Whether is default address available. */
-        bool default_available;
-} usb_address_keeping_t;
-
-void usb_address_keeping_init(usb_address_keeping_t *, usb_address_t);
-
-void usb_address_keeping_reserve_default(usb_address_keeping_t *);
-void usb_address_keeping_release_default(usb_address_keeping_t *);
-
-usb_address_t usb_address_keeping_request(usb_address_keeping_t *);
-int usb_address_keeping_release(usb_address_keeping_t *, usb_address_t);
-void usb_address_keeping_devman_bind(usb_address_keeping_t *, usb_address_t,
-    devman_handle_t);
-usb_address_t usb_address_keeping_find(usb_address_keeping_t *,
-    devman_handle_t);
+usb_address_t usb_hc_request_address(usb_hc_connection_t *, bool);
+int usb_hc_register_device(usb_hc_connection_t *,
+    const usb_hc_attached_device_t *);
+int usb_hc_unregister_device(usb_hc_connection_t *, usb_address_t);
 
 #endif

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

@@ -31 +31 @@
  */
 /** @file
- * Communication between device drivers and host controller driver.
+ * USB pipes representation.
  */
 #ifndef LIBUSB_PIPES_H_
@@ -38 +38 @@
 #include <sys/types.h>
 #include <usb/usb.h>
+#include <usb/usbdevice.h>
+#include <usb/descriptor.h>
 #include <ipc/devman.h>
 #include <driver.h>
@@ -73 +75 @@
         usb_direction_t direction;
 
+        /** Maximum packet size for the endpoint. */
+        size_t max_packet_size;
+
         /** Phone to the host controller.
          * Negative when no session is active.
@@ -80 +85 @@
 
 
+/** Description of endpoint characteristics. */
+typedef struct {
+        /** Transfer type (e.g. control or interrupt). */
+        usb_transfer_type_t transfer_type;
+        /** Transfer direction (to or from a device). */
+        usb_direction_t direction;
+        /** Interface class this endpoint belongs to (-1 for any). */
+        int interface_class;
+        /** Interface subclass this endpoint belongs to (-1 for any). */
+        int interface_subclass;
+        /** Interface protocol this endpoint belongs to (-1 for any). */
+        int interface_protocol;
+        /** Extra endpoint flags. */
+        unsigned int flags;
+} usb_endpoint_description_t;
+
+/** Mapping of endpoint pipes and endpoint descriptions. */
+typedef struct {
+        /** Endpoint pipe. */
+        usb_endpoint_pipe_t *pipe;
+        /** Endpoint description. */
+        const usb_endpoint_description_t *description;
+        /** Found descriptor fitting the description. */
+        usb_standard_endpoint_descriptor_t *descriptor;
+        /** Interface the endpoint belongs to. */
+        usb_standard_interface_descriptor_t *interface;
+        /** Whether the endpoint was actually found. */
+        bool present;
+} usb_endpoint_mapping_t;
+
+int usb_device_connection_initialize_on_default_address(
+    usb_device_connection_t *, usb_hc_connection_t *);
 int usb_device_connection_initialize_from_device(usb_device_connection_t *,
     device_t *);
@@ -87 +124 @@
 int usb_endpoint_pipe_initialize(usb_endpoint_pipe_t *,
     usb_device_connection_t *,
-    usb_endpoint_t, usb_transfer_type_t, usb_direction_t);
+    usb_endpoint_t, usb_transfer_type_t, size_t, usb_direction_t);
 int usb_endpoint_pipe_initialize_default_control(usb_endpoint_pipe_t *,
     usb_device_connection_t *);
+int usb_endpoint_pipe_initialize_from_configuration(usb_endpoint_mapping_t *,
+    size_t, uint8_t *, size_t, usb_device_connection_t *);
 
 
@@ -103 +142 @@
     void *, size_t);
 
-
-
-int usb_endpoint_pipe_async_read(usb_endpoint_pipe_t *, void *, size_t,
-    size_t *, usb_handle_t *);
-int usb_endpoint_pipe_async_write(usb_endpoint_pipe_t *, void *, size_t,
-    usb_handle_t *);
-
-int usb_endpoint_pipe_async_control_read(usb_endpoint_pipe_t *, void *, size_t,
-    void *, size_t, size_t *, usb_handle_t *);
-int usb_endpoint_pipe_async_control_write(usb_endpoint_pipe_t *, void *, size_t,
-    void *, size_t, usb_handle_t *);
-
-int usb_endpoint_pipe_wait_for(usb_endpoint_pipe_t *, usb_handle_t);
-
 #endif
 /**

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

@@ -83 +83 @@
 } usb_request_recipient_t;
 
-/** USB transaction outcome. */
-typedef enum {
-        USB_OUTCOME_OK,
-        USB_OUTCOME_CRCERROR,
-        USB_OUTCOME_BABBLE
-} usb_transaction_outcome_t;
-
-const char * usb_str_transaction_outcome(usb_transaction_outcome_t o);
-
 /** USB address type.
  * Negative values could be used to indicate error.

uspace/lib/usb/include/usb/usbdrv.h

@@ -106 +106 @@
     const void *, size_t);
 
-int usb_drv_create_device_match_ids(int, match_id_list_t *, usb_address_t);
-int usb_drv_register_child_in_devman(int, device_t *, usb_address_t,
-    devman_handle_t *);
-
 
 #endif

uspace/lib/usb/src/addrkeep.c

@@ -33 +33 @@
  * @brief Address keeping.
  */
-#include <usb/hcd.h>
+#include <usb/addrkeep.h>
 #include <errno.h>
 #include <assert.h>

uspace/lib/usb/src/dump.c

@@ -147 +147 @@
         PRINTLINE("bDeviceProtocol = 0x%02x", d->device_protocol);
         PRINTLINE("bMaxPacketSize0 = %d", d->max_packet_size);
-        PRINTLINE("idVendor = %d", d->vendor_id);
-        PRINTLINE("idProduct = %d", d->product_id);
+        PRINTLINE("idVendor = 0x%04x", d->vendor_id);
+        PRINTLINE("idProduct = 0x%04x", d->product_id);
         PRINTLINE("bcdDevice = %d", d->device_version);
         PRINTLINE("iManufacturer = %d", d->str_manufacturer);

uspace/lib/usb/src/pipes.c

@@ -31 +31 @@
  */
 /** @file
- * Communication between device drivers and host controller driver.
- *
- * Note on synchronousness of the operations: there is ABSOLUTELY NO
- * guarantee that a call to particular function will not trigger a fibril
- * switch.
- * The initialization functions may actually involve contacting some other
- * task, starting/ending a session might involve asynchronous IPC and since
- * the transfer functions uses IPC, asynchronous nature of them is obvious.
- * The pseudo synchronous versions for the transfers internally call the
- * asynchronous ones and so fibril switch is possible in them as well.
+ * USB endpoint pipes miscellaneous functions.
  */
 #include <usb/usb.h>
@@ -47 +38 @@
 #include <assert.h>
 #include <usb/usbdrv.h>
-
-#define _PREPARE_TARGET(varname, pipe) \
-        usb_target_t varname = { \
-                .address = (pipe)->wire->address, \
-                .endpoint = (pipe)->endpoint_no \
-        }
 
 /** Initialize connection to USB device.
@@ -117 +102 @@
 }
 
-/** Initialize USB endpoint pipe.
+/** Initialize connection to USB device on default address.
  *
- * @param pipe Endpoint pipe to be initialized.
- * @param connection Connection to the USB device backing this pipe (the wire).
- * @param endpoint_no Endpoint number (in USB 1.1 in range 0 to 15).
- * @param transfer_type Transfer type (e.g. interrupt or bulk).
- * @param direction Endpoint direction (in/out).
+ * @param dev_connection Device connection structure to be initialized.
+ * @param hc_connection Initialized connection to host controller.
  * @return Error code.
  */
-int usb_endpoint_pipe_initialize(usb_endpoint_pipe_t *pipe,
-    usb_device_connection_t *connection, usb_endpoint_t endpoint_no,
-    usb_transfer_type_t transfer_type, usb_direction_t direction)
+int usb_device_connection_initialize_on_default_address(
+    usb_device_connection_t *dev_connection,
+    usb_hc_connection_t *hc_connection)
 {
-        assert(pipe);
-        assert(connection);
+        assert(dev_connection);
 
-        pipe->wire = connection;
-        pipe->hc_phone = -1;
-        pipe->endpoint_no = endpoint_no;
-        pipe->transfer_type = transfer_type;
-        pipe->direction = direction;
+        if (hc_connection == NULL) {
+                return EBADMEM;
+        }
 
-        return EOK;
-}
-
-
-/** Initialize USB endpoint pipe as the default zero control pipe.
- *
- * @param pipe Endpoint pipe to be initialized.
- * @param connection Connection to the USB device backing this pipe (the wire).
- * @return Error code.
- */
-int usb_endpoint_pipe_initialize_default_control(usb_endpoint_pipe_t *pipe,
-    usb_device_connection_t *connection)
-{
-        assert(pipe);
-        assert(connection);
-
-        int rc = usb_endpoint_pipe_initialize(pipe, connection,
-            0, USB_TRANSFER_CONTROL, USB_DIRECTION_BOTH);
-
-        return rc;
+        return usb_device_connection_initialize(dev_connection,
+            hc_connection->hc_handle, (usb_address_t) 0);
 }
 
@@ -221 +182 @@
 }
 
-
-/** Request a read (in) transfer on an endpoint pipe.
- *
- * @param[in] pipe Pipe used for the transfer.
- * @param[out] buffer Buffer where to store the data.
- * @param[in] size Size of the buffer (in bytes).
- * @param[out] size_transfered Number of bytes that were actually transfered.
- * @return Error code.
- */
-int usb_endpoint_pipe_read(usb_endpoint_pipe_t *pipe,
-    void *buffer, size_t size, size_t *size_transfered)
-{
-        assert(pipe);
-
-        int rc;
-        usb_handle_t handle;
-
-        rc = usb_endpoint_pipe_async_read(pipe, buffer, size, size_transfered,
-            &handle);
-        if (rc != EOK) {
-                return rc;
-        }
-
-        rc = usb_endpoint_pipe_wait_for(pipe, handle);
-        return rc;
-}
-
-/** Request a write (out) transfer on an endpoint pipe.
- *
- * @param[in] pipe Pipe used for the transfer.
- * @param[in] buffer Buffer with data to transfer.
- * @param[in] size Size of the buffer (in bytes).
- * @return Error code.
- */
-int usb_endpoint_pipe_write(usb_endpoint_pipe_t *pipe,
-    void *buffer, size_t size)
-{
-        assert(pipe);
-
-        int rc;
-        usb_handle_t handle;
-
-        rc = usb_endpoint_pipe_async_write(pipe, buffer, size, &handle);
-        if (rc != EOK) {
-                return rc;
-        }
-
-        rc = usb_endpoint_pipe_wait_for(pipe, handle);
-        return rc;
-}
-
-
-/** Request a control read transfer on an endpoint pipe.
- *
- * This function encapsulates all three stages of a control transfer.
- *
- * @param[in] pipe Pipe used for the transfer.
- * @param[in] setup_buffer Buffer with the setup packet.
- * @param[in] setup_buffer_size Size of the setup packet (in bytes).
- * @param[out] data_buffer Buffer for incoming data.
- * @param[in] data_buffer_size Size of the buffer for incoming data (in bytes).
- * @param[out] data_transfered_size Number of bytes that were actually
- *                                  transfered during the DATA stage.
- * @return Error code.
- */
-int usb_endpoint_pipe_control_read(usb_endpoint_pipe_t *pipe,
-    void *setup_buffer, size_t setup_buffer_size,
-    void *data_buffer, size_t data_buffer_size, size_t *data_transfered_size)
-{
-        assert(pipe);
-
-        int rc;
-        usb_handle_t handle;
-
-        rc = usb_endpoint_pipe_async_control_read(pipe,
-            setup_buffer, setup_buffer_size,
-            data_buffer, data_buffer_size, data_transfered_size,
-            &handle);
-        if (rc != EOK) {
-                return rc;
-        }
-
-        rc = usb_endpoint_pipe_wait_for(pipe, handle);
-        return rc;
-}
-
-
-/** Request a control write transfer on an endpoint pipe.
- *
- * This function encapsulates all three stages of a control transfer.
- *
- * @param[in] pipe Pipe used for the transfer.
- * @param[in] setup_buffer Buffer with the setup packet.
- * @param[in] setup_buffer_size Size of the setup packet (in bytes).
- * @param[in] data_buffer Buffer with data to be sent.
- * @param[in] data_buffer_size Size of the buffer with outgoing data (in bytes).
- * @return Error code.
- */
-int usb_endpoint_pipe_control_write(usb_endpoint_pipe_t *pipe,
-    void *setup_buffer, size_t setup_buffer_size,
-    void *data_buffer, size_t data_buffer_size)
-{
-        assert(pipe);
-
-        int rc;
-        usb_handle_t handle;
-
-        rc = usb_endpoint_pipe_async_control_write(pipe,
-            setup_buffer, setup_buffer_size,
-            data_buffer, data_buffer_size,
-            &handle);
-        if (rc != EOK) {
-                return rc;
-        }
-
-        rc = usb_endpoint_pipe_wait_for(pipe, handle);
-        return rc;
-}
-
-
-/** Request a read (in) transfer on an endpoint pipe (asynchronous version).
- *
- * @param[in] pipe Pipe used for the transfer.
- * @param[out] buffer Buffer where to store the data.
- * @param[in] size Size of the buffer (in bytes).
- * @param[out] size_transfered Number of bytes that were actually transfered.
- * @param[out] handle Handle of the transfer.
- * @return Error code.
- */
-int usb_endpoint_pipe_async_read(usb_endpoint_pipe_t *pipe,
-    void *buffer, size_t size, size_t *size_transfered,
-    usb_handle_t *handle)
-{
-        assert(pipe);
-
-        if (pipe->hc_phone < 0) {
-                return EBADF;
-        }
-
-        if (pipe->direction != USB_DIRECTION_IN) {
-                return EBADF;
-        }
-
-        int rc;
-        _PREPARE_TARGET(target, pipe);
-
-        switch (pipe->transfer_type) {
-                case USB_TRANSFER_INTERRUPT:
-                        rc = usb_drv_async_interrupt_in(pipe->hc_phone, target,
-                            buffer, size, size_transfered, handle);
-                        break;
-                case USB_TRANSFER_CONTROL:
-                        rc = EBADF;
-                        break;
-                default:
-                        rc = ENOTSUP;
-                        break;
-        }
-
-        return rc;
-}
-
-
-/** Request a write (out) transfer on an endpoint pipe (asynchronous version).
- *
- * @param[in] pipe Pipe used for the transfer.
- * @param[in] buffer Buffer with data to transfer.
- * @param[in] size Size of the buffer (in bytes).
- * @param[out] handle Handle of the transfer.
- * @return Error code.
- */
-int usb_endpoint_pipe_async_write(usb_endpoint_pipe_t *pipe,
-    void *buffer, size_t size,
-    usb_handle_t *handle)
-{
-        assert(pipe);
-
-        if (pipe->hc_phone < 0) {
-                return EBADF;
-        }
-
-        if (pipe->direction != USB_DIRECTION_OUT) {
-                return EBADF;
-        }
-
-        int rc;
-        _PREPARE_TARGET(target, pipe);
-
-        switch (pipe->transfer_type) {
-                case USB_TRANSFER_INTERRUPT:
-                        rc = usb_drv_async_interrupt_out(pipe->hc_phone, target,
-                            buffer, size, handle);
-                        break;
-                case USB_TRANSFER_CONTROL:
-                        rc = EBADF;
-                        break;
-                default:
-                        rc = ENOTSUP;
-                        break;
-        }
-
-        return rc;
-}
-
-
-/** Request a control read transfer on an endpoint pipe (asynchronous version).
- *
- * This function encapsulates all three stages of a control transfer.
- *
- * @param[in] pipe Pipe used for the transfer.
- * @param[in] setup_buffer Buffer with the setup packet.
- * @param[in] setup_buffer_size Size of the setup packet (in bytes).
- * @param[out] data_buffer Buffer for incoming data.
- * @param[in] data_buffer_size Size of the buffer for incoming data (in bytes).
- * @param[out] data_transfered_size Number of bytes that were actually
- *                                  transfered during the DATA stage.
- * @param[out] handle Handle of the transfer.
- * @return Error code.
- */
-int usb_endpoint_pipe_async_control_read(usb_endpoint_pipe_t *pipe,
-    void *setup_buffer, size_t setup_buffer_size,
-    void *data_buffer, size_t data_buffer_size, size_t *data_transfered_size,
-    usb_handle_t *handle)
-{
-        assert(pipe);
-
-        if (pipe->hc_phone < 0) {
-                return EBADF;
-        }
-
-        if ((pipe->direction != USB_DIRECTION_BOTH)
-            || (pipe->transfer_type != USB_TRANSFER_CONTROL)) {
-                return EBADF;
-        }
-
-        int rc;
-        _PREPARE_TARGET(target, pipe);
-
-        rc = usb_drv_async_control_read(pipe->hc_phone, target,
-            setup_buffer, setup_buffer_size,
-            data_buffer, data_buffer_size, data_transfered_size,
-            handle);
-
-        return rc;
-}
-
-
-/** Request a control write transfer on an endpoint pipe (asynchronous version).
- *
- * This function encapsulates all three stages of a control transfer.
- *
- * @param[in] pipe Pipe used for the transfer.
- * @param[in] setup_buffer Buffer with the setup packet.
- * @param[in] setup_buffer_size Size of the setup packet (in bytes).
- * @param[in] data_buffer Buffer with data to be sent.
- * @param[in] data_buffer_size Size of the buffer with outgoing data (in bytes).
- * @param[out] handle Handle of the transfer.
- * @return Error code.
- */
-int usb_endpoint_pipe_async_control_write(usb_endpoint_pipe_t *pipe,
-    void *setup_buffer, size_t setup_buffer_size,
-    void *data_buffer, size_t data_buffer_size,
-    usb_handle_t *handle)
-{
-        assert(pipe);
-
-        if (pipe->hc_phone < 0) {
-                return EBADF;
-        }
-
-        if ((pipe->direction != USB_DIRECTION_BOTH)
-            || (pipe->transfer_type != USB_TRANSFER_CONTROL)) {
-                return EBADF;
-        }
-
-        int rc;
-        _PREPARE_TARGET(target, pipe);
-
-        rc = usb_drv_async_control_write(pipe->hc_phone, target,
-            setup_buffer, setup_buffer_size,
-            data_buffer, data_buffer_size,
-            handle);
-
-        return rc;
-}
-
-/** Wait for transfer completion.
- *
- * The function blocks the caller fibril until the transfer associated
- * with given @p handle is completed.
- *
- * @param[in] pipe Pipe the transfer executed on.
- * @param[in] handle Transfer handle.
- * @return Error code.
- */
-int usb_endpoint_pipe_wait_for(usb_endpoint_pipe_t *pipe, usb_handle_t handle)
-{
-        return usb_drv_async_wait_for(handle);
-}
-
-
 /**
  * @}

uspace/lib/usb/src/recognise.c

@@ -36 +36 @@
 #include <usb_iface.h>
 #include <usb/usbdrv.h>
+#include <usb/pipes.h>
+#include <usb/recognise.h>
+#include <usb/request.h>
 #include <usb/classes/classes.h>
 #include <stdio.h>
 #include <errno.h>
+
+static size_t device_name_index = 0;
+static FIBRIL_MUTEX_INITIALIZE(device_name_index_mutex);
 
 /** Callback for getting host controller handle.
@@ -70 +76 @@
 };
 
-static device_ops_t child_ops = {
+device_ops_t child_ops = {
         .interfaces[USB_DEV_IFACE] = &usb_iface
 };
@@ -155 +161 @@
                 /* First, with release number. */
                 rc = usb_add_match_id(matches, 100,
-                    "usb&vendor=%d&product=%d&release=" BCD_FMT,
+                    "usb&vendor=0x%04x&product=0x%04x&release=" BCD_FMT,
                     (int) device_descriptor->vendor_id,
                     (int) device_descriptor->product_id,
@@ -164 +170 @@
                 
                 /* Next, without release number. */
-                rc = usb_add_match_id(matches, 90, "usb&vendor=%d&product=%d",
+                rc = usb_add_match_id(matches, 90,
+                    "usb&vendor=0x%04x&product=0x%04x",
                     (int) device_descriptor->vendor_id,
                     (int) device_descriptor->product_id);
@@ -241 +248 @@
 /** Add match ids based on configuration descriptor.
  *
- * @param hc Open phone to host controller.
+ * @param pipe Control pipe to the device.
  * @param matches Match ids list to add matches to.
- * @param address USB address of the attached device.
  * @param config_count Number of configurations the device has.
  * @return Error code.
  */
-static int usb_add_config_descriptor_match_ids(int hc,
-    match_id_list_t *matches, usb_address_t address,
-    int config_count)
+static int usb_add_config_descriptor_match_ids(usb_endpoint_pipe_t *pipe,
+    match_id_list_t *matches, int config_count)
 {
         int final_rc = EOK;
@@ -257 +262 @@
                 int rc;
                 usb_standard_configuration_descriptor_t config_descriptor;
-                rc = usb_drv_req_get_bare_configuration_descriptor(hc,
-                    address,  config_index, &config_descriptor);
+                rc = usb_request_get_bare_configuration_descriptor(pipe,
+                    config_index, &config_descriptor);
                 if (rc != EOK) {
                         final_rc = rc;
@@ -267 +272 @@
                 void *full_config_descriptor
                     = malloc(config_descriptor.total_length);
-                rc = usb_drv_req_get_full_configuration_descriptor(hc,
-                    address, config_index,
+                rc = usb_request_get_full_configuration_descriptor(pipe,
+                    config_index,
                     full_config_descriptor, config_descriptor.total_length,
                     &full_config_descriptor_size);
@@ -299 +304 @@
  * function exits with error.
  *
- * @param hc Open phone to host controller.
+ * @param ctrl_pipe Control pipe to given device (session must be already
+ *      started).
  * @param matches Initialized list of match ids.
- * @param address USB address of the attached device.
- * @return Error code.
- */
-int usb_drv_create_device_match_ids(int hc, match_id_list_t *matches,
-    usb_address_t address)
+ * @return Error code.
+ */
+int usb_device_create_match_ids(usb_endpoint_pipe_t *ctrl_pipe,
+    match_id_list_t *matches)
 {
         int rc;
-        
         /*
          * Retrieve device descriptor and add matches from it.
@@ -314 +318 @@
         usb_standard_device_descriptor_t device_descriptor;
 
-        rc = usb_drv_req_get_device_descriptor(hc, address,
-            &device_descriptor);
+        rc = usb_request_get_device_descriptor(ctrl_pipe, &device_descriptor);
         if (rc != EOK) {
                 return rc;
         }
-        
+
         rc = usb_drv_create_match_ids_from_device_descriptor(matches,
             &device_descriptor);
@@ -325 +328 @@
                 return rc;
         }
-        
+
         /*
          * Go through all configurations and add matches
          * based on interface class.
          */
-        rc = usb_add_config_descriptor_match_ids(hc, matches,
-            address, device_descriptor.configuration_count);
+        rc = usb_add_config_descriptor_match_ids(ctrl_pipe, matches,
+            device_descriptor.configuration_count);
         if (rc != EOK) {
                 return rc;
@@ -347 +350 @@
 }
 
-
 /** Probe for device kind and register it in devman.
  *
- * @param[in] hc Open phone to the host controller.
+ * @param[in] address Address of the (unknown) attached device.
+ * @param[in] hc_handle Handle of the host controller.
  * @param[in] parent Parent device.
- * @param[in] address Address of the (unknown) attached device.
  * @param[out] child_handle Handle of the child device.
  * @return Error code.
  */
-int usb_drv_register_child_in_devman(int hc, device_t *parent,
-    usb_address_t address, devman_handle_t *child_handle)
-{
-        static size_t device_name_index = 0;
-        static FIBRIL_MUTEX_INITIALIZE(device_name_index_mutex);
-
+int usb_device_register_child_in_devman(usb_address_t address,
+    devman_handle_t hc_handle,
+    device_t *parent, devman_handle_t *child_handle)
+{
         size_t this_device_name_index;
 
@@ -369 +369 @@
         fibril_mutex_unlock(&device_name_index_mutex);
 
-
         device_t *child = NULL;
         char *child_name = NULL;
         int rc;
+        usb_device_connection_t dev_connection;
+        usb_endpoint_pipe_t ctrl_pipe;
+
+        rc = usb_device_connection_initialize(&dev_connection, hc_handle, address);
+        if (rc != EOK) {
+                goto failure;
+        }
+
+        rc = usb_endpoint_pipe_initialize_default_control(&ctrl_pipe,
+            &dev_connection);
+        if (rc != EOK) {
+                goto failure;
+        }
 
         child = create_device();
@@ -391 +403 @@
         child->name = child_name;
         child->ops = &child_ops;
-        
-        rc = usb_drv_create_device_match_ids(hc, &child->match_ids, address);
+
+        rc = usb_endpoint_pipe_start_session(&ctrl_pipe);
+        if (rc != EOK) {
+                goto failure;
+        }
+
+        rc = usb_device_create_match_ids(&ctrl_pipe, &child->match_ids);
+        if (rc != EOK) {
+                goto failure;
+        }
+
+        rc = usb_endpoint_pipe_end_session(&ctrl_pipe);
         if (rc != EOK) {
                 goto failure;
@@ -405 +427 @@
                 *child_handle = child->handle;
         }
-        
+
         return EOK;
 
@@ -419 +441 @@
 
         return rc;
-
 }
 

uspace/lib/usb/src/usb.c

@@ -54 +54 @@
 }
 
-/** String representation of USB transaction outcome. */
-const char * usb_str_transaction_outcome(usb_transaction_outcome_t o)
-{
-        switch (o) {
-                case USB_OUTCOME_OK:
-                        return "ok";
-                case USB_OUTCOME_CRCERROR:
-                        return "CRC error";
-                case USB_OUTCOME_BABBLE:
-                        return "babble";
-                default:
-                        return "unknown";
-        }
-}
-
-
 /**
  * @}

uspace/lib/usb/src/usbdrv.c

@@ -49 +49 @@
         /** Storage for actual number of bytes transferred. */
         size_t *size_transferred;
-        /** Initial call replay data. */
+        /** Initial call reply data. */
         ipc_call_t reply;
         /** Initial call identifier. */
         aid_t request;
+        /** Reply data for data read call. */
+        ipc_call_t read_reply;
+        /** Data read call identifier. */
+        aid_t read_request;
 } transfer_info_t;
 
@@ -140 +144 @@
 
         if (rc != EOK) {
-                printf("usb_drv_get_my_address over %d failed: %s\n", phone, str_error(rc));
                 return rc;
         }
@@ -250 +253 @@
         }
 
+        transfer->read_request = 0;
         transfer->size_transferred = NULL;
         transfer->buffer = NULL;
@@ -315 +319 @@
         }
 
+        transfer->read_request = 0;
         transfer->size_transferred = actual_size;
         transfer->buffer = buffer;
@@ -327 +332 @@
             &transfer->reply);
 
+        if (buffer != NULL) {
+                transfer->read_request = async_data_read(phone, buffer, size,
+                    &transfer->read_reply);
+        }
+
         *handle = (usb_handle_t) transfer;
 
@@ -332 +342 @@
 }
 
-/** Read buffer from HCD.
- *
- * @param phone Opened phone to HCD.
- * @param hash Buffer hash (obtained after completing IN transaction).
- * @param buffer Buffer where to store data data.
- * @param size Buffer size.
- * @param actual_size Storage where actual number of bytes transferred will
- *      be stored.
- * @return Error status.
- */
-static int read_buffer_in(int phone, sysarg_t hash,
-    void *buffer, size_t size, size_t *actual_size)
-{
-        ipc_call_t answer_data;
-        sysarg_t answer_rc;
-        aid_t req;
-        int rc;
-
-        req = async_send_2(phone,
-            DEV_IFACE_ID(USBHC_DEV_IFACE),
-            IPC_M_USBHC_GET_BUFFER,
-            hash,
-            &answer_data);
-
-        rc = async_data_read_start(phone, buffer, size);
-        if (rc != EOK) {
-                async_wait_for(req, NULL);
-                return EINVAL;
-        }
-
-        async_wait_for(req, &answer_rc);
-        rc = (int)answer_rc;
-
-        if (rc != EOK) {
-                return rc;
-        }
-
-        *actual_size = IPC_GET_ARG1(answer_data);
-
-        return EOK;
-}
 
 /** Blocks caller until given USB transaction is finished.
@@ -395 +364 @@
 
         sysarg_t answer_rc;
-        async_wait_for(transfer->request, &answer_rc);
-
-        if (answer_rc != EOK) {
-                rc = (int) answer_rc;
-                goto leave;
-        }
 
         /*
@@ -406 +369 @@
          */
         if ((transfer->buffer != NULL) && (transfer->size > 0)) {
-                /*
-                 * The buffer hash identifies the data on the server
-                 * side.
-                 * We will use it when actually reading-in the data.
-                 */
-                sysarg_t buffer_hash = IPC_GET_ARG1(transfer->reply);
-                if (buffer_hash == 0) {
-                        rc = ENOENT;
+                async_wait_for(transfer->read_request, &answer_rc);
+
+                if (answer_rc != EOK) {
+                        rc = (int) answer_rc;
                         goto leave;
                 }
 
-                size_t actual_size;
-                rc = read_buffer_in(transfer->phone, buffer_hash,
-                    transfer->buffer, transfer->size, &actual_size);
-
-                if (rc != EOK) {
-                        goto leave;
+                if (transfer->size_transferred != NULL) {
+                        *(transfer->size_transferred)
+                            = IPC_GET_ARG2(transfer->read_reply);
                 }
-
-                if (transfer->size_transferred) {
-                        *(transfer->size_transferred) = actual_size;
-                }
+        }
+
+        async_wait_for(transfer->request, &answer_rc);
+
+        if (answer_rc != EOK) {
+                rc = (int) answer_rc;
+                goto leave;
         }
 
@@ -499 +458 @@
     void *setup_packet, size_t setup_packet_size,
     void *buffer, size_t buffer_size,
+    usb_handle_t *handle)
+{
+        // FIXME - check input parameters instead of asserting them
+        assert(phone > 0);
+        assert(setup_packet != NULL);
+        assert(setup_packet_size > 0);
+        assert(((buffer != NULL) && (buffer_size > 0))
+            || ((buffer == NULL) && (buffer_size == 0)));
+        assert(handle != NULL);
+
+        transfer_info_t *transfer
+            = (transfer_info_t *) malloc(sizeof(transfer_info_t));
+        if (transfer == NULL) {
+                return ENOMEM;
+        }
+
+        transfer->read_request = 0;
+        transfer->size_transferred = NULL;
+        transfer->buffer = NULL;
+        transfer->size = 0;
+        transfer->phone = phone;
+
+        int rc;
+
+        transfer->request = async_send_3(phone,
+            DEV_IFACE_ID(USBHC_DEV_IFACE),
+            IPC_M_USBHC_CONTROL_WRITE,
+            target.address, target.endpoint,
+            &transfer->reply);
+
+        rc = async_data_write_start(phone, setup_packet, setup_packet_size);
+        if (rc != EOK) {
+                async_wait_for(transfer->request, NULL);
+                return rc;
+        }
+
+        if (buffer_size > 0) {
+                rc = async_data_write_start(phone, buffer, buffer_size);
+                if (rc != EOK) {
+                        async_wait_for(transfer->request, NULL);
+                        return rc;
+                }
+        }
+
+        *handle = (usb_handle_t) transfer;
+
+        return EOK;
+}
+
+/** Start control read transfer. */
+int usb_drv_async_control_read_setup(int phone, usb_target_t target,
+    void *buffer, size_t size,
+    usb_handle_t *handle)
+{
+        return async_send_buffer(phone,
+            IPC_M_USBHC_CONTROL_READ_SETUP,
+            target,
+            buffer, size,
+            handle);
+}
+
+/** Read data during control read transfer. */
+int usb_drv_async_control_read_data(int phone, usb_target_t target,
+    void *buffer, size_t size, size_t *actual_size,
+    usb_handle_t *handle)
+{
+        return async_recv_buffer(phone,
+            IPC_M_USBHC_CONTROL_READ_DATA,
+            target,
+            buffer, size, actual_size,
+            handle);
+}
+
+/** Finalize control read transfer. */
+int usb_drv_async_control_read_status(int phone, usb_target_t target,
+    usb_handle_t *handle)
+{
+        return async_send_buffer(phone,
+            IPC_M_USBHC_CONTROL_READ_STATUS,
+            target,
+            NULL, 0,
+            handle);
+}
+
+/** Issue whole control read transfer. */
+int usb_drv_async_control_read(int phone, usb_target_t target,
+    void *setup_packet, size_t setup_packet_size,
+    void *buffer, size_t buffer_size, size_t *actual_size,
     usb_handle_t *handle)
 {
@@ -515 +562 @@
         }
 
-        transfer->size_transferred = NULL;
-        transfer->buffer = NULL;
-        transfer->size = 0;
-        transfer->phone = phone;
-
-        int rc;
-
-        transfer->request = async_send_3(phone,
-            DEV_IFACE_ID(USBHC_DEV_IFACE),
-            IPC_M_USBHC_CONTROL_WRITE,
-            target.address, target.endpoint,
-            &transfer->reply);
-
-        rc = async_data_write_start(phone, setup_packet, setup_packet_size);
-        if (rc != EOK) {
-                async_wait_for(transfer->request, NULL);
-                return rc;
-        }
-
-        rc = async_data_write_start(phone, buffer, buffer_size);
-        if (rc != EOK) {
-                async_wait_for(transfer->request, NULL);
-                return rc;
-        }
-
-        *handle = (usb_handle_t) transfer;
-
-        return EOK;
-}
-
-/** Start control read transfer. */
-int usb_drv_async_control_read_setup(int phone, usb_target_t target,
-    void *buffer, size_t size,
-    usb_handle_t *handle)
-{
-        return async_send_buffer(phone,
-            IPC_M_USBHC_CONTROL_READ_SETUP,
-            target,
-            buffer, size,
-            handle);
-}
-
-/** Read data during control read transfer. */
-int usb_drv_async_control_read_data(int phone, usb_target_t target,
-    void *buffer, size_t size, size_t *actual_size,
-    usb_handle_t *handle)
-{
-        return async_recv_buffer(phone,
-            IPC_M_USBHC_CONTROL_READ_DATA,
-            target,
-            buffer, size, actual_size,
-            handle);
-}
-
-/** Finalize control read transfer. */
-int usb_drv_async_control_read_status(int phone, usb_target_t target,
-    usb_handle_t *handle)
-{
-        return async_send_buffer(phone,
-            IPC_M_USBHC_CONTROL_READ_STATUS,
-            target,
-            NULL, 0,
-            handle);
-}
-
-/** Issue whole control read transfer. */
-int usb_drv_async_control_read(int phone, usb_target_t target,
-    void *setup_packet, size_t setup_packet_size,
-    void *buffer, size_t buffer_size, size_t *actual_size,
-    usb_handle_t *handle)
-{
-        // FIXME - check input parameters instead of asserting them
-        assert(phone > 0);
-        assert(setup_packet != NULL);
-        assert(setup_packet_size > 0);
-        assert(buffer != NULL);
-        assert(buffer_size > 0);
-        assert(handle != NULL);
-
-        transfer_info_t *transfer
-            = (transfer_info_t *) malloc(sizeof(transfer_info_t));
-        if (transfer == NULL) {
-                return ENOMEM;
-        }
-
         transfer->size_transferred = actual_size;
         transfer->buffer = buffer;
@@ -620 +582 @@
         }
 
+        transfer->read_request = async_data_read(phone, buffer, buffer_size,
+            &transfer->read_reply);
+
         *handle = (usb_handle_t) transfer;
 

uspace/lib/usbvirt/Makefile

@@ -30 +30 @@
 LIBRARY = libusbvirt
 
-LIBS = $(LIBUSB_PREFIX)/libusb.a
 EXTRA_CFLAGS = -I$(LIBUSB_PREFIX)/include -Iinclude