Changes in / [6bb83c7:62066b4] in mainline

Location:

uspace

Files:

• drv/pciintel/pci.c (modified) (2 diffs)
• drv/uhci-hcd/batch.c (modified) (6 diffs)
• drv/uhci-hcd/iface.c (modified) (4 diffs)
• drv/uhci-hcd/main.c (modified) (5 diffs)
• drv/uhci-hcd/pci.c (modified) (1 diff)
• drv/uhci-hcd/pci.h (modified) (1 diff)
• drv/uhci-hcd/transfer_list.c (modified) (1 diff)
• drv/uhci-hcd/uhci-hcd.ma (modified) (1 diff)
• drv/uhci-hcd/uhci.c (modified) (7 diffs)
• drv/uhci-hcd/uhci.h (modified) (4 diffs)
• drv/uhci-rhd/port.c (modified) (2 diffs)
• drv/uhci-rhd/root_hub.c (modified) (1 diff)
• drv/usbhub/usbhub.c (modified) (3 diffs)
• drv/vhc/connhost.c (modified) (6 diffs)
• lib/c/generic/str_error.c (modified) (1 diff)
• lib/c/include/errno.h (modified) (1 diff)
• lib/drv/generic/remote_usbhc.c (modified) (16 diffs)
• lib/drv/include/usbhc_iface.h (modified) (6 diffs)
• lib/usb/include/usb/hub.h (modified) (2 diffs)
• lib/usb/include/usb/usb.h (modified) (1 diff)
• lib/usb/src/hub.c (modified) (6 diffs)
• lib/usb/src/pipes.c (modified) (3 diffs)
• lib/usb/src/pipesio.c (modified) (4 diffs)
• lib/usb/src/usbdrv.c (modified) (21 diffs)

uspace/drv/pciintel/pci.c

@@ -49 +49 @@
 #include <ipc/devman.h>
 #include <ipc/dev_iface.h>
+#include <ipc/irc.h>
+#include <ipc/ns.h>
+#include <ipc/services.h>
+#include <sysinfo.h>
 #include <ops/hw_res.h>
 #include <device/hw_res.h>
@@ -72 +76 @@
 static bool pciintel_enable_child_interrupt(device_t *dev)
 {
-        /* TODO */
-        
-        return false;
+        /* This is an old ugly way, copied from ne2000 driver */
+        assert(dev);
+        pci_dev_data_t *dev_data = (pci_dev_data_t *) dev->driver_data;
+
+  sysarg_t apic;
+  sysarg_t i8259;
+        int irc_phone = -1;
+        int irc_service = 0;
+
+  if ((sysinfo_get_value("apic", &apic) == EOK) && (apic)) {
+    irc_service = SERVICE_APIC;
+        } else if ((sysinfo_get_value("i8259", &i8259) == EOK) && (i8259)) {
+    irc_service = SERVICE_I8259;
+        }
+
+  if (irc_service) {
+    while (irc_phone < 0)
+      irc_phone = service_connect_blocking(irc_service, 0, 0);
+  } else {
+                return false;
+        }
+
+        size_t i;
+  for (i = 0; i < dev_data->hw_resources.count; i++) {
+                if (dev_data->hw_resources.resources[i].type == INTERRUPT) {
+                        int irq = dev_data->hw_resources.resources[i].res.interrupt.irq;
+                        async_msg_1(irc_phone, IRC_ENABLE_INTERRUPT, irq);
+                }
+        }
+
+        async_hangup(irc_phone);
+        return true;
 }
 

uspace/drv/uhci-hcd/batch.c

@@ -141 +141 @@
         usb_log_debug("Checking(%p) %d packet for completion.\n",
             instance, instance->packets);
-        /* This is just an ugly trick to support the old API */
         instance->transfered_size = 0;
         size_t i = 0;
@@ -157 +156 @@
                     transfer_descriptor_actual_size(&instance->tds[i]);
         }
+        /* This is just an ugly trick to support the old API */
         instance->transfered_size -= instance->setup_size;
         return true;
@@ -191 +191 @@
             0, 1, false, instance->target, USB_PID_IN, NULL, NULL);
 
+        instance->tds[i].status |= TD_STATUS_COMPLETE_INTERRUPT_FLAG;
+
         instance->next_step = batch_call_out_and_dispose;
         batch_schedule(instance);
@@ -221 +223 @@
         transfer_descriptor_init(&instance->tds[i], DEFAULT_ERROR_COUNT,
             0, 1, false, instance->target, USB_PID_OUT, NULL, NULL);
+
+        instance->tds[i].status |= TD_STATUS_COMPLETE_INTERRUPT_FLAG;
 
         instance->next_step = batch_call_in_and_dispose;
@@ -244 +248 @@
         }
 
+        instance->tds[i - 1].status |= TD_STATUS_COMPLETE_INTERRUPT_FLAG;
+
         instance->next_step = batch_call_in_and_dispose;
         batch_schedule(instance);
@@ -268 +274 @@
         }
 
+        instance->tds[i - 1].status |= TD_STATUS_COMPLETE_INTERRUPT_FLAG;
+
         instance->next_step = batch_call_out_and_dispose;
         batch_schedule(instance);

uspace/drv/uhci-hcd/iface.c

@@ -54 +54 @@
 }
 /*----------------------------------------------------------------------------*/
-static int reserve_default_address(device_t *dev, bool full_speed)
+static int reserve_default_address(device_t *dev, usb_speed_t speed)
 {
         assert(dev);
@@ -72 +72 @@
 }
 /*----------------------------------------------------------------------------*/
-static int request_address(device_t *dev, bool full_speed,
+static int request_address(device_t *dev, usb_speed_t speed,
     usb_address_t *address)
 {
@@ -164 +164 @@
         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;
-
-        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)
-{
-        size_t max_packet_size = 8;
-        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, NULL, 0, NULL, callback, arg);
-        if (!batch)
-                return ENOMEM;
-        batch_control_read_status_old(batch);
-        return EOK;
-}
 /*----------------------------------------------------------------------------*/
 usbhc_iface_t uhci_iface = {
@@ -273 +181 @@
         .control_read = control_read,
         .control_write = control_write,
-
-        .control_write_setup = control_write_setup,
-        .control_write_data = control_write_data,
-        .control_write_status = control_write_status,
-
-        .control_read_setup = control_read_setup,
-        .control_read_data = control_read_data,
-        .control_read_status = control_read_status
 };
 /**

uspace/drv/uhci-hcd/main.c

@@ -34 +34 @@
 #include <driver.h>
 #include <usb_iface.h>
+#include <device/hw_res.h>
 
 #include <errno.h>
@@ -46 +47 @@
 #define NAME "uhci-hcd"
 
+static int uhci_add_device(device_t *device);
+static int usb_iface_get_hc_handle(device_t *dev, devman_handle_t *handle);
+/*----------------------------------------------------------------------------*/
 static int usb_iface_get_hc_handle(device_t *dev, devman_handle_t *handle)
 {
@@ -54 +58 @@
         return EOK;
 }
-
+/*----------------------------------------------------------------------------*/
 static usb_iface_t hc_usb_iface = {
         .get_hc_handle = usb_iface_get_hc_handle
 };
-
+/*----------------------------------------------------------------------------*/
 static device_ops_t uhci_ops = {
         .interfaces[USB_DEV_IFACE] = &hc_usb_iface,
         .interfaces[USBHC_DEV_IFACE] = &uhci_iface
 };
+/*----------------------------------------------------------------------------*/
+static driver_ops_t uhci_driver_ops = {
+        .add_device = uhci_add_device,
+};
+/*----------------------------------------------------------------------------*/
+static driver_t uhci_driver = {
+        .name = NAME,
+        .driver_ops = &uhci_driver_ops
+};
+/*----------------------------------------------------------------------------*/
+static void irq_handler(device_t *device, ipc_callid_t iid, ipc_call_t *call)
+{
+        assert(device);
+        uhci_t *hc = dev_to_uhci(device);
+        uint16_t status = IPC_GET_ARG1(*call);
+        assert(hc);
+        uhci_interrupt(hc, status);
+}
+/*----------------------------------------------------------------------------*/
+#define CHECK_RET_RETURN(ret, message...) \
+if (ret != EOK) { \
+        usb_log_error(message); \
+        return ret; \
+}
 
 static int uhci_add_device(device_t *device)
@@ -75 +103 @@
         int irq;
 
-        int rc = pci_get_my_registers(device,
-            &io_reg_base, &io_reg_size, &irq);
+        int ret =
+            pci_get_my_registers(device, &io_reg_base, &io_reg_size, &irq);
 
