Changes in / [600733e:2e85b3c] in mainline

Location:

uspace

Files:

• app/tester/adt/usbaddrkeep.c (modified) (1 diff)
• app/virtusbkbd/kbdconfig.c (modified) (1 diff)
• drv/uhci-hcd/iface.c (modified) (7 diffs)
• drv/uhci-rhd/port.c (modified) (10 diffs)
• drv/uhci-rhd/port.h (modified) (2 diffs)
• drv/usbhub/usbhub.c (modified) (5 diffs)
• drv/usbhub/usbhub.h (modified) (2 diffs)
• drv/vhc/conn.h (modified) (2 diffs)
• drv/vhc/connhost.c (modified) (13 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)
• lib/c/generic/str_error.c (modified) (2 diffs)
• lib/c/include/errno.h (modified) (1 diff)
• lib/drv/generic/remote_usbhc.c (modified) (13 diffs)
• lib/drv/include/usbhc_iface.h (modified) (2 diffs)
• lib/usb/Makefile (modified) (1 diff)
• lib/usb/include/usb/addrkeep.h (modified) (1 diff, 1 prop)
• lib/usb/include/usb/classes/hub.h (modified) (3 diffs)
• lib/usb/include/usb/hcd.h (deleted)
• lib/usb/include/usb/hcdhubd.h (deleted)
• lib/usb/include/usb/hub.h (added)
• lib/usb/include/usb/pipes.h (modified) (4 diffs)
• lib/usb/include/usb/recognise.h (modified) (1 diff)
• lib/usb/include/usb/usb.h (modified) (1 diff)
• lib/usb/include/usb/usbdevice.h (added)
• 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 (modified) (1 diff)
• lib/usb/src/pipesio.c (added)
• 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) (2 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/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/iface.c

@@ -103 +103 @@
 /*----------------------------------------------------------------------------*/
 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 = 8;
+    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;
 
@@ -118 +118 @@
 /*----------------------------------------------------------------------------*/
 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;
+    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;
 
@@ -133 +133 @@
 /*----------------------------------------------------------------------------*/
 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)
 {
-        size_t max_packet_size = 8;
         dev_speed_t speed = FULL_SPEED;
 
@@ -149 +149 @@
 /*----------------------------------------------------------------------------*/
 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)
 {
-        size_t max_packet_size = 8;
         dev_speed_t speed = FULL_SPEED;
 
@@ -165 +165 @@
 /*----------------------------------------------------------------------------*/
 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)
+    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;
@@ -173 +204 @@
         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)
@@ -180 +227 @@
 }
 /*----------------------------------------------------------------------------*/
-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)
-{
-        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, 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,
-    void *data, size_t size,
-    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, 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,
-    void *data, size_t size,
-    usbhc_iface_transfer_in_callback_t callback, void *arg)
-{
-        size_t max_packet_size = 8;
+    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;
 

uspace/drv/uhci-rhd/port.c

@@ -36 +36 @@
 
 #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>
@@ -58 +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);
@@ -98 +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 */
@@ -104 +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);
         }
@@ -113 +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);
 
         if (usb_address <= 0) {
@@ -128 +150 @@
 
         /* get default address */
-        int ret = usb_drv_reserve_default_address(port->hc_phone);
+        int ret = usb_hc_reserve_default_address(&port->hc_connection);
         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",
@@ -174 +196 @@
         }
 
-        /* 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",
@@ -194 +233 @@
 
         /* 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",
@@ -206 +245 @@
         assert(port->attached_device == 0);
 
-        devman_handle_t hc_handle;
-        ret = usb_drv_find_hc(port->rh, &hc_handle);
-        if (ret != EOK) {
-                usb_log_error("Failed to get handle of host controller: %s.\n",
-                    str_error(ret));
-                uhci_port_set_enabled(port, false);
-                return ENOMEM;
-        }
-
-        ret = usb_device_register_child_in_devman(usb_address, hc_handle,
-            port->rh, &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 */
                 usb_log_error("Failed(%d) in usb_drv_register_child.\n", ret);
@@ -225 +256 @@
                 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/usbhub/usbhub.c

@@ -84 +84 @@
         }*/
 
-        result->usb_device = usb_new(usb_hcd_attached_device_info_t);
-        result->usb_device->address = addr;
+        result->address = addr;
 
         // get hub descriptor