-        if (rc != EOK) {
-                usb_log_error("Failed(%d) to get I/O registers addresses for device:.\n",
-                    rc, device->handle);
-                return rc;
-        }
-
+        CHECK_RET_RETURN(ret,
+            "Failed(%d) to get I/O addresses:.\n", ret, device->handle);
         usb_log_info("I/O regs at 0x%X (size %zu), IRQ %d.\n",
             io_reg_base, io_reg_size, irq);
 
+        ret = pci_enable_interrupts(device);
+        CHECK_RET_RETURN(ret, "Failed(%d) to get enable interrupts:\n", ret);
+
         uhci_t *uhci_hc = malloc(sizeof(uhci_t));
-        if (!uhci_hc) {
-                usb_log_error("Failed to allocaete memory for uhci hcd driver.\n");
-                return ENOMEM;
+        ret = (uhci_hc != NULL) ? EOK : ENOMEM;
+        CHECK_RET_RETURN(ret, "Failed to allocate memory for uhci hcd driver.\n");
+
+        ret = uhci_init(uhci_hc, (void*)io_reg_base, io_reg_size);
+        if (ret != EOK) {
+                usb_log_error("Failed to init uhci-hcd.\n");
+                free(uhci_hc);
+                return ret;
         }
 
-        int ret = uhci_init(uhci_hc, (void*)io_reg_base, io_reg_size);
+        ret = register_interrupt_handler(device, irq, irq_handler,
+            &uhci_hc->interrupt_code);
         if (ret != EOK) {
-                usb_log_error("Failed to init uhci-hcd.\n");
+                usb_log_error("Failed to register interrupt handler.\n");
+                uhci_fini(uhci_hc);
+                free(uhci_hc);
                 return ret;
         }
+
         device_t *rh;
         ret = setup_root_hub(&rh, device);
-
         if (ret != EOK) {
                 usb_log_error("Failed to setup uhci root hub.\n");
-                /* TODO: destroy uhci here */
+                uhci_fini(uhci_hc);
+                free(uhci_hc);
                 return ret;
         }
@@ -110 +146 @@
         if (ret != EOK) {
                 usb_log_error("Failed to register root hub.\n");
-                /* TODO: destroy uhci here */
+                uhci_fini(uhci_hc);
+                free(uhci_hc);
+                free(rh);
                 return ret;
         }
 
         device->driver_data = uhci_hc;
-
         return EOK;
 }
-
-static driver_ops_t uhci_driver_ops = {
-        .add_device = uhci_add_device,
-};
-
-static driver_t uhci_driver = {
-        .name = NAME,
-        .driver_ops = &uhci_driver_ops
-};
-
+/*----------------------------------------------------------------------------*/
 int main(int argc, char *argv[])
 {
-        /*
-         * Do some global initializations.
-         */
-        sleep(5);
-        usb_log_enable(USB_LOG_LEVEL_INFO, NAME);
+        sleep(3);
+        usb_log_enable(USB_LOG_LEVEL_DEBUG, NAME);
 
         return driver_main(&uhci_driver);

uspace/drv/uhci-hcd/pci.c

@@ -121 +121 @@
         return rc;
 }
-
+/*----------------------------------------------------------------------------*/
+int pci_enable_interrupts(device_t *device)
+{
+        int parent_phone = devman_parent_device_connect(device->handle,
+            IPC_FLAG_BLOCKING);
+        bool enabled = hw_res_enable_interrupt(parent_phone);
+        return enabled ? EOK : EIO;
+}
 /**
  * @}

uspace/drv/uhci-hcd/pci.h

@@ -39 +39 @@
 
 int pci_get_my_registers(device_t *, uintptr_t *, size_t *, int *);
+int pci_enable_interrupts(device_t *device);
 
 #endif

uspace/drv/uhci-hcd/transfer_list.c

@@ -111 +111 @@
         /* 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",
+                usb_log_debug("Removing batch %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",
+                usb_log_debug("Removing batch %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);

uspace/drv/uhci-hcd/uhci-hcd.ma

@@ -1 +1 @@
 10 pci/ven=8086&dev=7020
-
+10 pci/ven=8086&dev=7112

uspace/drv/uhci-hcd/uhci.c

@@ -39 +39 @@
 
 #include "uhci.h"
+static irq_cmd_t uhci_cmds[] = {
+        {
+                .cmd = CMD_PIO_READ_16,
+                .addr = (void*)0xc022,
+                .dstarg = 1
+        },
+        {
+                .cmd = CMD_PIO_WRITE_16,
+                .addr = (void*)0xc022,
+                .value = 0x1f
+        },
+        {
+                .cmd = CMD_ACCEPT
+        }
+};
 
 static int uhci_init_transfer_lists(uhci_t *instance);
-static int uhci_clean_finished(void *arg);
+static int uhci_init_mem_structures(uhci_t *instance);
+static void uhci_init_hw(uhci_t *instance);
+
+static int uhci_interrupt_emulator(void *arg);
 static int uhci_debug_checker(void *arg);
+
 static bool allowed_usb_packet(
         bool low_speed, usb_transfer_type_t, size_t size);
 
-int uhci_init(uhci_t *instance, void *regs, size_t reg_size)
-{
-#define CHECK_RET_RETURN(message...) \
+#define CHECK_RET_RETURN(ret, message...) \
         if (ret != EOK) { \
                 usb_log_error(message); \
@@ -54 +71 @@
         } else (void) 0
 
-        /* init address keeper(libusb) */
-        usb_address_keeping_init(&instance->address_manager, USB11_ADDRESS_MAX);
-        usb_log_debug("Initialized address manager.\n");
+int uhci_init(uhci_t *instance, void *regs, size_t reg_size)
+{
+        assert(reg_size >= sizeof(regs_t));
 
         /* allow access to hc control registers */
         regs_t *io;
-        assert(reg_size >= sizeof(regs_t));
         int ret = pio_enable(regs, reg_size, (void**)&io);
-        CHECK_RET_RETURN("Failed to gain access to registers at %p.\n", io);
+        CHECK_RET_RETURN(ret, "Failed to gain access to registers at %p.\n", io);
         instance->registers = io;
         usb_log_debug("Device registers accessible.\n");
 
+        ret = uhci_init_mem_structures(instance);
+        CHECK_RET_RETURN(ret, "Failed to initialize memory structures.\n");
+
+        uhci_init_hw(instance);
+
+        instance->cleaner = fibril_create(uhci_interrupt_emulator, instance);
+//      fibril_add_ready(instance->cleaner);
+
+        instance->debug_checker = fibril_create(uhci_debug_checker, instance);
+        fibril_add_ready(instance->debug_checker);
+
+        return EOK;
+}
+/*----------------------------------------------------------------------------*/
+void uhci_init_hw(uhci_t *instance)
+{
+
+        /* set framelist pointer */
+        const uint32_t pa = addr_to_phys(instance->frame_list);
+        pio_write_32(&instance->registers->flbaseadd, pa);
+
+        /* enable all interrupts, but resume interrupt */
+        pio_write_16(&instance->registers->usbintr,
+                  UHCI_INTR_CRC | UHCI_INTR_COMPLETE | UHCI_INTR_SHORT_PACKET);
+
+        /* Start the hc with large(64B) packet FSBR */
+        pio_write_16(&instance->registers->usbcmd,
+            UHCI_CMD_RUN_STOP | UHCI_CMD_MAX_PACKET | UHCI_CMD_CONFIGURE);
+        usb_log_debug("Started UHCI HC.\n");
+}
+/*----------------------------------------------------------------------------*/
+int uhci_init_mem_structures(uhci_t *instance)
+{
+        assert(instance);
+
+        /* init interrupt code */
+        irq_cmd_t *interrupt_commands = malloc(sizeof(uhci_cmds));
+        if (interrupt_commands == NULL) {
+                return ENOMEM;
+        }
+        memcpy(interrupt_commands, uhci_cmds, sizeof(uhci_cmds));
+        interrupt_commands[0].addr = (void*)&instance->registers->usbsts;
+        interrupt_commands[1].addr = (void*)&instance->registers->usbsts;
+        instance->interrupt_code.cmds = interrupt_commands;
+        instance->interrupt_code.cmdcount =
+            sizeof(uhci_cmds) / sizeof(irq_cmd_t);
+
         /* init transfer lists */
-        ret = uhci_init_transfer_lists(instance);
-        CHECK_RET_RETURN("Failed to initialize transfer lists.\n");
-        usb_log_debug("Transfer lists initialized.\n");
-
-
-        usb_log_debug("Initializing frame list.\n");
+        int ret = uhci_init_transfer_lists(instance);
+        CHECK_RET_RETURN(ret, "Failed to initialize transfer lists.\n");
+        usb_log_debug("Initialized transfer lists.\n");
+
+        /* frame list initialization */
         instance->frame_list = get_page();
         ret = instance ? EOK : ENOMEM;
-        CHECK_RET_RETURN("Failed to get frame list page.\n");
+        CHECK_RET_RETURN(ret, "Failed to get frame list page.\n");
+        usb_log_debug("Initialized frame list.\n");
 
         /* initialize all frames to point to the first queue head */
@@ -86 +149 @@
         }
 