@@ -155 +154 @@
         int opResult;
         usb_target_t target;
-        target.address = hub_info->usb_device->address;
+        target.address = hub_info->address;
         target.endpoint = 0;
 
@@ -216 +215 @@
         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);
@@ -465 +464 @@
 
                 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",
@@ -507 +506 @@
                         if (interrupt) {
                                 usb_hub_process_interrupt(
-                                        hub_info, hc, port, hub_info->usb_device->address);
+                                        hub_info, hc, port, hub_info->address);
                         }
                 }

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"
-
-#include "usb/hcdhubd.h"
 
 /** basic information about device attached to hub */
@@ -52 +54 @@
         /** attached device handles */
         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;
-
 } 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,

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/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/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 *);
@@ -240 +242 @@
 
 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;
@@ -250 +252 @@
 
 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) {
@@ -270 +272 @@
         }
 
-        async_answer_0(trans->caller, USB_OUTCOME_OK);
+        async_answer_0(trans->caller, EOK);
 
         async_transaction_destroy(trans);
@@ -322 +324 @@
         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);
 
@@ -368 +371 @@
         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);
 
@@ -540 +544 @@
                 .endpoint = DEV_IPC_GET_ARG2(*call)
         };
+        size_t data_buffer_len = DEV_IPC_GET_ARG3(*call);
 
         int rc;
@@ -546 +551 @@
         void *data_buffer = NULL;
         size_t setup_packet_len = 0;
-        size_t data_buffer_len = 0;
 
         rc = async_data_write_accept(&setup_packet, false,
@@ -554 +558 @@
                 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;
+                }
         }
 
@@ -573 +580 @@
         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,
@@ -596 +603 @@
         }
 
-        size_t data_len = DEV_IPC_GET_ARG3(*call);
         usb_target_t target = {
                 .address = DEV_IPC_GET_ARG1(*call),
@@ -606 +612 @@
         void *setup_packet = NULL;
         size_t setup_packet_len = 0;
+        size_t data_len = 0;
 
         rc = async_data_write_accept(&setup_packet, false,
@@ -637 +644 @@
         }
 
-        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

@@ -207 +207 @@
 /** 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 *);
@@ -251 +251 @@
 
         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/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/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>
@@ -114 +115 @@
 } 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 *);
@@ -139 +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/recognise.h

@@ -39 +39 @@
 #include <usb/usb.h>
 #include <usb/pipes.h>
+#include <ipc/devman.h>
 
 int usb_device_create_match_ids(usb_endpoint_pipe_t *, match_id_list_t *);

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/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 max_packet_size Maximum packet size in bytes.
- * @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, size_t max_packet_size,
-    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->max_packet_size = max_packet_size;
-        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, 8, USB_DIRECTION_BOTH);
-
-        return rc;
+        return usb_device_connection_initialize(dev_connection,
+            hc_connection->hc_handle, (usb_address_t) 0);
 }
 
@@ -224 +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/pipesinit.c

@@ -320 +320 @@
 }
 
+/** Initialize USB endpoint pipe.
+ *
+ * @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 max_packet_size Maximum packet size in bytes.
+ * @param direction Endpoint direction (in/out).
+ * @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, size_t max_packet_size,
+    usb_direction_t direction)
+{
+        assert(pipe);
+        assert(connection);
+
+        pipe->wire = connection;
+        pipe->hc_phone = -1;
+        pipe->endpoint_no = endpoint_no;
+        pipe->transfer_type = transfer_type;
+        pipe->max_packet_size = max_packet_size;
+        pipe->direction = direction;
+
+        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, 8, USB_DIRECTION_BOTH);
+
+        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

@@ -464 +464 @@
         assert(setup_packet != NULL);
         assert(setup_packet_size > 0);
-        assert(buffer != NULL);
-        assert(buffer_size > 0);
+        assert(((buffer != NULL) && (buffer_size > 0))
+            || ((buffer == NULL) && (buffer_size == 0)));
         assert(handle != NULL);
 
@@ -494 +494 @@
         }
 
-        rc = async_data_write_start(phone, buffer, buffer_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;
+                }
         }
 

uspace/lib/usbvirt/Makefile

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