-        const uintptr_t pa = (uintptr_t)addr_to_phys(instance->frame_list);
-        pio_write_32(&instance->registers->flbaseadd, (uint32_t)pa);
-
-        list_initialize(&instance->batch_list);
-        fibril_mutex_initialize(&instance->batch_list_mutex);
-
-        instance->cleaner = fibril_create(uhci_clean_finished, instance);
-        fibril_add_ready(instance->cleaner);
-
-        instance->debug_checker = fibril_create(uhci_debug_checker, instance);
-        fibril_add_ready(instance->debug_checker);
-
-        /* Start the hc with large(64B) packet FSBR */
-        pio_write_16(&instance->registers->usbcmd,
-            UHCI_CMD_RUN_STOP | UHCI_CMD_MAX_PACKET);
-        usb_log_debug("Started UHCI HC.\n");
-
-        uint16_t cmd = pio_read_16(&instance->registers->usbcmd);
-        cmd |= UHCI_CMD_DEBUG;
-        pio_write_16(&instance->registers->usbcmd, cmd);
+        /* init address keeper(libusb) */
+        usb_address_keeping_init(&instance->address_manager, USB11_ADDRESS_MAX);
+        usb_log_debug("Initialized address manager.\n");
 
         return EOK;
@@ -114 +160 @@
         assert(instance);
 
-        /* initialize */
+        /* initialize TODO: check errors */
         int ret;
         ret = transfer_list_init(&instance->transfers_bulk_full, "BULK_FULL");
@@ -146 +192 @@
         instance->transfers[1][USB_TRANSFER_CONTROL] =
           &instance->transfers_control_slow;
-        instance->transfers[0][USB_TRANSFER_CONTROL] =
-          &instance->transfers_control_full;
+        instance->transfers[0][USB_TRANSFER_BULK] =
+          &instance->transfers_bulk_full;
 
         return EOK;
@@ -174 +220 @@
 }
 /*----------------------------------------------------------------------------*/
-int uhci_clean_finished(void* arg)
-{
-        usb_log_debug("Started cleaning fibril.\n");
+void uhci_interrupt(uhci_t *instance, uint16_t status)
+{
+        assert(instance);
+        if ((status & (UHCI_STATUS_INTERRUPT | UHCI_STATUS_ERROR_INTERRUPT)) == 0)
+                return;
+        usb_log_debug("UHCI interrupt: %X.\n", status);
+        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);
+}
+/*----------------------------------------------------------------------------*/
+int uhci_interrupt_emulator(void* arg)
+{
+        usb_log_debug("Started interrupt emulator.\n");
         uhci_t *instance = (uhci_t*)arg;
         assert(instance);
 
         while(1) {
-                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);
+                uint16_t status = pio_read_16(&instance->registers->usbsts);
+                uhci_interrupt(instance, status);
                 async_usleep(UHCI_CLEANER_TIMEOUT);
         }
@@ -195 +251 @@
         assert(instance);
         while (1) {
-                uint16_t cmd = pio_read_16(&instance->registers->usbcmd);
-                uint16_t sts = pio_read_16(&instance->registers->usbsts);
-                usb_log_debug("Command register: %X Status register: %X\n", cmd, sts);
+                const uint16_t cmd = pio_read_16(&instance->registers->usbcmd);
+                const uint16_t sts = pio_read_16(&instance->registers->usbsts);
+                const uint16_t intr = pio_read_16(&instance->registers->usbintr);
+                usb_log_debug("Command: %X Status: %X Interrupts: %x\n",
+                    cmd, sts, intr);
 
                 uintptr_t frame_list = pio_read_32(&instance->registers->flbaseadd);
-                if (frame_list != (uintptr_t)addr_to_phys(instance->frame_list)) {
+                if (frame_list != addr_to_phys(instance->frame_list)) {
                         usb_log_debug("Framelist address: %p vs. %p.\n",
                                 frame_list, addr_to_phys(instance->frame_list));

uspace/drv/uhci-hcd/uhci.h

@@ -66 +66 @@
 
         uint16_t usbintr;
+#define UHCI_INTR_SHORT_PACKET (1 << 3)
+#define UHCI_INTR_COMPLETE (1 << 2)
+#define UHCI_INTR_RESUME (1 << 1)
+#define UHCI_INTR_CRC (1 << 0)
+
         uint16_t frnum;
         uint32_t flbaseadd;
@@ -81 +86 @@
         link_pointer_t *frame_list;
 
-        link_t batch_list;
-        fibril_mutex_t batch_list_mutex;
-
         transfer_list_t transfers_bulk_full;
         transfer_list_t transfers_control_full;
@@ -90 +92 @@
 
         transfer_list_t *transfers[2][4];
+
+        irq_code_t interrupt_code;
 
         fid_t cleaner;
@@ -98 +102 @@
 int uhci_init(uhci_t *instance, void *regs, size_t reg_size);
 
-int uhci_fini(uhci_t *device);
-
-int uhci_transfer(
-  uhci_t *instance,
-  device_t *dev,
-  usb_target_t target,
-  usb_transfer_type_t transfer_type,
-        bool toggle,
-  usb_packet_id pid,
-        bool low_speed,
-  void *buffer, size_t size,
-  usbhc_iface_transfer_out_callback_t callback_out,
-  usbhc_iface_transfer_in_callback_t callback_in,
-  void *arg );
+static inline void uhci_fini(uhci_t *instance) {};
 
 int uhci_schedule(uhci_t *instance, batch_t *batch);
 
+void uhci_interrupt(uhci_t *instance, uint16_t status);
+
 static inline uhci_t * dev_to_uhci(device_t *dev)
         { return (uhci_t*)dev->driver_data; }
+
 
 #endif

uspace/drv/uhci-rhd/port.c

@@ -131 +131 @@
         return EOK;
 }
-/*----------------------------------------------------------------------------*/
-static int uhci_port_new_device(uhci_port_t *port)
-{
-        assert(port);
-        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_hc_request_address(
-            &port->hc_connection, true);
-
-        if (usb_address <= 0) {
-                usb_log_error("Recieved invalid address(%d).\n", usb_address);
-                return usb_address;
-        }
-        usb_log_debug("Sucessfully obtained address %d for port %d.\n",
-            usb_address, port->number);
-
-        /* get default address */
-        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_hc_unregister_device(&port->hc_connection,
-                    usb_address);
-                if (ret2 != EOK) {
-                        usb_log_fatal("Failed to return requested address on port %d.\n",
-                           port->number);
-                        return ret2;
-                }
-                usb_log_debug("Successfully returned reserved address on port %d.\n",
-                        port->number);
-                return ret;
-        }
-        usb_log_debug("Sucessfully obtained default address for port %d.\n",
-            port->number);
+
+/** Callback for enabling port during adding a new device.
+ *
+ * @param portno Port number (unused).
+ * @param arg Pointer to uhci_port_t of port with the new device.
+ * @return Error code.
+ */
+static int new_device_enable_port(int portno, void *arg)
+{
+        uhci_port_t *port = (uhci_port_t *) arg;
+
+        usb_log_debug("new_device_enable_port(%d)\n", port->number);
 
         /*
-         * the host then waits for at least 100 ms to allow completion of
+         * The host then waits for at least 100 ms to allow completion of
          * an insertion process and for power at the device to become stable.
          */
         async_usleep(100000);
 
-        /* enable port */
+        /* Enable the port. */
         uhci_port_set_enabled(port, true);
 
@@ -197 +172 @@
         }
 
-        /*
-         * 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);
+        return EOK;
+}
+
+/*----------------------------------------------------------------------------*/
+static int uhci_port_new_device(uhci_port_t *port)
+{
+        assert(port);
+        assert(usb_hc_connection_is_opened(&port->hc_connection));
+
+        usb_log_info("Detected new device on port %u.\n", port->number);
+
+        usb_address_t dev_addr;
+        int rc = usb_hc_new_device_wrapper(port->rh, &port->hc_connection,
+            USB_SPEED_FULL,
+            new_device_enable_port, port->number, port,
+            &dev_addr, &port->attached_device);
+        if (rc != EOK) {
+                usb_log_error("Failed adding new device on port %u: %s.\n",
+                    port->number, str_error(rc));
                 uhci_port_set_enabled(port, false);
-                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",
-                            port->number);
-                        return release;
-                }
-                usb_log_debug("Sucessfully released default address on port %d.\n",
-                    port->number);
-                return ret;
-        }
-        usb_log_debug("Sucessfully assigned address %d for port %d.\n",
-            usb_address, port->number);
-
-        /* release default address */
-        ret = usb_hc_release_default_address(&port->hc_connection);
-        if (ret != EOK) {
-                usb_log_error("Failed to release default address on port %d.\n",
-                    port->number);
-                return ret;
-        }
-        usb_log_debug("Sucessfully released default address on port %d.\n",
-            port->number);
-
-        /* communicate and possibly report to devman */
-        assert(port->attached_device == 0);
-
-        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 */
-                usb_log_error("Failed(%d) in usb_drv_register_child.\n", ret);
-                uhci_port_set_enabled(port, false);
-                return ENOMEM;
-        }
-        usb_log_info("Sucessfully added device on port(%d) address(%d) handle %d.\n",
-                port->number, 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);
-
-        return EOK;
-}
+                return rc;
+        }
+
+        usb_log_info("New device on port %u has address %d (handle %zu).\n",
+            port->number, dev_addr, port->attached_device);
+
+        return EOK;
+}
+
 /*----------------------------------------------------------------------------*/
 static int uhci_port_remove_device(uhci_port_t *port)

uspace/drv/uhci-rhd/root_hub.c

@@ -47 +47 @@
         assert(rh);
         int ret;
-        ret = usb_drv_find_hc(rh, &instance->hc_handle);
+        ret = usb_hc_find(rh->handle, &instance->hc_handle);
         usb_log_info("rh found(%d) hc handle: %d.\n", ret, instance->hc_handle);
         if (ret != EOK) {

uspace/drv/usbhub/usbhub.c

@@ -52 +52 @@
 #include "usb/pipes.h"
 
+static int iface_get_hc_handle(device_t *device, devman_handle_t *handle)
+{
+        return usb_hc_find(device->handle, handle);
+}
+
 static usb_iface_t hub_usb_iface = {
-        .get_hc_handle = usb_drv_find_hc
+        .get_hc_handle = iface_get_hc_handle
 };
 
@@ -263 +268 @@
         //get default address
         //opResult = usb_drv_reserve_default_address(hc);
-        opResult = usb_hc_reserve_default_address(&hub->connection, false);
+        opResult = usb_hc_reserve_default_address(&hub->connection, USB_SPEED_LOW);
         if (opResult != EOK) {
                 dprintf(USB_LOG_LEVEL_WARNING, "cannot assign default address, it is probably used");
@@ -320 +325 @@
         usb_address_t new_device_address = usb_hc_request_address(
                         &hub->connection,
-                        false/// \TODO fullspeed??
+                        USB_SPEED_LOW/// \TODO fullspeed??
                         );
         if (new_device_address < 0) {

uspace/drv/vhc/connhost.c

@@ -234 +234 @@
 }
 
-static int enqueue_transfer_setup(device_t *dev,
-    usb_target_t target, usb_transfer_type_t transfer_type,
-    void *buffer, size_t size,
-    usbhc_iface_transfer_out_callback_t callback, void *arg)
-{
-        usb_log_debug2("Transfer SETUP [%d.%d (%s); %zu].\n",
-            target.address, target.endpoint,
-            usb_str_transfer_type(transfer_type),
-            size);
-
-        transfer_info_t *transfer
-            = create_transfer_info(dev, USB_DIRECTION_OUT, arg);
-        transfer->out_callback = callback;
-
-        hc_add_transaction_to_device(true, target, transfer_type, buffer, size,
-            universal_callback, transfer);
-
-        return EOK;
-}
-
 static int enqueue_transfer_in(device_t *dev,
     usb_target_t target, usb_transfer_type_t transfer_type,
@@ -292 +272 @@
         return enqueue_transfer_in(dev, target, USB_TRANSFER_INTERRUPT,
             data, size,
-            callback, arg);
-}
-
-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)
-{
-        return enqueue_transfer_setup(dev, target, USB_TRANSFER_CONTROL,
-            data, size,
-            callback, arg);
-}
-
-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)
-{
-        return enqueue_transfer_out(dev, target, USB_TRANSFER_CONTROL,
-            data, size,
-            callback, arg);
-}
-
-static int control_write_status(device_t *dev, usb_target_t target,
-    usbhc_iface_transfer_in_callback_t callback, void *arg)
-{
-        return enqueue_transfer_in(dev, target, USB_TRANSFER_CONTROL,
-            NULL, 0,
             callback, arg);
 }
@@ -341 +293 @@
 }
 
-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)
-{
-        return enqueue_transfer_setup(dev, target, USB_TRANSFER_CONTROL,
-            data, size,
-            callback, arg);
-}
-
-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)
-{
-        return enqueue_transfer_in(dev, target, USB_TRANSFER_CONTROL,
-            data, size,
-            callback, arg);
-}
-
-static int control_read_status(device_t *dev, usb_target_t target,
-    usbhc_iface_transfer_out_callback_t callback, void *arg)
-{
-        return enqueue_transfer_out(dev, target, USB_TRANSFER_CONTROL,
-            NULL, 0,
-            callback, arg);
-}
-
 static int control_read(device_t *dev, usb_target_t target,
     size_t max_packet_size,
@@ -390 +314 @@
 
 
-static int reserve_default_address(device_t *dev, bool ignored)
+static int reserve_default_address(device_t *dev, usb_speed_t ignored)
 {
         usb_address_keeping_reserve_default(&addresses);
@@ -402 +326 @@
 }
 
-static int request_address(device_t *dev, bool ignored, usb_address_t *address)
+static int request_address(device_t *dev, usb_speed_t ignored,
+    usb_address_t *address)
 {
         usb_address_t addr = usb_address_keeping_request(&addresses);
@@ -454 +379 @@
         .interrupt_in = interrupt_in,
 
-        .control_write_setup = control_write_setup,
-        .control_write_data = control_write_data,
-        .control_write_status = control_write_status,
-
         .control_write = control_write,
-
-        .control_read_setup = control_read_setup,
-        .control_read_data = control_read_data,
-        .control_read_status = control_read_status,
-
         .control_read = control_read
 };

uspace/lib/c/generic/str_error.c

@@ -73 +73 @@
                 case EBADCHECKSUM:
                         return "Bad checksum";
+                case ESTALL:
+                        return "Operation stalled";
                 case EAGAIN:
                         return "Resource temporarily unavailable";

uspace/lib/c/include/errno.h

@@ -59 +59 @@
 #define EBADCHECKSUM  (-300)
 
+/** USB: stalled operation. */
+#define ESTALL (-301)
+
 /** An API function is called while another blocking function is in progress. */
 #define EINPROGRESS  (-10036)

uspace/lib/drv/generic/remote_usbhc.c

@@ -46 +46 @@
 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 *);
-static void remote_usbhc_control_write_setup(device_t *, void *, ipc_callid_t, ipc_call_t *);
-static void remote_usbhc_control_write_data(device_t *, void *, ipc_callid_t, ipc_call_t *);
-static void remote_usbhc_control_write_status(device_t *, void *, ipc_callid_t, ipc_call_t *);
-static void remote_usbhc_control_read_setup(device_t *, void *, ipc_callid_t, ipc_call_t *);
-static void remote_usbhc_control_read_data(device_t *, void *, ipc_callid_t, ipc_call_t *);
-static void remote_usbhc_control_read_status(device_t *, void *, ipc_callid_t, ipc_call_t *);
 static void remote_usbhc_control_write(device_t *, void *, ipc_callid_t, ipc_call_t *);
 static void remote_usbhc_control_read(device_t *, void *, ipc_callid_t, ipc_call_t *);
@@ -75 +69 @@
         remote_usbhc_interrupt_in,
 
-        remote_usbhc_control_write_setup,
-        remote_usbhc_control_write_data,
-        remote_usbhc_control_write_status,
-
-        remote_usbhc_control_read_setup,
-        remote_usbhc_control_read_data,
-        remote_usbhc_control_read_status,
-
         remote_usbhc_control_write,
         remote_usbhc_control_read
@@ -166 +152 @@
         }
         
-        bool full_speed = DEV_IPC_GET_ARG1(*call);
+        usb_speed_t speed = DEV_IPC_GET_ARG1(*call);
         
-        int rc = usb_iface->reserve_default_address(device, full_speed);
+        int rc = usb_iface->reserve_default_address(device, speed);
 
         async_answer_0(callid, rc);
@@ -198 +184 @@
         }
         
-        bool full_speed = DEV_IPC_GET_ARG1(*call);
+        usb_speed_t speed = DEV_IPC_GET_ARG1(*call);
 
         usb_address_t address;
-        int rc = usb_iface->request_address(device, full_speed, &address);
+        int rc = usb_iface->request_address(device, speed, &address);
         if (rc != EOK) {
                 async_answer_0(callid, rc);
@@ -297 +283 @@
         }
 
-        size_t expected_len = DEV_IPC_GET_ARG3(*call);
+        size_t max_packet_size = DEV_IPC_GET_ARG3(*call);
         usb_target_t target = {
                 .address = DEV_IPC_GET_ARG1(*call),
@@ -305 +291 @@
         size_t len = 0;
         void *buffer = NULL;
-        if (expected_len > 0) {
-                int rc = async_data_write_accept(&buffer, false,
-                    1, USB_MAX_PAYLOAD_SIZE,
-                    0, &len);
-
-                if (rc != EOK) {
-                        async_answer_0(callid, rc);
-                        return;
-                }
+
+        int rc = async_data_write_accept(&buffer, false,
+            1, USB_MAX_PAYLOAD_SIZE,
+            0, &len);
+
+        if (rc != EOK) {
+                async_answer_0(callid, rc);
+                return;
         }
 
@@ -328 +313 @@
         trans->size = len;
 
-        int rc = transfer_func(device, target, HACK_MAX_PACKET_SIZE,
+        rc = transfer_func(device, target, max_packet_size,
             buffer, len,
             callback_out, trans);
@@ -354 +339 @@
         }
 
-        size_t len = DEV_IPC_GET_ARG3(*call);
+        size_t max_packet_size = DEV_IPC_GET_ARG3(*call);
         usb_target_t target = {
                 .address = DEV_IPC_GET_ARG1(*call),
@@ -360 +345 @@
         };
 
+        size_t len;
         ipc_callid_t data_callid;
         if (!async_data_read_receive(&data_callid, &len)) {
@@ -375 +361 @@
         trans->size = len;
 
-        int rc = transfer_func(device, target, HACK_MAX_PACKET_SIZE_INTERRUPT_IN,
+        int rc = transfer_func(device, target, max_packet_size,
             trans->buffer, len,
             callback_in, trans);
@@ -385 +371 @@
 }
 
-/** Process status part of control transfer.
- *
- * @param device Target device.
- * @param callid Initiating caller.
- * @param call Initiating call.
- * @param direction Transfer direction (read ~ in, write ~ out).
- * @param transfer_in_func Transfer function for control read (might be NULL).
- * @param transfer_out_func Transfer function for control write (might be NULL).
- */
-static void remote_usbhc_status_transfer(device_t *device,
-    ipc_callid_t callid, ipc_call_t *call,
-    usb_direction_t direction,
-    int (*transfer_in_func)(device_t *, usb_target_t,
-        usbhc_iface_transfer_in_callback_t, void *),
-    int (*transfer_out_func)(device_t *, usb_target_t,
-        usbhc_iface_transfer_out_callback_t, void *))
-{
-        switch (direction) {
-                case USB_DIRECTION_IN:
-                        if (!transfer_in_func) {
-                                async_answer_0(callid, ENOTSUP);
-                                return;
-                        }
-                        break;
-                case USB_DIRECTION_OUT:
-                        if (!transfer_out_func) {
-                                async_answer_0(callid, ENOTSUP);
-                                return;
-                        }
-                        break;
-                default:
-                        assert(false && "unreachable code");
-                        break;
-        }
-
-        usb_target_t target = {
-                .address = DEV_IPC_GET_ARG1(*call),
-                .endpoint = DEV_IPC_GET_ARG2(*call)
-        };
-
-        async_transaction_t *trans = async_transaction_create(callid);
-        if (trans == NULL) {
-                async_answer_0(callid, ENOMEM);
-                return;
-        }
-
-        int rc;
-        switch (direction) {
-                case USB_DIRECTION_IN:
-                        rc = transfer_in_func(device, target,
-                            callback_in, trans);
-                        break;
-                case USB_DIRECTION_OUT:
-                        rc = transfer_out_func(device, target,
-                            callback_out, trans);
-                        break;
-                default:
-                        assert(false && "unreachable code");
-                        break;
-        }
-
-        if (rc != EOK) {
-                async_answer_0(callid, rc);
-                async_transaction_destroy(trans);
-        }
-}
-
-
 void remote_usbhc_interrupt_out(device_t *device, void *iface,
     ipc_callid_t callid, ipc_call_t *call)
@@ -471 +389 @@
         return remote_usbhc_in_transfer(device, callid, call,
             usb_iface->interrupt_in);
-}
-
-void remote_usbhc_control_write_setup(device_t *device, void *iface,
-    ipc_callid_t callid, ipc_call_t *call)
-{
-        usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
-        assert(usb_iface != NULL);
-
-        return remote_usbhc_out_transfer(device, callid, call,
-            usb_iface->control_write_setup);
-}
-
-void remote_usbhc_control_write_data(device_t *device, void *iface,
-    ipc_callid_t callid, ipc_call_t *call)
-{
-        usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
-        assert(usb_iface != NULL);
-
-        return remote_usbhc_out_transfer(device, callid, call,
-            usb_iface->control_write_data);
-}
-
-void remote_usbhc_control_write_status(device_t *device, void *iface,
-    ipc_callid_t callid, ipc_call_t *call)
-{
-        usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
-        assert(usb_iface != NULL);
-
-        return remote_usbhc_status_transfer(device, callid, call,
-            USB_DIRECTION_IN, usb_iface->control_write_status, NULL);
-}
-
-void remote_usbhc_control_read_setup(device_t *device, void *iface,
-    ipc_callid_t callid, ipc_call_t *call)
-{
-        usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
-        assert(usb_iface != NULL);
-
-        return remote_usbhc_out_transfer(device, callid, call,
-            usb_iface->control_read_setup);
-}
-
-void remote_usbhc_control_read_data(device_t *device, void *iface,
-            ipc_callid_t callid, ipc_call_t *call)
-{
-        usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
-        assert(usb_iface != NULL);
-
-        return remote_usbhc_in_transfer(device, callid, call,
-            usb_iface->control_read_data);
-}
-
-void remote_usbhc_control_read_status(device_t *device, void *iface,
-            ipc_callid_t callid, ipc_call_t *call)
-{
-        usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
-        assert(usb_iface != NULL);
-
-        return remote_usbhc_status_transfer(device, callid, call,
-            USB_DIRECTION_OUT, NULL, usb_iface->control_read_status);
 }
 
@@ -549 +407 @@
         };
         size_t data_buffer_len = DEV_IPC_GET_ARG3(*call);
+        size_t max_packet_size = DEV_IPC_GET_ARG4(*call);
 
         int rc;
@@ -584 +443 @@
         trans->size = data_buffer_len;
 
-        rc = usb_iface->control_write(device, target, HACK_MAX_PACKET_SIZE,
+        rc = usb_iface->control_write(device, target, max_packet_size,
             setup_packet, setup_packet_len,
             data_buffer, data_buffer_len,
@@ -611 +470 @@
                 .endpoint = DEV_IPC_GET_ARG2(*call)
         };
+        size_t max_packet_size = DEV_IPC_GET_ARG3(*call);
 
         int rc;
@@ -648 +508 @@
         }
 
-        rc = usb_iface->control_read(device, target, HACK_MAX_PACKET_SIZE,
+        rc = usb_iface->control_read(device, target, max_packet_size,
             setup_packet, setup_packet_len,
             trans->buffer, trans->size,

uspace/lib/drv/include/usbhc_iface.h

@@ -53 +53 @@
  *   - argument #1 is target address
  *   - argument #2 is target endpoint
- *   - argument #3 is buffer size
+ *   - argument #3 is max packet size of the endpoint
  * - this call is immediately followed by IPC data write (from caller)
  * - the initial call (and the whole transaction) is answer after the
@@ -66 +66 @@
  *   - argument #1 is target address
  *   - argument #2 is target endpoint
- *   - argument #3 is buffer size
+ *   - argument #3 is max packet size of the endpoint
  * - this call is immediately followed by IPC data read (async version)
  * - the call is not answered until the device returns some data (or until
@@ -153 +153 @@
         IPC_M_USBHC_INTERRUPT_IN,
 
-
-        /** Start WRITE control transfer.
-         * See explanation at usb_iface_funcs_t (OUT transaction).
-         */
-        IPC_M_USBHC_CONTROL_WRITE_SETUP,
-
-        /** Send control-transfer data to device.
-         * See explanation at usb_iface_funcs_t (OUT transaction).
-         */
-        IPC_M_USBHC_CONTROL_WRITE_DATA,
-
-        /** Terminate WRITE control transfer.
-         * See explanation at usb_iface_funcs_t (NO-DATA transaction).
-         */
-        IPC_M_USBHC_CONTROL_WRITE_STATUS,
-
-
-
-        /** Start READ control transfer.
-         * See explanation at usb_iface_funcs_t (OUT transaction).
-         */
-        IPC_M_USBHC_CONTROL_READ_SETUP,
-
-        /** Get control-transfer data from device.
-         * See explanation at usb_iface_funcs_t (IN transaction).
-         */
-        IPC_M_USBHC_CONTROL_READ_DATA,
-
-        /** Terminate READ control transfer.
-         * See explanation at usb_iface_funcs_t (NO-DATA transaction).
-         */
-        IPC_M_USBHC_CONTROL_READ_STATUS,
-
         /** Issue control WRITE transfer.
          * See explanation at usb_iface_funcs_t (OUT transaction) for
@@ -194 +161 @@
         IPC_M_USBHC_CONTROL_WRITE,
 
-        /** Issue control WRITE transfer.
+        /** Issue control READ transfer.
          * See explanation at usb_iface_funcs_t (IN transaction) for
          * call parameters.
-         * This call is immediately followed by IPC data read from the caller
-         * (setup packet).
-         * Actual data are retrieved through IPC_M_USBHC_GET_BUFFER.
+         * This call is immediately followed by IPC data write from the caller
+         * (setup packet) and IPC data read (buffer that was read).
          */
         IPC_M_USBHC_CONTROL_READ,
@@ -232 +198 @@
         int (*tell_address)(device_t *, devman_handle_t, usb_address_t *);
 
-        int (*reserve_default_address)(device_t *, bool);
+        int (*reserve_default_address)(device_t *, usb_speed_t);
         int (*release_default_address)(device_t *);
-        int (*request_address)(device_t *, bool, usb_address_t *);
+        int (*request_address)(device_t *, usb_speed_t, usb_address_t *);
         int (*bind_address)(device_t *, usb_address_t, devman_handle_t);
         int (*release_address)(device_t *, usb_address_t);
@@ -240 +206 @@
         usbhc_iface_transfer_out_t interrupt_out;
         usbhc_iface_transfer_in_t interrupt_in;
-
-        usbhc_iface_transfer_setup_t control_write_setup;
-        usbhc_iface_transfer_out_t control_write_data;
-        int (*control_write_status)(device_t *, usb_target_t,
-            usbhc_iface_transfer_in_callback_t, void *);
-
-        usbhc_iface_transfer_setup_t control_read_setup;
-        usbhc_iface_transfer_in_t control_read_data;
-        int (*control_read_status)(device_t *, usb_target_t,
-            usbhc_iface_transfer_out_callback_t, void *);
 
         int (*control_write)(device_t *, usb_target_t,

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

@@ -39 +39 @@
 #include <usb/usbdevice.h>
 
+int usb_hc_new_device_wrapper(device_t *, usb_hc_connection_t *, usb_speed_t,
+    int (*)(int, void *), int, void *, usb_address_t *, devman_handle_t *);
 
 /** Info about device attached to host controller.
@@ -53 +55 @@
 } usb_hc_attached_device_t;
 
-int usb_hc_reserve_default_address(usb_hc_connection_t *, bool);
+int usb_hc_reserve_default_address(usb_hc_connection_t *, usb_speed_t);
 int usb_hc_release_default_address(usb_hc_connection_t *);
 
-usb_address_t usb_hc_request_address(usb_hc_connection_t *, bool);
+usb_address_t usb_hc_request_address(usb_hc_connection_t *, usb_speed_t);
 int usb_hc_register_device(usb_hc_connection_t *,
     const usb_hc_attached_device_t *);

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

@@ -68 +68 @@
         USB_DIRECTION_BOTH
 } usb_direction_t;
+
+/** USB speeds. */
+typedef enum {
+        /** USB 1.1 low speed (1.5Mbits/s). */
+        USB_SPEED_LOW,
+        /** USB 1.1 full speed (12Mbits/s). */
+        USB_SPEED_FULL,
+        /** USB 2.0 high speed (480Mbits/s). */
+        USB_SPEED_HIGH
+} usb_speed_t;
 
 /** USB request type target. */

uspace/lib/usb/src/hub.c

@@ -34 +34 @@
  */
 #include <usb/hub.h>
+#include <usb/pipes.h>
+#include <usb/request.h>
+#include <usb/recognise.h>
 #include <usbhc_iface.h>
 #include <errno.h>
@@ -56 +59 @@
  */
 int usb_hc_reserve_default_address(usb_hc_connection_t *connection,
-    bool full_speed)
+    usb_speed_t speed)
 {
         CHECK_CONNECTION(connection);
@@ -62 +65 @@
         return async_req_2_0(connection->hc_phone,
             DEV_IFACE_ID(USBHC_DEV_IFACE),
-            IPC_M_USBHC_RESERVE_DEFAULT_ADDRESS, full_speed);
+            IPC_M_USBHC_RESERVE_DEFAULT_ADDRESS, speed);
 }
 
@@ -85 +88 @@
  */
 usb_address_t usb_hc_request_address(usb_hc_connection_t *connection,
-    bool full_speed)
+    usb_speed_t speed)
 {
         CHECK_CONNECTION(connection);
@@ -92 +95 @@
         int rc = async_req_2_1(connection->hc_phone,
             DEV_IFACE_ID(USBHC_DEV_IFACE),
-            IPC_M_USBHC_REQUEST_ADDRESS, full_speed,
+            IPC_M_USBHC_REQUEST_ADDRESS, speed,
             &address);
         if (rc != EOK) {
@@ -138 +141 @@
 
 
+/** Wrapper for registering attached device to the hub.
+ *
+ * The @p enable_port function is expected to enable singalling on given
+ * port.
+ * The two arguments to it can have arbitrary meaning
+ * (the @p port_no is only a suggestion)
+ * and are not touched at all by this function
+ * (they are passed as is to the @p enable_port function).
+ *
+ * If the @p enable_port fails (i.e. does not return EOK), the device
+ * addition is cancelled.
+ * The return value is then returned (it is good idea to use different
+ * error codes than those listed as return codes by this function itself).
+ *
+ * @param parent Parent device (i.e. the hub device).
+ * @param connection Opened connection to host controller.
+ * @param dev_speed New device speed.
+ * @param enable_port Function for enabling signalling through the port the
+ *      device is attached to.
+ * @param port_no Port number (passed through to @p enable_port).
+ * @param arg Any data argument to @p enable_port.
+ * @param[out] assigned_address USB address of the device.
+ * @param[out] assigned_handle Devman handle of the new device.
+ * @return Error code.
+ * @retval ENOENT Connection to HC not opened.
+ * @retval EADDRNOTAVAIL Failed retrieving free address from host controller.
+ * @retval EBUSY Failed reserving default USB address.
+ * @retval ENOTCONN Problem connecting to the host controller via USB pipe.
+ * @retval ESTALL Problem communication with device (either SET_ADDRESS
+ *      request or requests for descriptors when creating match ids).
+ */
+int usb_hc_new_device_wrapper(device_t *parent, usb_hc_connection_t *connection,
+    usb_speed_t dev_speed,
+    int (*enable_port)(int port_no, void *arg), int port_no, void *arg,
+    usb_address_t *assigned_address, devman_handle_t *assigned_handle)
+{
+        CHECK_CONNECTION(connection);
+
+        /*
+         * Request new address.
+         */
+        usb_address_t dev_addr = usb_hc_request_address(connection, dev_speed);
+        if (dev_addr < 0) {
+                return EADDRNOTAVAIL;
+        }
+
+        int rc;
+
+        /*
+         * Reserve the default address.
+         */
+        rc = usb_hc_reserve_default_address(connection, dev_speed);
+        if (rc != EOK) {
+                rc = EBUSY;
+                goto leave_release_free_address;
+        }
+
+        /*
+         * Enable the port (i.e. allow signalling through this port).
+         */
+        rc = enable_port(port_no, arg);
+        if (rc != EOK) {
+                goto leave_release_default_address;
+        }
+
+        /*
+         * Change the address from default to the free one.
+         * We need to create a new control pipe for that.
+         */
+        usb_device_connection_t dev_conn;
+        rc = usb_device_connection_initialize_on_default_address(&dev_conn,
+            connection);
+        if (rc != EOK) {
+                rc = ENOTCONN;
+                goto leave_release_default_address;
+        }
+
+        usb_endpoint_pipe_t ctrl_pipe;
+        rc = usb_endpoint_pipe_initialize_default_control(&ctrl_pipe,
+            &dev_conn);
+        if (rc != EOK) {
+                rc = ENOTCONN;
+                goto leave_release_default_address;
+        }
+
+        rc = usb_endpoint_pipe_start_session(&ctrl_pipe);
+        if (rc != EOK) {
+                rc = ENOTCONN;
+                goto leave_release_default_address;
+        }
+
+        rc = usb_request_set_address(&ctrl_pipe, dev_addr);
+        if (rc != EOK) {
+                rc = ESTALL;
+                goto leave_stop_session;
+        }
+
+        usb_endpoint_pipe_end_session(&ctrl_pipe);
+
+        /*
+         * Once the address is changed, we can return the default address.
+         */
+        usb_hc_release_default_address(connection);
+
+        /*
+         * It is time to register the device with devman.
+         */
+        /* FIXME: create device_register that will get opened ctrl pipe. */
+        devman_handle_t child_handle;
+        rc = usb_device_register_child_in_devman(dev_addr, dev_conn.hc_handle,
+            parent, &child_handle);
+        if (rc != EOK) {
+                rc = ESTALL;
+                goto leave_release_free_address;
+        }
+
+        /*
+         * And now inform the host controller about the handle.
+         */
+        usb_hc_attached_device_t new_device = {
+                .address = dev_addr,
+                .handle = child_handle
+        };
+        rc = usb_hc_register_device(connection, &new_device);
+        if (rc != EOK) {
+                rc = EDESTADDRREQ;
+                goto leave_release_free_address;
+        }
+
+        /*
+         * And we are done.
+         */
+        if (assigned_address != NULL) {
+                *assigned_address = dev_addr;
+        }
+        if (assigned_handle != NULL) {
+                *assigned_handle = child_handle;
+        }
+
+        return EOK;
+
+
+
+        /*
+         * Error handling (like nested exceptions) starts here.
+         * Completely ignoring errors here.
+         */
+
+leave_stop_session:
+        usb_endpoint_pipe_end_session(&ctrl_pipe);
+
+leave_release_default_address:
+        usb_hc_release_default_address(connection);
+
+leave_release_free_address:
+        usb_hc_unregister_device(connection, dev_addr);
+
+        return rc;
+}
+
+
 /**
  * @}

uspace/lib/usb/src/pipes.c

@@ -35 +35 @@
 #include <usb/usb.h>
 #include <usb/pipes.h>
+#include <usbhc_iface.h>
 #include <errno.h>
 #include <assert.h>
-#include <usb/usbdrv.h>
+
+/** Tell USB address assigned to given device.
+ *
+ * @param phone Phone to my HC.
+ * @param dev Device in question.
+ * @return USB address or error code.
+ */
+static usb_address_t get_my_address(int phone, device_t *dev)
+{
+        sysarg_t address;
+        int rc = async_req_2_1(phone, DEV_IFACE_ID(USBHC_DEV_IFACE),
+            IPC_M_USBHC_GET_ADDRESS,
+            dev->handle, &address);
+
+        if (rc != EOK) {
+                return rc;
+        }
+
+        return (usb_address_t) address;
+}
 
 /** Initialize connection to USB device.
@@ -55 +75 @@
         usb_address_t my_address;
 
-        rc = usb_drv_find_hc(device, &hc_handle);
+        rc = usb_hc_find(device->handle, &hc_handle);
         if (rc != EOK) {
                 return rc;
@@ -65 +85 @@
         }
 
-        my_address = usb_drv_get_my_address(hc_phone, device);
+        my_address = get_my_address(hc_phone, device);
         if (my_address < 0) {
                 rc = my_address;

uspace/lib/usb/src/pipesio.c

@@ -78 +78 @@
          * Make call identifying target USB device and type of transfer.
          */
-        aid_t opening_request = async_send_3(pipe->hc_phone,
+        aid_t opening_request = async_send_4(pipe->hc_phone,
             DEV_IFACE_ID(USBHC_DEV_IFACE), ipc_method,
             pipe->wire->address, pipe->endpoint_no,
+            pipe->max_packet_size,
             NULL);
         if (opening_request == 0) {
@@ -201 +202 @@
          * Make call identifying target USB device and type of transfer.
          */
-        aid_t opening_request = async_send_3(pipe->hc_phone,
+        aid_t opening_request = async_send_4(pipe->hc_phone,
             DEV_IFACE_ID(USBHC_DEV_IFACE), ipc_method,
             pipe->wire->address, pipe->endpoint_no,
+            pipe->max_packet_size,
             NULL);
         if (opening_request == 0) {
@@ -283 +285 @@
          * Make call identifying target USB device and control transfer type.
          */
-        aid_t opening_request = async_send_3(pipe->hc_phone,
+        aid_t opening_request = async_send_4(pipe->hc_phone,
             DEV_IFACE_ID(USBHC_DEV_IFACE), IPC_M_USBHC_CONTROL_READ,
             pipe->wire->address, pipe->endpoint_no,
+            pipe->max_packet_size,
             NULL);
         if (opening_request == 0) {
@@ -402 +405 @@
          * Make call identifying target USB device and control transfer type.
          */
-        aid_t opening_request = async_send_4(pipe->hc_phone,
+        aid_t opening_request = async_send_5(pipe->hc_phone,
             DEV_IFACE_ID(USBHC_DEV_IFACE), IPC_M_USBHC_CONTROL_WRITE,
             pipe->wire->address, pipe->endpoint_no,
             data_buffer_size,
+            pipe->max_packet_size,
             NULL);
         if (opening_request == 0) {

uspace/lib/usb/src/usbdrv.c

@@ -34 +34 @@
  */
 #include <usb/usbdrv.h>
-#include <usbhc_iface.h>
-#include <usb_iface.h>
 #include <errno.h>
-#include <str_error.h>
-
-/** Information about pending transaction on HC. */
-typedef struct {
-        /** Phone to host controller driver. */
-        int phone;
-        /** Data buffer. */
-        void *buffer;
-        /** Buffer size. */
-        size_t size;
-        /** Storage for actual number of bytes transferred. */
-        size_t *size_transferred;
-        /** 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;
+
 
 /** Find handle of host controller the device is physically attached to.
@@ -67 +45 @@
 int usb_drv_find_hc(device_t *dev, devman_handle_t *handle)
 {
-        if (dev == NULL) {
-                return EBADMEM;
-        }
-        if (handle == NULL) {
-                return EBADMEM;
-        }
-
-        int parent_phone = devman_parent_device_connect(dev->handle,
-            IPC_FLAG_BLOCKING);
-        if (parent_phone < 0) {
-                return parent_phone;
-        }
-
-        devman_handle_t h;
-        int rc = async_req_1_1(parent_phone, DEV_IFACE_ID(USB_DEV_IFACE),
-            IPC_M_USB_GET_HOST_CONTROLLER_HANDLE, &h);
-
-        async_hangup(parent_phone);
-
-        if (rc != EOK) {
-                return rc;
-        }
-
-        *handle = h;
-
-        return EOK;
+        return ENOTSUP;
 }
 
@@ -105 +58 @@
     unsigned int flags)
 {
-        return devman_device_connect(hc_handle, flags);
+        return ENOTSUP;
 }
 
@@ -116 +69 @@
 int usb_drv_hc_connect_auto(device_t *dev, unsigned int flags)
 {
-        int rc;
-        devman_handle_t hc_handle;
-
-        /*
-         * Call parent hub to obtain device handle of respective HC.
-         */
-        rc = usb_drv_find_hc(dev, &hc_handle);
-        if (rc != EOK) {
-                return rc;
-        }
-        
-        return usb_drv_hc_connect(dev, hc_handle, flags);
+        return ENOTSUP;
 }
 
@@ -138 +80 @@
 usb_address_t usb_drv_get_my_address(int phone, device_t *dev)
 {
-        sysarg_t address;
-        int rc = async_req_2_1(phone, DEV_IFACE_ID(USBHC_DEV_IFACE),
-            IPC_M_USBHC_GET_ADDRESS,
-            dev->handle, &address);
-
-        if (rc != EOK) {
-                return rc;
-        }
-
-        return (usb_address_t) address;
+        return ENOTSUP;
 }
 
@@ -157 +90 @@
 int usb_drv_reserve_default_address(int phone)
 {
-        return async_req_1_0(phone, DEV_IFACE_ID(USBHC_DEV_IFACE),
-            IPC_M_USBHC_RESERVE_DEFAULT_ADDRESS);
+        return ENOTSUP;
 }
 
@@ -168 +100 @@
 int usb_drv_release_default_address(int phone)
 {
-        return async_req_1_0(phone, DEV_IFACE_ID(USBHC_DEV_IFACE),
-            IPC_M_USBHC_RELEASE_DEFAULT_ADDRESS);
+        return ENOTSUP;
 }
 
@@ -179 +110 @@
 usb_address_t usb_drv_request_address(int phone)
 {
-        sysarg_t address;
-        int rc = async_req_1_1(phone, DEV_IFACE_ID(USBHC_DEV_IFACE),
-            IPC_M_USBHC_REQUEST_ADDRESS, &address);
-        if (rc != EOK) {
-                return rc;
-        } else {
-                return (usb_address_t) address;
-        }
+        return ENOTSUP;
 }
 
@@ -199 +123 @@
     devman_handle_t handle)
 {
-        int rc = async_req_3_0(phone, DEV_IFACE_ID(USBHC_DEV_IFACE),
-            IPC_M_USBHC_BIND_ADDRESS,
-            address, handle);
-
-        return rc;
+        return ENOTSUP;
 }
 
@@ -214 +134 @@
 int usb_drv_release_address(int phone, usb_address_t address)
 {
-        return async_req_2_0(phone, DEV_IFACE_ID(USBHC_DEV_IFACE),
-            IPC_M_USBHC_RELEASE_ADDRESS, address);
-}
-
-/** Send data to HCD.
- *
- * @param phone Phone to HC.
- * @param method Method used for calling.
- * @param target Targeted device.
- * @param buffer Data buffer (NULL to skip data transfer phase).
- * @param size Buffer size (must be zero when @p buffer is NULL).
- * @param handle Storage for transaction handle (cannot be NULL).
- * @return Error status.
- * @retval EINVAL Invalid parameter.
- * @retval ENOMEM Not enough memory to complete the operation.
- */
-static int async_send_buffer(int phone, int method,
-    usb_target_t target,
-    void *buffer, size_t size,
-    usb_handle_t *handle)
-{
-        if (phone < 0) {
-                return EINVAL;
-        }
-
-        if ((buffer == NULL) && (size > 0)) {
-                return EINVAL;
-        }
-
-        if (handle == NULL) {
-                return EINVAL;
-        }
-
-        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_4(phone,
-            DEV_IFACE_ID(USBHC_DEV_IFACE),
-            method,
-            target.address, target.endpoint,
-            size,
-            &transfer->reply);
-
-        if (size > 0) {
-                rc = async_data_write_start(phone, buffer, size);
-                if (rc != EOK) {
-                        async_wait_for(transfer->request, NULL);
-                        return rc;
-                }
-        }
-
-        *handle = (usb_handle_t) transfer;
-
-        return EOK;
-}
-
-/** Prepare data retrieval.
- *
- * @param phone Opened phone to HCD.
- * @param method Method used for calling.
- * @param target Targeted device.
- * @param buffer Buffer where to store retrieved data
- *      (NULL to skip data transfer phase).
- * @param size Buffer size (must be zero when @p buffer is NULL).
- * @param actual_size Storage where actual number of bytes transferred will
- *      be stored.
- * @param handle Storage for transaction handle (cannot be NULL).
- * @return Error status.
- * @retval EINVAL Invalid parameter.
- * @retval ENOMEM Not enough memory to complete the operation.
- */
-static int async_recv_buffer(int phone, int method,
-    usb_target_t target,
-    void *buffer, size_t size, size_t *actual_size,
-    usb_handle_t *handle)
-{
-        if (phone < 0) {
-                return EINVAL;
-        }
-
-        if ((buffer == NULL) && (size > 0)) {
-                return EINVAL;
-        }
-
-        if (handle == NULL) {
-                return EINVAL;
-        }
-
-        transfer_info_t *transfer
-            = (transfer_info_t *) malloc(sizeof(transfer_info_t));
-        if (transfer == NULL) {
-                return ENOMEM;
-        }
-
-        transfer->read_request = 0;
-        transfer->size_transferred = actual_size;
-        transfer->buffer = buffer;
-        transfer->size = size;
-        transfer->phone = phone;
-
-        transfer->request = async_send_4(phone,
-            DEV_IFACE_ID(USBHC_DEV_IFACE),
-            method,
-            target.address, target.endpoint,
-            size,
-            &transfer->reply);
-
-        if (buffer != NULL) {
-                transfer->read_request = async_data_read(phone, buffer, size,
-                    &transfer->read_reply);
-        }
-
-        *handle = (usb_handle_t) transfer;
-
-        return EOK;
-}
-
+        return ENOTSUP;
+}
 
 /** Blocks caller until given USB transaction is finished.
@@ -355 +149 @@
 int usb_drv_async_wait_for(usb_handle_t handle)
 {
-        if (handle == 0) {
-                return EBADMEM;
-        }
-
-        int rc = EOK;
-
-        transfer_info_t *transfer = (transfer_info_t *) handle;
-
-        sysarg_t answer_rc;
-
-        /*
-         * If the buffer is not NULL, we must accept some data.
-         */
-        if ((transfer->buffer != NULL) && (transfer->size > 0)) {
-                async_wait_for(transfer->read_request, &answer_rc);
-
-                if (answer_rc != EOK) {
-                        rc = (int) answer_rc;
-                        goto leave;
-                }
-
-                if (transfer->size_transferred != NULL) {
-                        *(transfer->size_transferred)
-                            = IPC_GET_ARG2(transfer->read_reply);
-                }
-        }
-
-        async_wait_for(transfer->request, &answer_rc);
-
-        if (answer_rc != EOK) {
-                rc = (int) answer_rc;
-                goto leave;
-        }
-
-leave:
-        free(transfer);
-
-        return rc;
+        return ENOTSUP;
 }
 
@@ -400 +157 @@
     usb_handle_t *handle)
 {
-        return async_send_buffer(phone,
-            IPC_M_USBHC_INTERRUPT_OUT,
-            target,
-            buffer, size,
-            handle);
+        return ENOTSUP;
 }
 
@@ -412 +165 @@
     usb_handle_t *handle)
 {
-        return async_recv_buffer(phone,
-            IPC_M_USBHC_INTERRUPT_IN,
-            target,
-            buffer, size, actual_size,
-            handle);
+        return ENOTSUP;
 }
 
@@ -424 +173 @@
     usb_handle_t *handle)
 {
-        return async_send_buffer(phone,
-            IPC_M_USBHC_CONTROL_WRITE_SETUP,
-            target,
-            buffer, size,
-            handle);
+        return ENOTSUP;
 }
 
@@ -436 +181 @@
     usb_handle_t *handle)
 {
-        return async_send_buffer(phone,
-            IPC_M_USBHC_CONTROL_WRITE_DATA,
-            target,
-            buffer, size,
-            handle);
+        return ENOTSUP;
 }
 
@@ -447 +188 @@
     usb_handle_t *handle)
 {
-        return async_recv_buffer(phone,
-            IPC_M_USBHC_CONTROL_WRITE_STATUS,
-            target,
-            NULL, 0, NULL,
-            handle);
+        return ENOTSUP;
 }
 
@@ -460 +197 @@
     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;
+        return ENOTSUP;
 }
 
@@ -512 +205 @@
     usb_handle_t *handle)
 {
-        return async_send_buffer(phone,
-            IPC_M_USBHC_CONTROL_READ_SETUP,
-            target,
-            buffer, size,
-            handle);
+        return ENOTSUP;
 }
 
@@ -524 +213 @@
     usb_handle_t *handle)
 {
-        return async_recv_buffer(phone,
-            IPC_M_USBHC_CONTROL_READ_DATA,
-            target,
-            buffer, size, actual_size,
-            handle);
+        return ENOTSUP;
 }
 
@@ -535 +220 @@
     usb_handle_t *handle)
 {
-        return async_send_buffer(phone,
-            IPC_M_USBHC_CONTROL_READ_STATUS,
-            target,
-            NULL, 0,
-            handle);
+        return ENOTSUP;
 }
 
@@ -548 +229 @@
     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;
-        transfer->size = buffer_size;
-        transfer->phone = phone;
-
-        int rc;
-
-        transfer->request = async_send_4(phone,
-            DEV_IFACE_ID(USBHC_DEV_IFACE),
-            IPC_M_USBHC_CONTROL_READ,
-            target.address, target.endpoint,
-            buffer_size,
-            &transfer->reply);
-
-        rc = async_data_write_start(phone, setup_packet, setup_packet_size);
-        if (rc != EOK) {
-                async_wait_for(transfer->request, NULL);
-                return rc;
-        }
-
-        transfer->read_request = async_data_read(phone, buffer, buffer_size,
-            &transfer->read_reply);
-
-        *handle = (usb_handle_t) transfer;
-
-        return EOK;
+        return ENOTSUP;
 }