Changeset 72af8da for uspace/drv/uhci-hcd – HelenOS

uspace/drv/uhci-hcd/Makefile

-              r3e7b7cd
+              r72af8da
         iface.c \
         main.c \
-        root_hub.c \
         transfer_list.c \
         uhci.c \
+        uhci_hc.c \
+        uhci_rh.c \
         uhci_struct/transfer_descriptor.c \
         utils/device_keeper.c \

uspace/drv/uhci-hcd/batch.c

-              r3e7b7cd
+              r72af8da
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 /** @addtogroup usb
+/** @addtogroup drvusbuhcihc
  * @{
  */
 /** @file
  * @brief UHCI driver
+ * @brief UHCI driver USB transaction structure
  */
 #include <errno.h>
 …
 #include "batch.h"
 #include "transfer_list.h"
 #include "uhci.h"
+#include "uhci_hc.h"
 #include "utils/malloc32.h"
 #define DEFAULT_ERROR_COUNT 3
+static int batch_schedule(batch_t *instance);
+static void batch_control(
+    batch_t *instance, int data_stage, int status_stage);
+static void batch_control(batch_t *instance,
+    usb_packet_id data_stage, usb_packet_id status_stage);
+static void batch_data(batch_t *instance, usb_packet_id pid);
 static void batch_call_in(batch_t *instance);
 static void batch_call_out(batch_t *instance);
 …
+/** Allocate memory and initialize internal data structure.
+ *
+ * @param[in] fun DDF function to pass to callback.
+ * @param[in] target Device and endpoint target of the transaction.
+ * @param[in] transfer_type Interrupt, Control or Bulk.
+ * @param[in] max_packet_size maximum allowed size of data packets.
+ * @param[in] speed Speed of the transaction.
+ * @param[in] buffer Data source/destination.
+ * @param[in] size Size of the buffer.
+ * @param[in] setup_buffer Setup data source (if not NULL)
+ * @param[in] setup_size Size of setup_buffer (should be always 8)
+ * @param[in] func_in function to call on inbound transaction completion
+ * @param[in] func_out function to call on outbound transaction completion
+ * @param[in] arg additional parameter to func_in or func_out
+ * @param[in] manager Pointer to toggle management structure.
+ * @return Valid pointer if all substructures were successfully created,
+ * NULL otherwise.
+ *
+ * Determines the number of needed packets (TDs). Prepares a transport buffer
+ * (that is accessible by the hardware). Initializes parameters needed for the
+ * transaction and callback.
+ */
 batch_t * batch_get(ddf_fun_t *fun, usb_target_t target,
     usb_transfer_type_t transfer_type, size_t max_packet_size,
 …
     char* setup_buffer, size_t setup_size,
     usbhc_iface_transfer_in_callback_t func_in,
+    usbhc_iface_transfer_out_callback_t func_out, void *arg)
+    usbhc_iface_transfer_out_callback_t func_out, void *arg,
+    device_keeper_t *manager
+    )
+{
         assert(func_in == NULL || func_out == NULL);
         assert(func_in != NULL || func_out != NULL);
+#define CHECK_NULL_DISPOSE_RETURN(ptr, message...) \
+        if (ptr == NULL) { \
+                usb_log_error(message); \
+                if (instance) { \
+                        batch_dispose(instance); \
+                } \
+                return NULL; \
+        } else (void)0
         batch_t *instance = malloc(sizeof(batch_t));
+        if (instance == NULL) {
+                usb_log_error("Failed to allocate batch instance.\n");
+                return NULL;
+        }
+        instance->qh = queue_head_get();
+        if (instance->qh == NULL) {
+                usb_log_error("Failed to allocate queue head.\n");
+                free(instance);
+                return NULL;
+        }
+        CHECK_NULL_DISPOSE_RETURN(instance,
+            "Failed to allocate batch instance.\n");
+        bzero(instance, sizeof(batch_t));
+        instance->qh = malloc32(sizeof(qh_t));
+        CHECK_NULL_DISPOSE_RETURN(instance->qh,
+            "Failed to allocate batch queue head.\n");
+        qh_init(instance->qh);
         instance->packets = (size + max_packet_size - 1) / max_packet_size;
 …
+        }
+        instance->tds = malloc32(sizeof(transfer_descriptor_t) * instance->packets);
+        if (instance->tds == NULL) {
+                usb_log_error("Failed to allocate transfer descriptors.\n");
+                queue_head_dispose(instance->qh);
+                free(instance);
+                return NULL;
+        }
+        bzero(instance->tds, sizeof(transfer_descriptor_t) * instance->packets);
+        const size_t transport_size = max_packet_size * instance->packets;
+        instance->transport_buffer =
+           (size > 0) ? malloc32(transport_size) : NULL;
+        if ((size > 0) && (instance->transport_buffer == NULL)) {
+                usb_log_error("Failed to allocate device accessible buffer.\n");
+                queue_head_dispose(instance->qh);
+                free32(instance->tds);
+                free(instance);
+                return NULL;
+        }
+        instance->setup_buffer = setup_buffer ? malloc32(setup_size) : NULL;
+        if ((setup_size > 0) && (instance->setup_buffer == NULL)) {
+                usb_log_error("Failed to allocate device accessible setup buffer.\n");
+                queue_head_dispose(instance->qh);
+                free32(instance->tds);
+                free32(instance->transport_buffer);
+                free(instance);
+                return NULL;
+        }
+        if (instance->setup_buffer) {
+        instance->tds = malloc32(sizeof(td_t) * instance->packets);
+        CHECK_NULL_DISPOSE_RETURN(
+            instance->tds, "Failed to allocate transfer descriptors.\n");
+        bzero(instance->tds, sizeof(td_t) * instance->packets);
+        if (size > 0) {
+                instance->transport_buffer = malloc32(size);
+                CHECK_NULL_DISPOSE_RETURN(instance->transport_buffer,
+                    "Failed to allocate device accessible buffer.\n");
+        }
+        if (setup_size > 0) {
+                instance->setup_buffer = malloc32(setup_size);
+                CHECK_NULL_DISPOSE_RETURN(instance->setup_buffer,
+                    "Failed to allocate device accessible setup buffer.\n");
                 memcpy(instance->setup_buffer, setup_buffer, setup_size);
+        }
+        link_initialize(&instance->link);
         instance->max_packet_size = max_packet_size;
-        link_initialize(&instance->link);
         instance->target = target;
         instance->transfer_type = transfer_type;
-        if (func_out)
-                instance->callback_out = func_out;
-        if (func_in)
-                instance->callback_in = func_in;
         instance->buffer = buffer;
         instance->buffer_size = size;
 …
         instance->arg = arg;
         instance->speed = speed;
+        queue_head_element_td(instance->qh, addr_to_phys(instance->tds));
+        instance->manager = manager;
+        instance->callback_out = func_out;
+        instance->callback_in = func_in;
+        qh_set_element_td(instance->qh, addr_to_phys(instance->tds));
         usb_log_debug("Batch(%p) %d:%d memory structures ready.\n",
             instance, target.address, target.endpoint);
 …
+}
 /*----------------------------------------------------------------------------*/
+/** Check batch TDs for activity.
+ *
+ * @param[in] instance Batch structure to use.
+ * @return False, if there is an active TD, true otherwise.
+ *
+ * Walk all TDs. Stop with false if there is an active one (it is to be
+ * processed). Stop with true if an error is found. Return true if the last TS
+ * is reached.
+ */
 bool batch_is_complete(batch_t *instance)
+{
 …
         size_t i = 0;
         for (;i < instance->packets; ++i) {
                 if (transfer_descriptor_is_active(&instance->tds[i])) {
+                if (td_is_active(&instance->tds[i])) {
                         return false;
+                }
+                instance->error = transfer_descriptor_status(&instance->tds[i]);
+                instance->error = td_status(&instance->tds[i]);
                 if (instance->error != EOK) {
+                        usb_log_debug("Batch(%p) found error TD(%d):%x.\n",
+                            instance, i, instance->tds[i].status);
+                        td_print_status(&instance->tds[i]);
+                        device_keeper_set_toggle(instance->manager,
+                            instance->target, td_toggle(&instance->tds[i]));
                         if (i > 0)
+                                instance->transfered_size -= instance->setup_size;
+                        usb_log_debug("Batch(%p) found error TD(%d):%x.\n",
+                          instance, i, instance->tds[i].status);
+                                goto substract_ret;
                         return true;
+                }
+                instance->transfered_size +=
+                    transfer_descriptor_actual_size(&instance->tds[i]);
+        }
+                instance->transfered_size += td_act_size(&instance->tds[i]);
+                if (td_is_short(&instance->tds[i]))
+                        goto substract_ret;
+        }
+substract_ret:
         instance->transfered_size -= instance->setup_size;
         return true;
+}
 /*----------------------------------------------------------------------------*/
+/** Prepares control write transaction.
+ *
+ * @param[in] instance Batch structure to use.
+ *
+ * Uses genercir control function with pids OUT and IN.
+ */
 void batch_control_write(batch_t *instance)
+{
         assert(instance);
+        /* we are data out, we are supposed to provide data */
+        memcpy(instance->transport_buffer, instance->buffer, instance->buffer_size);
+        /* We are data out, we are supposed to provide data */
+        memcpy(instance->transport_buffer, instance->buffer,
+            instance->buffer_size);
         batch_control(instance, USB_PID_OUT, USB_PID_IN);
         instance->next_step = batch_call_out_and_dispose;
         usb_log_debug("Batch(%p) CONTROL WRITE initialized.\n", instance);
+        batch_schedule(instance);
+}
+/*----------------------------------------------------------------------------*/
+}
+/*----------------------------------------------------------------------------*/
+/** Prepares control read transaction.
+ *
+ * @param[in] instance Batch structure to use.
+ *
+ * Uses generic control with pids IN and OUT.
+ */
 void batch_control_read(batch_t *instance)
+{
 …
         instance->next_step = batch_call_in_and_dispose;
         usb_log_debug("Batch(%p) CONTROL READ initialized.\n", instance);
+        batch_schedule(instance);
+}
+/*----------------------------------------------------------------------------*/
+}
+/*----------------------------------------------------------------------------*/
+/** Prepare interrupt in transaction.
+ *
+ * @param[in] instance Batch structure to use.
+ *
+ * Data transaction with PID_IN.
+ */
 void batch_interrupt_in(batch_t *instance)
+{
         assert(instance);
+        const bool low_speed = instance->speed == USB_SPEED_LOW;
+        int toggle = 1;
+        size_t i = 0;
+        for (;i < instance->packets; ++i) {
+                char *data =
+                    instance->transport_buffer + (i  * instance->max_packet_size);
+                transfer_descriptor_t *next = (i + 1) < instance->packets ?
+                    &instance->tds[i + 1] : NULL;
+                toggle = 1 - toggle;
+                transfer_descriptor_init(&instance->tds[i], DEFAULT_ERROR_COUNT,
+                    instance->max_packet_size, toggle, false, low_speed,
+                    instance->target, USB_PID_IN, data, next);
+        }
+        instance->tds[i - 1].status |= TD_STATUS_COMPLETE_INTERRUPT_FLAG;
+        batch_data(instance, USB_PID_IN);
         instance->next_step = batch_call_in_and_dispose;
         usb_log_debug("Batch(%p) INTERRUPT IN initialized.\n", instance);
+        batch_schedule(instance);
+}
+/*----------------------------------------------------------------------------*/
+}
+/*----------------------------------------------------------------------------*/
+/** Prepare interrupt out transaction.
+ *
+ * @param[in] instance Batch structure to use.
+ *
+ * Data transaction with PID_OUT.
+ */
 void batch_interrupt_out(batch_t *instance)
+{
         assert(instance);
+        /* We are data out, we are supposed to provide data */
         memcpy(instance->transport_buffer, instance->buffer, instance->buffer_size);
+        const bool low_speed = instance->speed == USB_SPEED_LOW;
+        int toggle = 1;
+        size_t i = 0;
+        for (;i < instance->packets; ++i) {
+                char *data =
+                    instance->transport_buffer + (i  * instance->max_packet_size);
+                transfer_descriptor_t *next = (i + 1) < instance->packets ?
+                    &instance->tds[i + 1] : NULL;
+                toggle = 1 - toggle;
+                transfer_descriptor_init(&instance->tds[i], DEFAULT_ERROR_COUNT,
+                    instance->max_packet_size, toggle++, false, low_speed,
+                    instance->target, USB_PID_OUT, data, next);
+        }
+        instance->tds[i - 1].status |= TD_STATUS_COMPLETE_INTERRUPT_FLAG;
+        batch_data(instance, USB_PID_OUT);
         instance->next_step = batch_call_out_and_dispose;
         usb_log_debug("Batch(%p) INTERRUPT OUT initialized.\n", instance);
+        batch_schedule(instance);
+}
+/*----------------------------------------------------------------------------*/
+static void batch_control(
+    batch_t *instance, int data_stage, int status_stage)
+}
+/*----------------------------------------------------------------------------*/
+/** Prepare bulk in transaction.
+ *
+ * @param[in] instance Batch structure to use.
+ *
+ * Data transaction with PID_IN.
+ */
+void batch_bulk_in(batch_t *instance)
+{
+        assert(instance);
+        batch_data(instance, USB_PID_IN);
+        instance->next_step = batch_call_in_and_dispose;
+        usb_log_debug("Batch(%p) BULK IN initialized.\n", instance);
+}
+/*----------------------------------------------------------------------------*/
+/** Prepare bulk out transaction.
+ *
+ * @param[in] instance Batch structure to use.
+ *
+ * Data transaction with PID_OUT.
+ */
+void batch_bulk_out(batch_t *instance)
+{
+        assert(instance);
+        /* We are data out, we are supposed to provide data */
+        memcpy(instance->transport_buffer, instance->buffer, instance->buffer_size);
+        batch_data(instance, USB_PID_OUT);
+        instance->next_step = batch_call_out_and_dispose;
+        usb_log_debug("Batch(%p) BULK OUT initialized.\n", instance);
+}
+/*----------------------------------------------------------------------------*/
+/** Prepare generic data transaction
+ *
+ * @param[in] instance Batch structure to use.
+ * @param[in] pid to use for data packets.
+ *
+ * Packets with alternating toggle bit and supplied pid value.
+ * The last packet is marked with IOC flag.
+ */
+void batch_data(batch_t *instance, usb_packet_id pid)
+{
+        assert(instance);
+        const bool low_speed = instance->speed == USB_SPEED_LOW;
+        int toggle =
+            device_keeper_get_toggle(instance->manager, instance->target);
+        assert(toggle == 0 || toggle == 1);
+        size_t packet = 0;
+        size_t remain_size = instance->buffer_size;
+        while (remain_size > 0) {
+                char *data =
+                    instance->transport_buffer + instance->buffer_size
+                    - remain_size;
+                const size_t packet_size =
+                    (instance->max_packet_size > remain_size) ?
+                    remain_size : instance->max_packet_size;
+                td_t *next_packet = (packet + 1 < instance->packets)
+                    ? &instance->tds[packet + 1] : NULL;
+                assert(packet < instance->packets);
+                assert(packet_size <= remain_size);
+                td_init(
+                    &instance->tds[packet], DEFAULT_ERROR_COUNT, packet_size,
+                    toggle, false, low_speed, instance->target, pid, data,
+                    next_packet);
+                toggle = 1 - toggle;
+                remain_size -= packet_size;
+                ++packet;
+        }
+        td_set_ioc(&instance->tds[packet - 1]);
+        device_keeper_set_toggle(instance->manager, instance->target, toggle);
+}
+/*----------------------------------------------------------------------------*/
+/** Prepare generic control transaction
+ *
+ * @param[in] instance Batch structure to use.
+ * @param[in] data_stage to use for data packets.
+ * @param[in] status_stage to use for data packets.
+ *
+ * Setup stage with toggle 0 and USB_PID_SETUP.
+ * Data stage with alternating toggle and pid supplied by parameter.
+ * Status stage with toggle 1 and pid supplied by parameter.
+ * The last packet is marked with IOC.
+ */
+void batch_control(batch_t *instance,
+   usb_packet_id data_stage, usb_packet_id status_stage)
+{
         assert(instance);
 …
         int toggle = 0;
         /* setup stage */
         transfer_descriptor_init(instance->tds, DEFAULT_ERROR_COUNT,
+        td_init(instance->tds, DEFAULT_ERROR_COUNT,
             instance->setup_size, toggle, false, low_speed, instance->target,
             USB_PID_SETUP, instance->setup_buffer, &instance->tds[1]);
 …
                     remain_size : instance->max_packet_size;
                 transfer_descriptor_init(&instance->tds[packet],
                     DEFAULT_ERROR_COUNT, packet_size, toggle, false, low_speed,
                     instance->target, data_stage, data,
                     &instance->tds[packet + 1]);
+                td_init(
+                    &instance->tds[packet], DEFAULT_ERROR_COUNT, packet_size,
+                    toggle, false, low_speed, instance->target, data_stage,
+                    data, &instance->tds[packet + 1]);
                 ++packet;
 …
         /* status stage */
         assert(packet == instance->packets - 1);
         transfer_descriptor_init(&instance->tds[packet], DEFAULT_ERROR_COUNT,
+        td_init(&instance->tds[packet], DEFAULT_ERROR_COUNT,
 , 1, false, low_speed, instance->target, status_stage, NULL, NULL);
+        instance->tds[packet].status |= TD_STATUS_COMPLETE_INTERRUPT_FLAG;
+        td_set_ioc(&instance->tds[packet]);
         usb_log_debug2("Control last TD status: %x.\n",
             instance->tds[packet].status);
+}
 /*----------------------------------------------------------------------------*/
+/** Prepare data, get error status and call callback in.
+ *
+ * @param[in] instance Batch structure to use.
+ * Copies data from transport buffer, and calls callback with appropriate
+ * parameters.
+ */
 void batch_call_in(batch_t *instance)
+{
 …
         assert(instance->callback_in);
+        memcpy(instance->buffer, instance->transport_buffer, instance->buffer_size);
+        /* We are data in, we need data */
+        memcpy(instance->buffer, instance->transport_buffer,
+            instance->buffer_size);
         int err = instance->error;
 …
             instance->transfered_size);
+        instance->callback_in(instance->fun,
+            err, instance->transfered_size,
+            instance->arg);
+}
+/*----------------------------------------------------------------------------*/
+        instance->callback_in(
+            instance->fun, err, instance->transfered_size, instance->arg);
+}
+/*----------------------------------------------------------------------------*/
+/** Get error status and call callback out.
+ *
+ * @param[in] instance Batch structure to use.
+ */
 void batch_call_out(batch_t *instance)
+{
 …
+}
 /*----------------------------------------------------------------------------*/
+/** Helper function calls callback and correctly disposes of batch structure.
+ *
+ * @param[in] instance Batch structure to use.
+ */
 void batch_call_in_and_dispose(batch_t *instance)
+{
         assert(instance);
         batch_call_in(instance);
+        batch_dispose(instance);
+}
+/*----------------------------------------------------------------------------*/
+/** Helper function calls callback and correctly disposes of batch structure.
+ *
+ * @param[in] instance Batch structure to use.
+ */
+void batch_call_out_and_dispose(batch_t *instance)
+{
+        assert(instance);
+        batch_call_out(instance);
+        batch_dispose(instance);
+}
+/*----------------------------------------------------------------------------*/
+/** Correctly dispose all used data structures.
+ *
+ * @param[in] instance Batch structure to use.
+ */
+void batch_dispose(batch_t *instance)
+{
+        assert(instance);
         usb_log_debug("Batch(%p) disposing.\n", instance);
+        /* free32 is NULL safe */
         free32(instance->tds);
         free32(instance->qh);
 …
         free(instance);
+}
-/*----------------------------------------------------------------------------*/
-void batch_call_out_and_dispose(batch_t *instance)
+{
-        assert(instance);
-        batch_call_out(instance);
-        usb_log_debug("Batch(%p) disposing.\n", instance);
-        free32(instance->tds);
-        free32(instance->qh);
-        free32(instance->setup_buffer);
-        free32(instance->transport_buffer);
-        free(instance);
+}
-/*----------------------------------------------------------------------------*/
-int batch_schedule(batch_t *instance)
+{
-        assert(instance);
-        uhci_t *hc = fun_to_uhci(instance->fun);
-        assert(hc);
-        return uhci_schedule(hc, instance);
+}
 /**
  * @}

uspace/drv/uhci-hcd/batch.h

-              r3e7b7cd
+              r72af8da
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 /** @addtogroup usb
+/** @addtogroup drvusbuhcihc
  * @{
  */
 /** @file
  * @brief UHCI driver
+ * @brief UHCI driver USB transaction structure
  */
 #ifndef DRV_UHCI_BATCH_H
 …
 #include "uhci_struct/transfer_descriptor.h"
 #include "uhci_struct/queue_head.h"
+#include "utils/device_keeper.h"
 typedef struct batch
 …
         usb_target_t target;
         usb_transfer_type_t transfer_type;
+        union {
+                usbhc_iface_transfer_in_callback_t callback_in;
+                usbhc_iface_transfer_out_callback_t callback_out;
+        };
+        usbhc_iface_transfer_in_callback_t callback_in;
+        usbhc_iface_transfer_out_callback_t callback_out;
         void *arg;
         char *transport_buffer;
 …
         int error;
         ddf_fun_t *fun;
         queue_head_t *qh;
         transfer_descriptor_t *tds;
+        qh_t *qh;
+        td_t *tds;
         void (*next_step)(struct batch*);
+        device_keeper_t *manager;
 } batch_t;
 …
                 char *setup_buffer, size_t setup_size,
     usbhc_iface_transfer_in_callback_t func_in,
+    usbhc_iface_transfer_out_callback_t func_out, void *arg);
+    usbhc_iface_transfer_out_callback_t func_out, void *arg,
+                device_keeper_t *manager
+                );
+void batch_dispose(batch_t *instance);
 bool batch_is_complete(batch_t *instance);
 …
 void batch_interrupt_out(batch_t *instance);
+/* DEPRECATED FUNCTIONS NEEDED BY THE OLD API */
+void batch_control_setup_old(batch_t *instance);
+void batch_bulk_in(batch_t *instance);
+void batch_control_write_data_old(batch_t *instance);
+void batch_control_read_data_old(batch_t *instance);
+void batch_control_write_status_old(batch_t *instance);
+void batch_control_read_status_old(batch_t *instance);
+void batch_bulk_out(batch_t *instance);
 #endif
 /**

uspace/drv/uhci-hcd/iface.c

-              r3e7b7cd
+              r72af8da
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 /** @addtogroup usb
+/** @addtogroup drvusbuhcihc
  * @{
  */
 /** @file
  * @brief UHCI driver
+ * @brief UHCI driver hc interface implementation
  */
 #include <ddf/driver.h>
 …
 #include "iface.h"
 #include "uhci.h"
+#include "uhci_hc.h"
 #include "utils/device_keeper.h"
+/** Reserve default address interface function
+ *
+ * @param[in] fun DDF function that was called.
+ * @param[in] speed Speed to associate with the new default address.
+ * @return Error code.
+ */
 /*----------------------------------------------------------------------------*/
 static int reserve_default_address(ddf_fun_t *fun, usb_speed_t speed)
+{
         assert(fun);
         uhci_t *hc = fun_to_uhci(fun);
+        uhci_hc_t *hc = fun_to_uhci_hc(fun);
         assert(hc);
         usb_log_debug("Default address request with speed %d.\n", speed);
 …
+}
 /*----------------------------------------------------------------------------*/
+/** Release default address interface function
+ *
+ * @param[in] fun DDF function that was called.
+ * @return Error code.
+ */
 static int release_default_address(ddf_fun_t *fun)
+{
         assert(fun);
         uhci_t *hc = fun_to_uhci(fun);
+        uhci_hc_t *hc = fun_to_uhci_hc(fun);
         assert(hc);
         usb_log_debug("Default address release.\n");
 …
+}
 /*----------------------------------------------------------------------------*/
+/** Request address interface function
+ *
+ * @param[in] fun DDF function that was called.
+ * @param[in] speed Speed to associate with the new default address.
+ * @param[out] address Place to write a new address.
+ * @return Error code.
+ */
 static int request_address(ddf_fun_t *fun, usb_speed_t speed,
     usb_address_t *address)
+{
         assert(fun);
         uhci_t *hc = fun_to_uhci(fun);
+        uhci_hc_t *hc = fun_to_uhci_hc(fun);
         assert(hc);
         assert(address);
 …
+}
 /*----------------------------------------------------------------------------*/
+/** Bind address interface function
+ *
+ * @param[in] fun DDF function that was called.
+ * @param[in] address Address of the device
+ * @param[in] handle Devman handle of the device driver.
+ * @return Error code.
+ */
 static int bind_address(
   ddf_fun_t *fun, usb_address_t address, devman_handle_t handle)
+{
         assert(fun);
         uhci_t *hc = fun_to_uhci(fun);
+        uhci_hc_t *hc = fun_to_uhci_hc(fun);
         assert(hc);
         usb_log_debug("Address bind %d-%d.\n", address, handle);
 …
+}
 /*----------------------------------------------------------------------------*/
+/** Release address interface function
+ *
+ * @param[in] fun DDF function that was called.
+ * @param[in] address USB address to be released.
+ * @return Error code.
+ */
 static int release_address(ddf_fun_t *fun, usb_address_t address)
+{
         assert(fun);
         uhci_t *hc = fun_to_uhci(fun);
+        uhci_hc_t *hc = fun_to_uhci_hc(fun);
         assert(hc);
         usb_log_debug("Address release %d.\n", address);
 …
+}
 /*----------------------------------------------------------------------------*/
+/** Interrupt out transaction interface function
+ *
+ * @param[in] fun DDF function that was called.
+ * @param[in] target USB device to write to.
+ * @param[in] max_packet_size maximum size of data packet the device accepts
+ * @param[in] data Source of data.
+ * @param[in] size Size of data source.
+ * @param[in] callback Function to call on transaction completion
+ * @param[in] arg Additional for callback function.
+ * @return Error code.
+ */
 static int interrupt_out(ddf_fun_t *fun, usb_target_t target,
     size_t max_packet_size, void *data, size_t size,
 …
+{
         assert(fun);
         uhci_t *hc = fun_to_uhci(fun);
+        uhci_hc_t *hc = fun_to_uhci_hc(fun);
         assert(hc);
         usb_speed_t speed = device_keeper_speed(&hc->device_manager, target.address);
 …
         batch_t *batch = batch_get(fun, target, USB_TRANSFER_INTERRUPT,
+            max_packet_size, speed, data, size, NULL, 0, NULL, callback, arg);
+            max_packet_size, speed, data, size, NULL, 0, NULL, callback, arg,
+            &hc->device_manager);
         if (!batch)
                 return ENOMEM;
         batch_interrupt_out(batch);
+        return EOK;
+}
+/*----------------------------------------------------------------------------*/
+        const int ret = uhci_hc_schedule(hc, batch);
+        if (ret != EOK) {
+                batch_dispose(batch);
+                return ret;
+        }
+        return EOK;
+}
+/*----------------------------------------------------------------------------*/
+/** Interrupt in transaction interface function
+ *
+ * @param[in] fun DDF function that was called.
+ * @param[in] target USB device to write to.
+ * @param[in] max_packet_size maximum size of data packet the device accepts
+ * @param[out] data Data destination.
+ * @param[in] size Size of data source.
+ * @param[in] callback Function to call on transaction completion
+ * @param[in] arg Additional for callback function.
+ * @return Error code.
+ */
 static int interrupt_in(ddf_fun_t *fun, usb_target_t target,
     size_t max_packet_size, void *data, size_t size,
 …
+{
         assert(fun);
         uhci_t *hc = fun_to_uhci(fun);
+        uhci_hc_t *hc = fun_to_uhci_hc(fun);
         assert(hc);
         usb_speed_t speed = device_keeper_speed(&hc->device_manager, target.address);
 …
         batch_t *batch = batch_get(fun, target, USB_TRANSFER_INTERRUPT,
+            max_packet_size, speed, data, size, NULL, 0, callback, NULL, arg);
+            max_packet_size, speed, data, size, NULL, 0, callback, NULL, arg,
+                        &hc->device_manager);
         if (!batch)
                 return ENOMEM;
         batch_interrupt_in(batch);
+        return EOK;
+}
+/*----------------------------------------------------------------------------*/
+        const int ret = uhci_hc_schedule(hc, batch);
+        if (ret != EOK) {
+                batch_dispose(batch);
+                return ret;
+        }
+        return EOK;
+}
+/*----------------------------------------------------------------------------*/
+/** Bulk out transaction interface function
+ *
+ * @param[in] fun DDF function that was called.
+ * @param[in] target USB device to write to.
+ * @param[in] max_packet_size maximum size of data packet the device accepts
+ * @param[in] data Source of data.
+ * @param[in] size Size of data source.
+ * @param[in] callback Function to call on transaction completion
+ * @param[in] arg Additional for callback function.
+ * @return Error code.
+ */
+static int bulk_out(ddf_fun_t *fun, usb_target_t target,
+    size_t max_packet_size, void *data, size_t size,
+    usbhc_iface_transfer_out_callback_t callback, void *arg)
+{
+        assert(fun);
+        uhci_hc_t *hc = fun_to_uhci_hc(fun);
+        assert(hc);
+        usb_speed_t speed = device_keeper_speed(&hc->device_manager, target.address);
+        usb_log_debug("Bulk OUT %d:%d %zu(%zu).\n",
+            target.address, target.endpoint, size, max_packet_size);
+        batch_t *batch = batch_get(fun, target, USB_TRANSFER_BULK,
+            max_packet_size, speed, data, size, NULL, 0, NULL, callback, arg,
+            &hc->device_manager);
+        if (!batch)
+                return ENOMEM;
+        batch_bulk_out(batch);
+        const int ret = uhci_hc_schedule(hc, batch);
+        if (ret != EOK) {
+                batch_dispose(batch);
+                return ret;
+        }
+        return EOK;
+}
+/*----------------------------------------------------------------------------*/
+/** Bulk in transaction interface function
+ *
+ * @param[in] fun DDF function that was called.
+ * @param[in] target USB device to write to.
+ * @param[in] max_packet_size maximum size of data packet the device accepts
+ * @param[out] data Data destination.
+ * @param[in] size Size of data source.
+ * @param[in] callback Function to call on transaction completion
+ * @param[in] arg Additional for callback function.
+ * @return Error code.
+ */
+static int bulk_in(ddf_fun_t *fun, usb_target_t target,
+    size_t max_packet_size, void *data, size_t size,
+    usbhc_iface_transfer_in_callback_t callback, void *arg)
+{
+        assert(fun);
+        uhci_hc_t *hc = fun_to_uhci_hc(fun);
+        assert(hc);
+        usb_speed_t speed = device_keeper_speed(&hc->device_manager, target.address);
+        usb_log_debug("Bulk IN %d:%d %zu(%zu).\n",
+            target.address, target.endpoint, size, max_packet_size);
+        batch_t *batch = batch_get(fun, target, USB_TRANSFER_BULK,
+            max_packet_size, speed, data, size, NULL, 0, callback, NULL, arg,
+            &hc->device_manager);
+        if (!batch)
+                return ENOMEM;
+        batch_bulk_in(batch);
+        const int ret = uhci_hc_schedule(hc, batch);
+        if (ret != EOK) {
+                batch_dispose(batch);
+                return ret;
+        }
+        return EOK;
+}
+/*----------------------------------------------------------------------------*/
+/** Control write transaction interface function
+ *
+ * @param[in] fun DDF function that was called.
+ * @param[in] target USB device to write to.
+ * @param[in] max_packet_size maximum size of data packet the device accepts.
+ * @param[in] setup_data Data to send with SETUP packet.
+ * @param[in] setup_size Size of data to send with SETUP packet (should be 8B).
+ * @param[in] data Source of data.
+ * @param[in] size Size of data source.
+ * @param[in] callback Function to call on transaction completion.
+ * @param[in] arg Additional for callback function.
+ * @return Error code.
+ */
 static int control_write(ddf_fun_t *fun, usb_target_t target,
     size_t max_packet_size,
 …
+{
         assert(fun);
+        uhci_t *hc = fun_to_uhci(fun);
+        assert(hc);
+        usb_speed_t speed = device_keeper_speed(&hc->device_manager, target.address);
+        usb_log_debug("Control WRITE %d:%d %zu(%zu).\n",
+            target.address, target.endpoint, size, max_packet_size);
+        uhci_hc_t *hc = fun_to_uhci_hc(fun);
+        assert(hc);
+        usb_speed_t speed = device_keeper_speed(&hc->device_manager, target.address);
+        usb_log_debug("Control WRITE (%d) %d:%d %zu(%zu).\n",
+            speed, target.address, target.endpoint, size, max_packet_size);
+        if (setup_size != 8)
+                return EINVAL;
         batch_t *batch = batch_get(fun, target, USB_TRANSFER_CONTROL,
             max_packet_size, speed, data, size, setup_data, setup_size,
+            NULL, callback, arg);
+        if (!batch)
+                return ENOMEM;
+            NULL, callback, arg, &hc->device_manager);
+        if (!batch)
+                return ENOMEM;
+        device_keeper_reset_if_need(&hc->device_manager, target, setup_data);
         batch_control_write(batch);
+        return EOK;
+}
+/*----------------------------------------------------------------------------*/
+        const int ret = uhci_hc_schedule(hc, batch);
+        if (ret != EOK) {
+                batch_dispose(batch);
+                return ret;
+        }
+        return EOK;
+}
+/*----------------------------------------------------------------------------*/
+/** Control read transaction interface function
+ *
+ * @param[in] fun DDF function that was called.
+ * @param[in] target USB device to write to.
+ * @param[in] max_packet_size maximum size of data packet the device accepts.
+ * @param[in] setup_data Data to send with SETUP packet.
+ * @param[in] setup_size Size of data to send with SETUP packet (should be 8B).
+ * @param[out] data Source of data.
+ * @param[in] size Size of data source.
+ * @param[in] callback Function to call on transaction completion.
+ * @param[in] arg Additional for callback function.
+ * @return Error code.
+ */
 static int control_read(ddf_fun_t *fun, usb_target_t target,
     size_t max_packet_size,
 …
+{
         assert(fun);
         uhci_t *hc = fun_to_uhci(fun);
         assert(hc);
         usb_speed_t speed = device_keeper_speed(&hc->device_manager, target.address);
         usb_log_debug("Control READ %d:%d %zu(%zu).\n",
             target.address, target.endpoint, size, max_packet_size);
+        uhci_hc_t *hc = fun_to_uhci_hc(fun);
+        assert(hc);
+        usb_speed_t speed = device_keeper_speed(&hc->device_manager, target.address);
+        usb_log_debug("Control READ(%d) %d:%d %zu(%zu).\n",
+            speed, target.address, target.endpoint, size, max_packet_size);
         batch_t *batch = batch_get(fun, target, USB_TRANSFER_CONTROL,
             max_packet_size, speed, data, size, setup_data, setup_size, callback,
             NULL, arg);
+            NULL, arg, &hc->device_manager);
         if (!batch)
                 return ENOMEM;
         batch_control_read(batch);
+        return EOK;
+}
+/*----------------------------------------------------------------------------*/
+usbhc_iface_t uhci_iface = {
+        const int ret = uhci_hc_schedule(hc, batch);
+        if (ret != EOK) {
+                batch_dispose(batch);
+                return ret;
+        }
+        return EOK;
+}
+/*----------------------------------------------------------------------------*/
+usbhc_iface_t uhci_hc_iface = {
         .reserve_default_address = reserve_default_address,
         .release_default_address = release_default_address,
 …
         .interrupt_in = interrupt_in,
+        .bulk_in = bulk_in,
+        .bulk_out = bulk_out,
         .control_read = control_read,
         .control_write = control_write,

uspace/drv/uhci-hcd/iface.h

-              r3e7b7cd
+              r72af8da
  */
 /** @addtogroup usb
+/** @addtogroup drvusbuhcihc
  * @{
  */
 /** @file
  * @brief UHCI driver
+ * @brief UHCI driver iface
  */
 #ifndef DRV_UHCI_IFACE_H
 …
 #include <usbhc_iface.h>
 extern usbhc_iface_t uhci_iface;
+extern usbhc_iface_t uhci_hc_iface;
 #endif

uspace/drv/uhci-hcd/main.c

-              r3e7b7cd
+              r72af8da
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 /** @addtogroup usb
+/** @addtogroup drvusbuhcihc
  * @{
  */
 /** @file
  * @brief UHCI driver
+ * @brief UHCI driver initialization
  */
 #include <ddf/driver.h>
-#include <ddf/interrupt.h>
-#include <device/hw_res.h>
 #include <errno.h>
 #include <str_error.h>
-#include <usb_iface.h>
 #include <usb/ddfiface.h>
 #include <usb/debug.h>
 #include "iface.h"
-#include "pci.h"
-#include "root_hub.h"
 #include "uhci.h"
 …
 };
 /*----------------------------------------------------------------------------*/
+static void irq_handler(ddf_dev_t *dev, ipc_callid_t iid, ipc_call_t *call)
+/** Initialize a new ddf driver instance for uhci hc and hub.
+ *
+ * @param[in] device DDF instance of the device to initialize.
+ * @return Error code.
+ */
+int uhci_add_device(ddf_dev_t *device)
+{
+        assert(dev);
+        uhci_t *hc = dev_to_uhci(dev);
+        uint16_t status = IPC_GET_ARG1(*call);
+        assert(hc);
+        uhci_interrupt(hc, status);
+        usb_log_info("uhci_add_device() called\n");
+        assert(device);
+        uhci_t *uhci = malloc(sizeof(uhci_t));
+        if (uhci == NULL) {
+                usb_log_error("Failed to allocate UHCI driver.\n");
+                return ENOMEM;
+        }
+        int ret = uhci_init(uhci, device);
+        if (ret != EOK) {
+                usb_log_error("Failed to initialzie UHCI driver.\n");
+                return ret;
+        }
+        device->driver_data = uhci;
+        return EOK;
+}
 /*----------------------------------------------------------------------------*/
+static int uhci_add_device(ddf_dev_t *device)
+{
+        assert(device);
+        uhci_t *hcd = NULL;
+#define CHECK_RET_FREE_HC_RETURN(ret, message...) \
+if (ret != EOK) { \
+        usb_log_error(message); \
+        if (hcd != NULL) \
+                free(hcd); \
+        return ret; \
+}
+        usb_log_info("uhci_add_device() called\n");
+        uintptr_t io_reg_base = 0;
+        size_t io_reg_size = 0;
+        int irq = 0;
+        int ret =
+            pci_get_my_registers(device, &io_reg_base, &io_reg_size, &irq);
+        CHECK_RET_FREE_HC_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_disable_legacy(device);
+        CHECK_RET_FREE_HC_RETURN(ret,
+            "Failed(%d) disable legacy USB: %s.\n", ret, str_error(ret));
+#if 0
+        ret = pci_enable_interrupts(device);
+        if (ret != EOK) {
+                usb_log_warning(
+                    "Failed(%d) to enable interrupts, fall back to polling.\n",
+                    ret);
+        }
+#endif
+        hcd = malloc(sizeof(uhci_t));
+        ret = (hcd != NULL) ? EOK : ENOMEM;
+        CHECK_RET_FREE_HC_RETURN(ret,
+            "Failed(%d) to allocate memory for uhci hcd.\n", ret);
+        ret = uhci_init(hcd, device, (void*)io_reg_base, io_reg_size);
+        CHECK_RET_FREE_HC_RETURN(ret, "Failed(%d) to init uhci-hcd.\n",
+            ret);
+#undef CHECK_RET_FREE_HC_RETURN
+        /*
+         * We might free hcd, but that does not matter since no one
+         * else would access driver_data anyway.
+         */
+        device->driver_data = hcd;
+        ddf_fun_t *rh = NULL;
+#define CHECK_RET_FINI_FREE_RETURN(ret, message...) \
+if (ret != EOK) { \
+        usb_log_error(message); \
+        if (hcd != NULL) {\
+                uhci_fini(hcd); \
+                free(hcd); \
+        } \
+        if (rh != NULL) \
+                free(rh); \
+        return ret; \
+}
+        /* It does no harm if we register this on polling */
+        ret = register_interrupt_handler(device, irq, irq_handler,
+            &hcd->interrupt_code);
+        CHECK_RET_FINI_FREE_RETURN(ret,
+            "Failed(%d) to register interrupt handler.\n", ret);
+        ret = setup_root_hub(&rh, device);
+        CHECK_RET_FINI_FREE_RETURN(ret,
+            "Failed(%d) to setup UHCI root hub.\n", ret);
+        rh->driver_data = hcd->ddf_instance;
+        ret = ddf_fun_bind(rh);
+        CHECK_RET_FINI_FREE_RETURN(ret,
+            "Failed(%d) to register UHCI root hub.\n", ret);
+        return EOK;
+#undef CHECK_RET_FINI_FREE_RETURN
+}
+/*----------------------------------------------------------------------------*/
+/** Initialize global driver structures (NONE).
+ *
+ * @param[in] argc Nmber of arguments in argv vector (ignored).
+ * @param[in] argv Cmdline argument vector (ignored).
+ * @return Error code.
+ *
+ * Driver debug level is set here.
+ */
 int main(int argc, char *argv[])
+{
         sleep(3);
+        sleep(3); /* TODO: remove in final version */
         usb_log_enable(USB_LOG_LEVEL_DEBUG, NAME);

uspace/drv/uhci-hcd/pci.c

-              r3e7b7cd
+              r72af8da
  */
 /**
  * @addtogroup drvusbuhci
+ * @addtogroup drvusbuhcihc
  * @{
  */
 …
         int rc;
         hw_resource_list_t hw_resources;
         rc = hw_res_get_resource_list(parent_phone, &hw_resources);
 …
         for (i = 0; i < hw_resources.count; i++) {
                 hw_resource_t *res = &hw_resources.resources[i];
+                switch (res->type) {
+                        case INTERRUPT:
+                                irq = res->res.interrupt.irq;
+                                irq_found = true;
+                                usb_log_debug2("Found interrupt: %d.\n", irq);
+                                break;
+                        case IO_RANGE:
+                                io_address = res->res.io_range.address;
+                                io_size = res->res.io_range.size;
+                                usb_log_debug2("Found io: %llx %zu.\n",
+                                    res->res.io_range.address, res->res.io_range.size);
+                                io_found = true;
+                                break;
+                        default:
+                                break;
+                switch (res->type)
+                {
+                case INTERRUPT:
+                        irq = res->res.interrupt.irq;
+                        irq_found = true;
+                        usb_log_debug2("Found interrupt: %d.\n", irq);
+                        break;
+                case IO_RANGE:
+                        io_address = res->res.io_range.address;
+                        io_size = res->res.io_range.size;
+                        usb_log_debug2("Found io: %llx %zu.\n",
+                            res->res.io_range.address, res->res.io_range.size);
+                        io_found = true;
+                default:
+                        break;
+                }
+        }
+        if (!io_found) {
+                rc = ENOENT;
+                goto leave;
+        }
+        if (!irq_found) {
+        if (!io_found || !irq_found) {
                 rc = ENOENT;
                 goto leave;
 …
+}
 /*----------------------------------------------------------------------------*/
+/** Call the PCI driver with a request to enable interrupts
+ *
+ * @param[in] device Device asking for interrupts
+ * @return Error code.
+ */
 int pci_enable_interrupts(ddf_dev_t *device)
+{
 …
+}
 /*----------------------------------------------------------------------------*/
+/** Call the PCI driver with a request to clear legacy support register
+ *
+ * @param[in] device Device asking to disable interrupts
+ * @return Error code.
+ */
 int pci_disable_legacy(ddf_dev_t *device)
+{
         assert(device);
         int parent_phone = devman_parent_device_connect(device->handle,
                 IPC_FLAG_BLOCKING);
+        int parent_phone =
+            devman_parent_device_connect(device->handle, IPC_FLAG_BLOCKING);
         if (parent_phone < 0) {
                 return parent_phone;
 …
         sysarg_t value = 0x8f00;
   int rc = async_req_3_0(parent_phone, DEV_IFACE_ID(PCI_DEV_IFACE),
+        int rc = async_req_3_0(parent_phone, DEV_IFACE_ID(PCI_DEV_IFACE),
             IPC_M_CONFIG_SPACE_WRITE_16, address, value);
         async_hangup(parent_phone);
   return rc;
+        return rc;
+}
 /*----------------------------------------------------------------------------*/

uspace/drv/uhci-hcd/pci.h

-              r3e7b7cd
+              r72af8da
  */
 /** @addtogroup drvusbuhci
+/** @addtogroup drvusbuhcihc
  * @{
  */
 /** @file
  * @brief UHCI driver
+ * @brief UHCI driver PCI helper functions
  */
 #ifndef DRV_UHCI_PCI_H

uspace/drv/uhci-hcd/transfer_list.c

-              r3e7b7cd
+              r72af8da
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 /** @addtogroup usb
+/** @addtogroup drvusbuhcihc
  * @{
  */
 /** @file
  * @brief UHCI driver
+ * @brief UHCI driver transfer list implementation
  */
 #include <errno.h>
 #include <usb/debug.h>
 #include "transfer_list.h"
+static void transfer_list_remove_batch(
+    transfer_list_t *instance, batch_t *batch);
+/*----------------------------------------------------------------------------*/
+/** Initialize transfer list structures.
+ *
+ * @param[in] instance Memory place to use.
+ * @param[in] name Name of the new list.
+ * @return Error code
+ *
+ * Allocates memory for internal qh_t structure.
+ */
 int transfer_list_init(transfer_list_t *instance, const char *name)
+{
         assert(instance);
-        instance->next = NULL;
         instance->name = name;
         instance->queue_head = queue_head_get();
+        instance->queue_head = malloc32(sizeof(qh_t));
         if (!instance->queue_head) {
                 usb_log_error("Failed to allocate queue head.\n");
                 return ENOMEM;
+        }
         instance->queue_head_pa = (uintptr_t)addr_to_phys(instance->queue_head);
         queue_head_init(instance->queue_head);
+        instance->queue_head_pa = addr_to_phys(instance->queue_head);
+        qh_init(instance->queue_head);
         list_initialize(&instance->batch_list);
         fibril_mutex_initialize(&instance->guard);
 …
+}
 /*----------------------------------------------------------------------------*/
+/** Set the next list in transfer list chain.
+ *
+ * @param[in] instance List to lead.
+ * @param[in] next List to append.
+ * @return Error code
+ *
+ * Does not check whether this replaces an existing list .
+ */
 void transfer_list_set_next(transfer_list_t *instance, transfer_list_t *next)
+{
 …
         if (!instance->queue_head)
                 return;
+        queue_head_append_qh(instance->queue_head, next->queue_head_pa);
+        instance->queue_head->element = instance->queue_head->next_queue;
+}
+/*----------------------------------------------------------------------------*/
+        /* Set both next and element to point to the same QH */
+        qh_set_next_qh(instance->queue_head, next->queue_head_pa);
+        qh_set_element_qh(instance->queue_head, next->queue_head_pa);
+}
+/*----------------------------------------------------------------------------*/
+/** Submit transfer batch to the list and queue.
+ *
+ * @param[in] instance List to use.
+ * @param[in] batch Transfer batch to submit.
+ * @return Error code
+ *
+ * The batch is added to the end of the list and queue.
+ */
 void transfer_list_add_batch(transfer_list_t *instance, batch_t *batch)
+{
         assert(instance);
         assert(batch);
         usb_log_debug2("Adding batch(%p) to queue %s.\n", batch, instance->name);
         uint32_t pa = (uintptr_t)addr_to_phys(batch->qh);
+        usb_log_debug2("Queue %s: Adding batch(%p).\n", instance->name, batch);
+        const uint32_t pa = addr_to_phys(batch->qh);
         assert((pa & LINK_POINTER_ADDRESS_MASK) == pa);
+        pa |= LINK_POINTER_QUEUE_HEAD_FLAG;
+        batch->qh->next_queue = instance->queue_head->next_queue;
+        /* New batch will be added to the end of the current list
+         * so set the link accordingly */
+        qh_set_next_qh(batch->qh, instance->queue_head->next);
         fibril_mutex_lock(&instance->guard);
+        if (instance->queue_head->element == instance->queue_head->next_queue) {
+                /* there is nothing scheduled */
+                list_append(&batch->link, &instance->batch_list);
+                instance->queue_head->element = pa;
+                usb_log_debug("Batch(%p) added to queue %s first.\n",
+                        batch, instance->name);
+                fibril_mutex_unlock(&instance->guard);
+                return;
+        }
+        /* now we can be sure that there is someting scheduled */
+        assert(!list_empty(&instance->batch_list));
+        /* Add to the hardware queue. */
+        if (list_empty(&instance->batch_list)) {
+                /* There is nothing scheduled */
+                qh_t *qh = instance->queue_head;
+                assert(qh->element == qh->next);
+                qh_set_element_qh(qh, pa);
+        } else {
+                /* There is something scheduled */
+                batch_t *last = list_get_instance(
+                    instance->batch_list.prev, batch_t, link);
+                qh_set_next_qh(last->qh, pa);
+        }
+        /* Add to the driver list */
+        list_append(&batch->link, &instance->batch_list);
         batch_t *first = list_get_instance(
+                  instance->batch_list.next, batch_t, link);
+        batch_t *last = list_get_instance(
+            instance->batch_list.prev, batch_t, link);
+        queue_head_append_qh(last->qh, pa);
+        list_append(&batch->link, &instance->batch_list);
+        usb_log_debug("Batch(%p) added to queue %s last, first is %p.\n",
+                batch, instance->name, first );
+            instance->batch_list.next, batch_t, link);
+        usb_log_debug("Batch(%p) added to queue %s, first is %p.\n",
+                batch, instance->name, first);
         fibril_mutex_unlock(&instance->guard);
+}
 /*----------------------------------------------------------------------------*/
+static void transfer_list_remove_batch(
+    transfer_list_t *instance, batch_t *batch)
+/** Remove a transfer batch from the list and queue.
+ *
+ * @param[in] instance List to use.
+ * @param[in] batch Transfer batch to remove.
+ * @return Error code
+ *
+ * Does not lock the transfer list, caller is responsible for that.
+ */
+void transfer_list_remove_batch(transfer_list_t *instance, batch_t *batch)
+{
         assert(instance);
 …
         assert(instance->queue_head);
         assert(batch->qh);
+        usb_log_debug2("Removing batch(%p) from queue %s.\n", batch, instance->name);
+        /* I'm the first one here */
+        usb_log_debug2(
+            "Queue %s: removing batch(%p).\n", instance->name, batch);
+        const char * pos = NULL;
+        /* Remove from the hardware queue */
         if (batch->link.prev == &instance->batch_list) {
                 usb_log_debug("Batch(%p) removed (FIRST) from queue %s, next element %x.\n",
                         batch, instance->name, batch->qh->next_queue);
                 instance->queue_head->element = batch->qh->next_queue;
+                /* I'm the first one here */
+                qh_set_element_qh(instance->queue_head, batch->qh->next);
+                pos = "FIRST";
         } else {
+                usb_log_debug("Batch(%p) removed (NOT FIRST) from queue, next element %x.\n",
+                        batch, instance->name, batch->qh->next_queue);
+                batch_t *prev = list_get_instance(batch->link.prev, batch_t, link);
+                prev->qh->next_queue = batch->qh->next_queue;
+        }
+                batch_t *prev =
+                    list_get_instance(batch->link.prev, batch_t, link);
+                qh_set_next_qh(prev->qh, batch->qh->next);
+                pos = "NOT FIRST";
+        }
+        /* Remove from the driver list */
         list_remove(&batch->link);
+}
+/*----------------------------------------------------------------------------*/
+        usb_log_debug("Batch(%p) removed (%s) from %s, next element %x.\n",
+            batch, pos, instance->name, batch->qh->next);
+}
+/*----------------------------------------------------------------------------*/
+/** Check list for finished batches.
+ *
+ * @param[in] instance List to use.
+ * @return Error code
+ *
+ * Creates a local list of finished batches and calls next_step on each and
+ * every one. This is safer because next_step may theoretically access
+ * this transfer list leading to the deadlock if its done inline.
+ */
 void transfer_list_remove_finished(transfer_list_t *instance)
+{
 …
                 if (batch_is_complete(batch)) {
+                        /* Save for post-processing */
                         transfer_list_remove_batch(instance, batch);
                         list_append(current, &done);

uspace/drv/uhci-hcd/transfer_list.h

-              r3e7b7cd
+              r72af8da
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 /** @addtogroup usb
+/** @addtogroup drvusbuhcihc
  * @{
  */
 /** @file
  * @brief UHCI driver
+ * @brief UHCI driver transfer list structure
  */
 #ifndef DRV_UHCI_TRANSFER_LIST_H
 …
+{
         fibril_mutex_t guard;
         queue_head_t *queue_head;
+        qh_t *queue_head;
         uint32_t queue_head_pa;
-        struct transfer_list *next;
         const char *name;
         link_t batch_list;
 } transfer_list_t;
+/** Dispose transfer list structures.
+ *
+ * @param[in] instance Memory place to use.
+ *
+ * Frees memory for internal qh_t structure.
+ */
+static inline void transfer_list_fini(transfer_list_t *instance)
+{
+        assert(instance);
+        free32(instance->queue_head);
+}
 int transfer_list_init(transfer_list_t *instance, const char *name);
 …
 void transfer_list_set_next(transfer_list_t *instance, transfer_list_t *next);
-static inline void transfer_list_fini(transfer_list_t *instance)
+{
-        assert(instance);
-        queue_head_dispose(instance->queue_head);
+}
 void transfer_list_remove_finished(transfer_list_t *instance);

uspace/drv/uhci-hcd/uhci.c

-              r3e7b7cd
+              r72af8da
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
+/** @addtogroup usb
+/** @addtogroup drvusbuhci
  * @{
  */
 …
 #include <errno.h>
 #include <str_error.h>
 #include <adt/list.h>
 #include <libarch/ddi.h>
+#include <ddf/interrupt.h>
+#include <usb_iface.h>
+#include <usb/ddfiface.h>
 #include <usb/debug.h>
-#include <usb/usb.h>
-#include <usb/ddfiface.h>
-#include <usb_iface.h>
 #include "uhci.h"
 #include "iface.h"
+static irq_cmd_t uhci_cmds[] = {
+        {
+                .cmd = CMD_PIO_READ_16,
+                .addr = NULL, /* patched for every instance */
+                .dstarg = 1
+        },
+        {
+                .cmd = CMD_PIO_WRITE_16,
+                .addr = NULL, /* pathed for every instance */
+                .value = 0x1f
+        },
+        {
+                .cmd = CMD_ACCEPT
+        }
+};
+static int usb_iface_get_address(ddf_fun_t *fun, devman_handle_t handle,
+    usb_address_t *address)
+#include "pci.h"
+/** IRQ handling callback, identifies device
+ *
+ * @param[in] dev DDF instance of the device to use.
+ * @param[in] iid (Unused).
+ * @param[in] call Pointer to the call that represents interrupt.
+ */
+static void irq_handler(ddf_dev_t *dev, ipc_callid_t iid, ipc_call_t *call)
+{
+        assert(dev);
+        uhci_hc_t *hc = &((uhci_t*)dev->driver_data)->hc;
+        uint16_t status = IPC_GET_ARG1(*call);
+        assert(hc);
+        uhci_hc_interrupt(hc, status);
+}
+/*----------------------------------------------------------------------------*/
+/** Get address of the device identified by handle.
+ *
+ * @param[in] dev DDF instance of the device to use.
+ * @param[in] iid (Unused).
+ * @param[in] call Pointer to the call that represents interrupt.
+ */
+static int usb_iface_get_address(
+    ddf_fun_t *fun, devman_handle_t handle, usb_address_t *address)
+{
         assert(fun);
+        uhci_t *hc = fun_to_uhci(fun);
+        assert(hc);
+        usb_address_t addr = device_keeper_find(&hc->device_manager,
+            handle);
+        device_keeper_t *manager = &((uhci_t*)fun->dev->driver_data)->hc.device_manager;
+        usb_address_t addr = device_keeper_find(manager, handle);
         if (addr < 0) {
                 return addr;
 …
+}
 /*----------------------------------------------------------------------------*/
+static usb_iface_t hc_usb_iface = {
+        .get_hc_handle = usb_iface_get_hc_handle_hc_impl,
+/** Gets handle of the respective hc (this or parent device).
+ *
+ * @param[in] root_hub_fun Root hub function seeking hc handle.
+ * @param[out] handle Place to write the handle.
+ * @return Error code.
+ */
+static int usb_iface_get_hc_handle(
+    ddf_fun_t *fun, devman_handle_t *handle)
+{
+        assert(handle);
+        ddf_fun_t *hc_fun = ((uhci_t*)fun->dev->driver_data)->hc_fun;
+        assert(hc_fun != NULL);
+        *handle = hc_fun->handle;
+        return EOK;
+}
+/*----------------------------------------------------------------------------*/
+/** This iface is generic for both RH and HC. */
+static usb_iface_t usb_iface = {
+        .get_hc_handle = usb_iface_get_hc_handle,
         .get_address = usb_iface_get_address
 };
 /*----------------------------------------------------------------------------*/
+static ddf_dev_ops_t uhci_ops = {
+        .interfaces[USB_DEV_IFACE] = &hc_usb_iface,
+        .interfaces[USBHC_DEV_IFACE] = &uhci_iface,
+};
+/*----------------------------------------------------------------------------*/
+static int uhci_init_transfer_lists(uhci_t *instance);
+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, ddf_dev_t *dev, void *regs, size_t reg_size)
+{
+        assert(reg_size >= sizeof(regs_t));
+        int ret;
+static ddf_dev_ops_t uhci_hc_ops = {
+        .interfaces[USB_DEV_IFACE] = &usb_iface,
+        .interfaces[USBHC_DEV_IFACE] = &uhci_hc_iface, /* see iface.h/c */
+};
+/*----------------------------------------------------------------------------*/
+/** Get root hub hw resources (I/O registers).
+ *
+ * @param[in] fun Root hub function.
+ * @return Pointer to the resource list used by the root hub.
+ */
+static hw_resource_list_t *get_resource_list(ddf_fun_t *fun)
+{
+        assert(fun);
+        return &((uhci_rh_t*)fun->driver_data)->resource_list;
+}
+/*----------------------------------------------------------------------------*/
+static hw_res_ops_t hw_res_iface = {
+        .get_resource_list = get_resource_list,
+        .enable_interrupt = NULL
+};
+/*----------------------------------------------------------------------------*/
+static ddf_dev_ops_t uhci_rh_ops = {
+        .interfaces[USB_DEV_IFACE] = &usb_iface,
+        .interfaces[HW_RES_DEV_IFACE] = &hw_res_iface
+};
+/*----------------------------------------------------------------------------*/
+/** Initialize hc and rh ddf structures and their respective drivers.
+ *
+ * @param[in] instance UHCI structure to use.
+ * @param[in] device DDF instance of the device to use.
+ *
+ * This function does all the preparatory work for hc and rh drivers:
+ *  - gets device hw resources
+ *  - disables UHCI legacy support
+ *  - asks for interrupt
+ *  - registers interrupt handler
+ */
+int uhci_init(uhci_t *instance, ddf_dev_t *device)
+{
+        assert(instance);
+        instance->hc_fun = NULL;
+        instance->rh_fun = NULL;
 #define CHECK_RET_DEST_FUN_RETURN(ret, message...) \
+        if (ret != EOK) { \
+                usb_log_error(message); \
+                if (instance->ddf_instance) \
+                        ddf_fun_destroy(instance->ddf_instance); \
+                return ret; \
+        } else (void) 0
+        /* Create UHCI function. */
+        instance->ddf_instance = ddf_fun_create(dev, fun_exposed, "uhci");
+        ret = (instance->ddf_instance == NULL) ? ENOMEM : EOK;
+        CHECK_RET_DEST_FUN_RETURN(ret,
+            "Failed to create UHCI device function.\n");
+        instance->ddf_instance->ops = &uhci_ops;
+        instance->ddf_instance->driver_data = instance;
+        ret = ddf_fun_bind(instance->ddf_instance);
+if (ret != EOK) { \
+        usb_log_error(message); \
+        if (instance->hc_fun) \
+                ddf_fun_destroy(instance->hc_fun); \
+        if (instance->rh_fun) \
+                ddf_fun_destroy(instance->rh_fun); \
+        return ret; \
+}
+        uintptr_t io_reg_base = 0;
+        size_t io_reg_size = 0;
+        int irq = 0;
+        int ret =
+            pci_get_my_registers(device, &io_reg_base, &io_reg_size, &irq);
+        CHECK_RET_DEST_FUN_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_disable_legacy(device);
+        CHECK_RET_DEST_FUN_RETURN(ret,
+            "Failed(%d) to disable legacy USB: %s.\n", ret, str_error(ret));
+        bool interrupts = false;
+        ret = pci_enable_interrupts(device);
+        if (ret != EOK) {
+                usb_log_warning(
+                    "Failed(%d) to enable interrupts, fall back to polling.\n",
+                    ret);
+        } else {
+                usb_log_debug("Hw interrupts enabled.\n");
+                interrupts = true;
+        }
+        instance->hc_fun = ddf_fun_create(device, fun_exposed, "uhci-hc");
+        ret = (instance->hc_fun == NULL) ? ENOMEM : EOK;
+        CHECK_RET_DEST_FUN_RETURN(ret,
+            "Failed(%d) to create HC function.\n", ret);
+        ret = uhci_hc_init(&instance->hc, instance->hc_fun,
+            (void*)io_reg_base, io_reg_size, interrupts);
+        CHECK_RET_DEST_FUN_RETURN(ret, "Failed(%d) to init uhci-hcd.\n", ret);
+        instance->hc_fun->ops = &uhci_hc_ops;
+        instance->hc_fun->driver_data = &instance->hc;
+        ret = ddf_fun_bind(instance->hc_fun);
         CHECK_RET_DEST_FUN_RETURN(ret,
             "Failed(%d) to bind UHCI device function: %s.\n",
             ret, str_error(ret));
+        /* allow access to hc control registers */
+        regs_t *io;
+        ret = pio_enable(regs, reg_size, (void**)&io);
+        CHECK_RET_DEST_FUN_RETURN(ret,
+            "Failed(%d) to gain access to registers at %p: %s.\n",
+            ret, str_error(ret), io);
+        instance->registers = io;
+        usb_log_debug("Device registers at %p(%u) accessible.\n",
+            io, reg_size);
+        ret = uhci_init_mem_structures(instance);
+        CHECK_RET_DEST_FUN_RETURN(ret,
+            "Failed to initialize UHCI 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);
+        usb_log_info("Started UHCI driver.\n");
+#undef CHECK_RET_HC_RETURN
+#define CHECK_RET_FINI_RETURN(ret, message...) \
+if (ret != EOK) { \
+        usb_log_error(message); \
+        if (instance->hc_fun) \
+                ddf_fun_destroy(instance->hc_fun); \
+        if (instance->rh_fun) \
+                ddf_fun_destroy(instance->rh_fun); \
+        uhci_hc_fini(&instance->hc); \
+        return ret; \
+}
+        /* It does no harm if we register this on polling */
+        ret = register_interrupt_handler(device, irq, irq_handler,
+            &instance->hc.interrupt_code);
+        CHECK_RET_FINI_RETURN(ret,
+            "Failed(%d) to register interrupt handler.\n", ret);
+        instance->rh_fun = ddf_fun_create(device, fun_inner, "uhci-rh");
+        ret = (instance->rh_fun == NULL) ? ENOMEM : EOK;
+        CHECK_RET_FINI_RETURN(ret,
+            "Failed(%d) to create root hub function.\n", ret);
+        ret = uhci_rh_init(&instance->rh, instance->rh_fun,
+            (uintptr_t)instance->hc.registers + 0x10, 4);
+        CHECK_RET_FINI_RETURN(ret,
+            "Failed(%d) to setup UHCI root hub.\n", ret);
+        instance->rh_fun->ops = &uhci_rh_ops;
+        instance->rh_fun->driver_data = &instance->rh;
+        ret = ddf_fun_bind(instance->rh_fun);
+        CHECK_RET_FINI_RETURN(ret,
+            "Failed(%d) to register UHCI root hub.\n", ret);
         return EOK;
+#undef CHECK_RET_DEST_FUN_RETURN
+}
+/*----------------------------------------------------------------------------*/
+void uhci_init_hw(uhci_t *instance)
+{
+        assert(instance);
+        /* reset everything, who knows what touched it before us */
+        pio_write_16(&instance->registers->usbcmd, UHCI_CMD_GLOBAL_RESET);
+        async_usleep(10000); /* 10ms according to USB spec */
+        pio_write_16(&instance->registers->usbcmd, 0);
+        /* reset hc, all states and counters */
+        pio_write_16(&instance->registers->usbcmd, UHCI_CMD_HCRESET);
+        while ((pio_read_16(&instance->registers->usbcmd) & UHCI_CMD_HCRESET) != 0)
+                { async_usleep(10); }
+        /* 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);
+}
+/*----------------------------------------------------------------------------*/
+int uhci_init_mem_structures(uhci_t *instance)
+{
+        assert(instance);
+#define CHECK_RET_DEST_CMDS_RETURN(ret, message...) \
+        if (ret != EOK) { \
+                usb_log_error(message); \
+                if (instance->interrupt_code.cmds != NULL) \
+                        free(instance->interrupt_code.cmds); \
+                return ret; \
+        } else (void) 0
+        /* init interrupt code */
+        instance->interrupt_code.cmds = malloc(sizeof(uhci_cmds));
+        int ret = (instance->interrupt_code.cmds == NULL) ? ENOMEM : EOK;
+        CHECK_RET_DEST_CMDS_RETURN(ret, "Failed to allocate interrupt cmds space.\n");
+        {
+                irq_cmd_t *interrupt_commands = instance->interrupt_code.cmds;
+                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.cmdcount =
+                    sizeof(uhci_cmds) / sizeof(irq_cmd_t);
+        }
+        /* init transfer lists */
+        ret = uhci_init_transfer_lists(instance);
+        CHECK_RET_DEST_CMDS_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_DEST_CMDS_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 */
+        const uint32_t queue =
+          instance->transfers_interrupt.queue_head_pa
+          | LINK_POINTER_QUEUE_HEAD_FLAG;
+        unsigned i = 0;
+        for(; i < UHCI_FRAME_LIST_COUNT; ++i) {
+                instance->frame_list[i] = queue;
+        }
+        /* init address keeper(libusb) */
+        device_keeper_init(&instance->device_manager);
+        usb_log_debug("Initialized device manager.\n");
+        return EOK;
+#undef CHECK_RET_DEST_CMDS_RETURN
+}
+/*----------------------------------------------------------------------------*/
+int uhci_init_transfer_lists(uhci_t *instance)
+{
+        assert(instance);
+#define CHECK_RET_CLEAR_RETURN(ret, message...) \
+        if (ret != EOK) { \
+                usb_log_error(message); \
+                transfer_list_fini(&instance->transfers_bulk_full); \
+                transfer_list_fini(&instance->transfers_control_full); \
+                transfer_list_fini(&instance->transfers_control_slow); \
+                transfer_list_fini(&instance->transfers_interrupt); \
+                return ret; \
+        } else (void) 0
+        /* initialize TODO: check errors */
+        int ret;
+        ret = transfer_list_init(&instance->transfers_bulk_full, "BULK_FULL");
+        CHECK_RET_CLEAR_RETURN(ret, "Failed to init BULK list.");
+        ret = transfer_list_init(&instance->transfers_control_full, "CONTROL_FULL");
+        CHECK_RET_CLEAR_RETURN(ret, "Failed to init CONTROL FULL list.");
+        ret = transfer_list_init(&instance->transfers_control_slow, "CONTROL_SLOW");
+        CHECK_RET_CLEAR_RETURN(ret, "Failed to init CONTROL SLOW list.");
+        ret = transfer_list_init(&instance->transfers_interrupt, "INTERRUPT");
+        CHECK_RET_CLEAR_RETURN(ret, "Failed to init INTERRUPT list.");
+        transfer_list_set_next(&instance->transfers_control_full,
+                &instance->transfers_bulk_full);
+        transfer_list_set_next(&instance->transfers_control_slow,
+                &instance->transfers_control_full);
+        transfer_list_set_next(&instance->transfers_interrupt,
+                &instance->transfers_control_slow);
+        /*FSBR*/
+#ifdef FSBR
+        transfer_list_set_next(&instance->transfers_bulk_full,
+                &instance->transfers_control_full);
+#endif
+        instance->transfers[0][USB_TRANSFER_INTERRUPT] =
+          &instance->transfers_interrupt;
+        instance->transfers[1][USB_TRANSFER_INTERRUPT] =
+          &instance->transfers_interrupt;
+        instance->transfers[0][USB_TRANSFER_CONTROL] =
+          &instance->transfers_control_full;
+        instance->transfers[1][USB_TRANSFER_CONTROL] =
+          &instance->transfers_control_slow;
+        instance->transfers[0][USB_TRANSFER_BULK] =
+          &instance->transfers_bulk_full;
+        return EOK;
+#undef CHECK_RET_CLEAR_RETURN
+}
+/*----------------------------------------------------------------------------*/
+int uhci_schedule(uhci_t *instance, batch_t *batch)
+{
+        assert(instance);
+        assert(batch);
+        const int low_speed = (batch->speed == USB_SPEED_LOW);
+        if (!allowed_usb_packet(
+            low_speed, batch->transfer_type, batch->max_packet_size)) {
+                usb_log_warning("Invalid USB packet specified %s SPEED %d %zu.\n",
+                    low_speed ? "LOW" : "FULL" , batch->transfer_type,
+                    batch->max_packet_size);
+                return ENOTSUP;
+        }
+        /* TODO: check available bandwith here */
+        transfer_list_t *list =
+            instance->transfers[low_speed][batch->transfer_type];
+        assert(list);
+        transfer_list_add_batch(list, batch);
+        return EOK;
+}
+/*----------------------------------------------------------------------------*/
+void uhci_interrupt(uhci_t *instance, uint16_t status)
+{
+        assert(instance);
+        transfer_list_remove_finished(&instance->transfers_interrupt);
+        transfer_list_remove_finished(&instance->transfers_control_slow);
+        transfer_list_remove_finished(&instance->transfers_control_full);
+        transfer_list_remove_finished(&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) {
+                uint16_t status = pio_read_16(&instance->registers->usbsts);
+                if (status != 0)
+                        usb_log_debug2("UHCI status: %x.\n", status);
+                status |= 1;
+                uhci_interrupt(instance, status);
+                pio_write_16(&instance->registers->usbsts, 0x1f);
+                async_usleep(UHCI_CLEANER_TIMEOUT * 5);
+        }
+        return EOK;
+}
+/*---------------------------------------------------------------------------*/
+int uhci_debug_checker(void *arg)
+{
+        uhci_t *instance = (uhci_t*)arg;
+        assert(instance);
+#define QH(queue) \
+        instance->transfers_##queue.queue_head
+        while (1) {
+                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);
+                if (((cmd & UHCI_CMD_RUN_STOP) != 1) || (sts != 0)) {
+                        usb_log_debug2("Command: %X Status: %X Intr: %x\n",
+                            cmd, sts, intr);
+                }
+                uintptr_t frame_list =
+                    pio_read_32(&instance->registers->flbaseadd) & ~0xfff;
+                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));
+                }
+                int frnum = pio_read_16(&instance->registers->frnum) & 0x3ff;
+                usb_log_debug2("Framelist item: %d \n", frnum );
+                uintptr_t expected_pa = instance->frame_list[frnum] & (~0xf);
+                uintptr_t real_pa = addr_to_phys(QH(interrupt));
+                if (expected_pa != real_pa) {
+                        usb_log_debug("Interrupt QH: %p vs. %p.\n",
+                            expected_pa, real_pa);
+                }
+                expected_pa = QH(interrupt)->next_queue & (~0xf);
+                real_pa = addr_to_phys(QH(control_slow));
+                if (expected_pa != real_pa) {
+                        usb_log_debug("Control Slow QH: %p vs. %p.\n",
+                            expected_pa, real_pa);
+                }
+                expected_pa = QH(control_slow)->next_queue & (~0xf);
+                real_pa = addr_to_phys(QH(control_full));
+                if (expected_pa != real_pa) {
+                        usb_log_debug("Control Full QH: %p vs. %p.\n",
+                            expected_pa, real_pa);
+                }
+                expected_pa = QH(control_full)->next_queue & (~0xf);
+                real_pa = addr_to_phys(QH(bulk_full));
+                if (expected_pa != real_pa ) {
+                        usb_log_debug("Bulk QH: %p vs. %p.\n",
+                            expected_pa, real_pa);
+                }
+                async_usleep(UHCI_DEBUGER_TIMEOUT);
+        }
+        return 0;
+#undef QH
+}
+/*----------------------------------------------------------------------------*/
+bool allowed_usb_packet(
+    bool low_speed, usb_transfer_type_t transfer, size_t size)
+{
+        /* see USB specification chapter 5.5-5.8 for magic numbers used here */
+        switch(transfer)
+        {
+        case USB_TRANSFER_ISOCHRONOUS:
+                return (!low_speed && size < 1024);
+        case USB_TRANSFER_INTERRUPT:
+                return size <= (low_speed ? 8 : 64);
+        case USB_TRANSFER_CONTROL: /* device specifies its own max size */
+                return (size <= (low_speed ? 8 : 64));
+        case USB_TRANSFER_BULK: /* device specifies its own max size */
+                return (!low_speed && size <= 64);
+        }
+        return false;
+#undef CHECK_RET_FINI_RETURN
+}
 /**

uspace/drv/uhci-hcd/uhci.h

-              r3e7b7cd
+              r72af8da
 /*
  * Copyright (c) 2010 Jan Vesely
+ * Copyright (c) 2011 Jan Vesely
  * All rights reserved.
+ *
 …
  */
 /** @file
  * @brief UHCI driver
+ * @brief UHCI driver main structure for both host controller and root-hub.
  */
 #ifndef DRV_UHCI_UHCI_H
 #define DRV_UHCI_UHCI_H
+#include <ddi.h>
+#include <ddf/driver.h>
+#include <fibril.h>
+#include <fibril_synch.h>
+#include <adt/list.h>
+#include <ddi.h>
+#include <usbhc_iface.h>
+#include "batch.h"
+#include "transfer_list.h"
+#include "utils/device_keeper.h"
+typedef struct uhci_regs {
+        uint16_t usbcmd;
+#define UHCI_CMD_MAX_PACKET (1 << 7)
+#define UHCI_CMD_CONFIGURE  (1 << 6)
+#define UHCI_CMD_DEBUG  (1 << 5)
+#define UHCI_CMD_FORCE_GLOBAL_RESUME  (1 << 4)
+#define UHCI_CMD_FORCE_GLOBAL_SUSPEND  (1 << 3)
+#define UHCI_CMD_GLOBAL_RESET  (1 << 2)
+#define UHCI_CMD_HCRESET  (1 << 1)
+#define UHCI_CMD_RUN_STOP  (1 << 0)
+        uint16_t usbsts;
+#define UHCI_STATUS_HALTED (1 << 5)
+#define UHCI_STATUS_PROCESS_ERROR (1 << 4)
+#define UHCI_STATUS_SYSTEM_ERROR (1 << 3)
+#define UHCI_STATUS_RESUME (1 << 2)
+#define UHCI_STATUS_ERROR_INTERRUPT (1 << 1)
+#define UHCI_STATUS_INTERRUPT (1 << 0)
+        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;
+        uint8_t sofmod;
+} regs_t;
+#define UHCI_FRAME_LIST_COUNT 1024
+#define UHCI_CLEANER_TIMEOUT 10000
+#define UHCI_DEBUGER_TIMEOUT 5000000
+#include "uhci_hc.h"
+#include "uhci_rh.h"
 typedef struct uhci {
+        device_keeper_t device_manager;
+        ddf_fun_t *hc_fun;
+        ddf_fun_t *rh_fun;
+        volatile regs_t *registers;
+        link_pointer_t *frame_list;
+        transfer_list_t transfers_bulk_full;
+        transfer_list_t transfers_control_full;
+        transfer_list_t transfers_control_slow;
+        transfer_list_t transfers_interrupt;
+        transfer_list_t *transfers[2][4];
+        irq_code_t interrupt_code;
+        fid_t cleaner;
+        fid_t debug_checker;
+        ddf_fun_t *ddf_instance;
+        uhci_hc_t hc;
+        uhci_rh_t rh;
 } uhci_t;
+/* init uhci specifics in device.driver_data */
+int uhci_init(uhci_t *instance, ddf_dev_t *dev, void *regs, size_t reg_size);
+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(ddf_dev_t *dev)
+        { return (uhci_t*)dev->driver_data; }
+static inline uhci_t * fun_to_uhci(ddf_fun_t *fun)
+        { return (uhci_t*)fun->driver_data; }
+int uhci_init(uhci_t *instance, ddf_dev_t *device);
 #endif

uspace/drv/uhci-hcd/uhci_rh.c

-              r3e7b7cd
+              r72af8da
 /*
  * Copyright (c) 2010 Vojtech Horky
+ * Copyright (c) 2011 Jan Vesely
  * All rights reserved.
+ *
 …
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
+/** @addtogroup libusb
+/** @addtogroup drvusbuhci
  * @{
  */
 /** @file
  * @brief Common definitions for both HC driver and hub driver.
+ * @brief UHCI driver
  */
+#ifndef LIBUSB_HCDHUBD_PRIVATE_H_
+#define LIBUSB_HCDHUBD_PRIVATE_H_
+#include <assert.h>
+#include <errno.h>
+#include <str_error.h>
+#include <stdio.h>
+#define USB_HUB_DEVICE_NAME "usbhub"
+#define USB_KBD_DEVICE_NAME "hid"
+#include <usb/debug.h>
+extern link_t hc_list;
+extern usb_hc_driver_t *hc_driver;
+#include "uhci_rh.h"
+#include "uhci_hc.h"
+extern usbhc_iface_t usbhc_interface;
+/** Root hub initialization
+ * @param[in] instance RH structure to initialize
+ * @param[in] fun DDF function representing UHCI root hub
+ * @param[in] reg_addr Address of root hub status and control registers.
+ * @param[in] reg_size Size of accessible address space.
+ * @return Error code.
+ */
+int uhci_rh_init(
+    uhci_rh_t *instance, ddf_fun_t *fun, uintptr_t reg_addr, size_t reg_size)
+{
+        assert(fun);
+usb_address_t usb_get_address_by_handle(devman_handle_t);
+int usb_add_hc_device(device_t *);
+        char *match_str = NULL;
+        int ret = asprintf(&match_str, "usb&uhci&root-hub");
+        if (ret < 0) {
+                usb_log_error("Failed to create root hub match string.\n");
+                return ENOMEM;
+        }
+/** lowest allowed usb address */
+extern int usb_lowest_address;
+        ret = ddf_fun_add_match_id(fun, match_str, 100);
+        if (ret != EOK) {
+                usb_log_error("Failed(%d) to add root hub match id: %s\n",
+                    ret, str_error(ret));
+                return ret;
+        }
+/** highest allowed usb address */
+extern int usb_highest_address;
+        hw_resource_list_t *resource_list = &instance->resource_list;
+        resource_list->count = 1;
+        resource_list->resources = &instance->io_regs;
+        assert(resource_list->resources);
+        instance->io_regs.type = IO_RANGE;
+        instance->io_regs.res.io_range.address = reg_addr;
+        instance->io_regs.res.io_range.size = reg_size;
+        instance->io_regs.res.io_range.endianness = LITTLE_ENDIAN;
+/**
+ * @brief initialize address list of given hcd
+ *
+ * This function should be used only for hcd initialization.
+ * It creates interval list of free addresses, thus it is initialized as
+ * list with one interval with whole address space. Using an address shrinks
+ * the interval, freeing an address extends an interval or creates a
+ * new one.
+ *
+ * @param hcd
+ * @return
+ */
+void  usb_create_address_list(usb_hc_device_t * hcd);
+#endif
+        return EOK;
+}
 /**
  * @}

uspace/drv/uhci-hcd/uhci_rh.h

-              r3e7b7cd
+              r72af8da
 /*
  * Copyright (c) 2010 Jan Vesely
+ * Copyright (c) 2011 Jan Vesely
  * All rights reserved.
+ *
 …
  * @brief UHCI driver
  */
 #ifndef DRV_UHCI_ROOT_HUB_H
 #define DRV_UHCI_ROOT_HUB_H
+#ifndef DRV_UHCI_UHCI_RH_H
+#define DRV_UHCI_UHCI_RH_H
 #include <ddf/driver.h>
+#include <ops/hw_res.h>
+int setup_root_hub(ddf_fun_t **device, ddf_dev_t *hc);
+typedef struct uhci_rh {
+        hw_resource_list_t resource_list;
+        hw_resource_t io_regs;
+} uhci_rh_t;
+int uhci_rh_init(
+    uhci_rh_t *instance, ddf_fun_t *fun, uintptr_t reg_addr, size_t reg_size);
 #endif

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

-              r3e7b7cd
+              r72af8da
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 /** @addtogroup usb
+/** @addtogroup drvusbuhcihc
  * @{
  */
 …
 #define LINK_POINTER_ADDRESS_MASK 0xfffffff0 /* upper 28 bits */
+#define LINK_POINTER_QH(address) \
+        ((address & LINK_POINTER_ADDRESS_MASK) | LINK_POINTER_QUEUE_HEAD_FLAG)
 #endif
 /**

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

-              r3e7b7cd
+              r72af8da
 /*
  * Copyright (c) 2010 Jan Vesely
 …
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 /** @addtogroup usb
+/** @addtogroup drv usbuhcihc
  * @{
  */
 …
 typedef struct queue_head {
         volatile link_pointer_t next_queue;
+        volatile link_pointer_t next;
         volatile link_pointer_t element;
+} __attribute__((packed)) queue_head_t;
+static inline void queue_head_init(queue_head_t *instance)
+} __attribute__((packed)) qh_t;
+/*----------------------------------------------------------------------------*/
+/** Initialize queue head structure
+ *
+ * @param[in] instance qh_t structure to initialize.
+ *
+ * Sets both pointer to terminal NULL.
+ */
+static inline void qh_init(qh_t *instance)
+{
         assert(instance);
         instance->element = 0 | LINK_POINTER_TERMINATE_FLAG;
         instance->next_queue = 0 | LINK_POINTER_TERMINATE_FLAG;
+        instance->next = 0 | LINK_POINTER_TERMINATE_FLAG;
+}
+static inline void queue_head_append_qh(queue_head_t *instance, uint32_t pa)
+/*----------------------------------------------------------------------------*/
+/** Set queue head next pointer
+ *
+ * @param[in] instance qh_t structure to use.
+ * @param[in] pa Physical address of the next queue head.
+ *
+ * Adds proper flag. If the pointer is NULL or terminal, sets next to terminal
+ * NULL.
+ */
+static inline void qh_set_next_qh(qh_t *instance, uint32_t pa)
+{
+        if (pa) {
+                instance->next_queue = (pa & LINK_POINTER_ADDRESS_MASK)
+        /* Address is valid and not terminal */
+        if (pa && ((pa & LINK_POINTER_TERMINATE_FLAG) == 0)) {
+                instance->next = (pa & LINK_POINTER_ADDRESS_MASK)
                     | LINK_POINTER_QUEUE_HEAD_FLAG;
+        } else {
+                instance->next = 0 | LINK_POINTER_TERMINATE_FLAG;
+        }
+}
+static inline void queue_head_element_qh(queue_head_t *instance, uint32_t pa)
+/*----------------------------------------------------------------------------*/
+/** Set queue head element pointer
+ *
+ * @param[in] instance qh_t structure to initialize.
+ * @param[in] pa Physical address of the next queue head.
+ *
+ * Adds proper flag. If the pointer is NULL or terminal, sets element
+ * to terminal NULL.
+ */
+static inline void qh_set_element_qh(qh_t *instance, uint32_t pa)
+{
+        if (pa) {
+                instance->next_queue = (pa & LINK_POINTER_ADDRESS_MASK)
+        /* Address is valid and not terminal */
+        if (pa && ((pa & LINK_POINTER_TERMINATE_FLAG) == 0)) {
+                instance->element = (pa & LINK_POINTER_ADDRESS_MASK)
                     | LINK_POINTER_QUEUE_HEAD_FLAG;
+        } else {
+                instance->element = 0 | LINK_POINTER_TERMINATE_FLAG;
+        }
+}
+static inline void queue_head_element_td(queue_head_t *instance, uint32_t pa)
+/*----------------------------------------------------------------------------*/
+/** Set queue head element pointer
+ *
+ * @param[in] instance qh_t structure to initialize.
+ * @param[in] pa Physical address of the TD structure.
+ *
+ * Adds proper flag. If the pointer is NULL or terminal, sets element
+ * to terminal NULL.
+ */
+static inline void qh_set_element_td(qh_t *instance, uint32_t pa)
+{
         if (pa) {
+        if (pa && ((pa & LINK_POINTER_TERMINATE_FLAG) == 0)) {
                 instance->element = (pa & LINK_POINTER_ADDRESS_MASK);
+        } else {
+                instance->element = 0 | LINK_POINTER_TERMINATE_FLAG;
+        }
+}
-static inline queue_head_t * queue_head_get() {
-        queue_head_t *ret = malloc32(sizeof(queue_head_t));
-        if (ret)
-                queue_head_init(ret);
-        return ret;
+}
-static inline void queue_head_dispose(queue_head_t *head)
-        { free32(head); }
 #endif

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

-              r3e7b7cd
+              r72af8da
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 /** @addtogroup usb
+/** @addtogroup drvusbuhcihc
  * @{
  */
 …
 #include "utils/malloc32.h"
+void transfer_descriptor_init(transfer_descriptor_t *instance,
+    int error_count, size_t size, bool toggle, bool isochronous, bool low_speed,
+    usb_target_t target, int pid, void *buffer, transfer_descriptor_t *next)
+/** Initialize Transfer Descriptor
+ *
+ * @param[in] instance Memory place to initialize.
+ * @param[in] err_count Number of retries hc should attempt.
+ * @param[in] size Size of data source.
+ * @param[in] toggle Value of toggle bit.
+ * @param[in] iso True if TD represents Isochronous transfer.
+ * @param[in] low_speed Target device's speed.
+ * @param[in] target Address and endpoint receiving the transfer.
+ * @param[in] pid Packet identification (SETUP, IN or OUT).
+ * @param[in] buffer Source of data.
+ * @param[in] next Net TD in transaction.
+ * @return Error code.
+ *
+ * Uses a mix of supplied and default values.
+ * Implicit values:
+ *  - all TDs have vertical flag set (makes transfers to endpoints atomic)
+ *  - in the error field only active it is set
+ *  - if the packet uses PID_IN and is not isochronous SPD is set
+ *
+ * Dumps 8 bytes of buffer if PID_SETUP is used.
+ */
+void td_init(td_t *instance, int err_count, size_t size, bool toggle, bool iso,
+    bool low_speed, usb_target_t target, usb_packet_id pid, void *buffer,
+    td_t *next)
+{
         assert(instance);
+        assert(size < 1024);
+        assert((pid == USB_PID_SETUP) || (pid == USB_PID_IN)
+            || (pid == USB_PID_OUT));
         instance->next = 0
 …
         instance->status = 0
+          | ((error_count & TD_STATUS_ERROR_COUNT_MASK) << TD_STATUS_ERROR_COUNT_POS)
+                | (low_speed ? TD_STATUS_LOW_SPEED_FLAG : 0)
+          | TD_STATUS_ERROR_ACTIVE;
+            | ((err_count & TD_STATUS_ERROR_COUNT_MASK) << TD_STATUS_ERROR_COUNT_POS)
+            | (low_speed ? TD_STATUS_LOW_SPEED_FLAG : 0)
+            | (iso ? TD_STATUS_ISOCHRONOUS_FLAG : 0)
+            | TD_STATUS_ERROR_ACTIVE;
+        assert(size < 1024);
+        if (pid == USB_PID_IN && !iso) {
+                instance->status |= TD_STATUS_SPD_FLAG;
+        }
         instance->device = 0
                 | (((size - 1) & TD_DEVICE_MAXLEN_MASK) << TD_DEVICE_MAXLEN_POS)
                 | (toggle ? TD_DEVICE_DATA_TOGGLE_ONE_FLAG : 0)
                 | ((target.address & TD_DEVICE_ADDRESS_MASK) << TD_DEVICE_ADDRESS_POS)
                 | ((target.endpoint & TD_DEVICE_ENDPOINT_MASK) << TD_DEVICE_ENDPOINT_POS)
                 | ((pid & TD_DEVICE_PID_MASK) << TD_DEVICE_PID_POS);
+            | (((size - 1) & TD_DEVICE_MAXLEN_MASK) << TD_DEVICE_MAXLEN_POS)
+            | (toggle ? TD_DEVICE_DATA_TOGGLE_ONE_FLAG : 0)
+            | ((target.address & TD_DEVICE_ADDRESS_MASK) << TD_DEVICE_ADDRESS_POS)
+            | ((target.endpoint & TD_DEVICE_ENDPOINT_MASK) << TD_DEVICE_ENDPOINT_POS)
+            | ((pid & TD_DEVICE_PID_MASK) << TD_DEVICE_PID_POS);
         instance->buffer_ptr = 0;
 …
+        }
+        usb_log_debug2("Created TD: %X:%X:%X:%X(%p).\n",
+                instance->next, instance->status, instance->device,
+          instance->buffer_ptr, buffer);
+        usb_log_debug2("Created TD(%p): %X:%X:%X:%X(%p).\n",
+            instance, instance->next, instance->status, instance->device,
+            instance->buffer_ptr, buffer);
+        td_print_status(instance);
+        if (pid == USB_PID_SETUP) {
+                usb_log_debug("SETUP BUFFER: %s\n",
+                    usb_debug_str_buffer(buffer, 8, 8));
+        }
+}
 /*----------------------------------------------------------------------------*/
+int transfer_descriptor_status(transfer_descriptor_t *instance)
+/** Convert TD status into standard error code
+ *
+ * @param[in] instance TD structure to use.
+ * @return Error code.
+ */
+int td_status(td_t *instance)
+{
         assert(instance);
 …
         return EOK;
+}
+/*----------------------------------------------------------------------------*/
+/** Print values in status field (dw1) in a human readable way.
+ *
+ * @param[in] instance TD structure to use.
+ */
+void td_print_status(td_t *instance)
+{
+        assert(instance);
+        const uint32_t s = instance->status;
+        usb_log_debug2("TD(%p) status(%#x):%s %d,%s%s%s%s%s%s%s%s%s%s%s %d.\n",
+            instance, instance->status,
+            (s & TD_STATUS_SPD_FLAG) ? " SPD," : "",
+            (s >> TD_STATUS_ERROR_COUNT_POS) & TD_STATUS_ERROR_COUNT_MASK,
+            (s & TD_STATUS_LOW_SPEED_FLAG) ? " LOW SPEED," : "",
+            (s & TD_STATUS_ISOCHRONOUS_FLAG) ? " ISOCHRONOUS," : "",
+            (s & TD_STATUS_IOC_FLAG) ? " IOC," : "",
+            (s & TD_STATUS_ERROR_ACTIVE) ? " ACTIVE," : "",
+            (s & TD_STATUS_ERROR_STALLED) ? " STALLED," : "",
+            (s & TD_STATUS_ERROR_BUFFER) ? " BUFFER," : "",
+            (s & TD_STATUS_ERROR_BABBLE) ? " BABBLE," : "",
+            (s & TD_STATUS_ERROR_NAK) ? " NAK," : "",
+            (s & TD_STATUS_ERROR_CRC) ? " CRC/TIMEOUT," : "",
+            (s & TD_STATUS_ERROR_BIT_STUFF) ? " BIT_STUFF," : "",
+            (s & TD_STATUS_ERROR_RESERVED) ? " RESERVED," : "",
+            (s >> TD_STATUS_ACTLEN_POS) & TD_STATUS_ACTLEN_MASK
+        );
+}
 /**
  * @}

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

-              r3e7b7cd
+              r72af8da
 /*
  * Copyright (c) 2010 Jan Vesely
+ * Copyright (c) 2011 Jan Vesely
  * All rights reserved.
+ *
 …
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 /** @addtogroup usb
+/** @addtogroup drvusbuhcihc
  * @{
  */
 …
         volatile uint32_t status;
 #define TD_STATUS_RESERVED_MASK 0xc000f800
 #define TD_STATUS_SPD_FLAG ( 1 << 29 )
 #define TD_STATUS_ERROR_COUNT_POS ( 27 )
 #define TD_STATUS_ERROR_COUNT_MASK ( 0x3 )
-#define TD_STATUS_ERROR_COUNT_DEFAULT 3
 #define TD_STATUS_LOW_SPEED_FLAG ( 1 << 26 )
 #define TD_STATUS_ISOCHRONOUS_FLAG ( 1 << 25 )
 #define TD_STATUS_COMPLETE_INTERRUPT_FLAG ( 1 << 24 )
+#define TD_STATUS_IOC_FLAG ( 1 << 24 )
 #define TD_STATUS_ERROR_ACTIVE ( 1 << 23 )
 …
         volatile uint32_t device;
 #define TD_DEVICE_MAXLEN_POS 21
 #define TD_DEVICE_MAXLEN_MASK ( 0x7ff )
 …
         /* there is 16 bytes of data available here, according to UHCI
          * Design guide, according to linux kernel the hardware does not care
          * we don't use it anyway
+         * Design guide, according to linux kernel the hardware does not care,
+         * it just needs to be aligned, we don't use it anyway
          */
 } __attribute__((packed)) transfer_descriptor_t;
+} __attribute__((packed)) td_t;
 void transfer_descriptor_init(transfer_descriptor_t *instance,
     int error_count, size_t size, bool toggle, bool isochronous, bool low_speed,
     usb_target_t target, int pid, void *buffer, transfer_descriptor_t * next);
+void td_init(td_t *instance, int error_count, size_t size, bool toggle,
+    bool iso, bool low_speed, usb_target_t target, usb_packet_id pid,
+    void *buffer, td_t *next);
 int transfer_descriptor_status(transfer_descriptor_t *instance);
+int td_status(td_t *instance);
+static inline size_t transfer_descriptor_actual_size(
+    transfer_descriptor_t *instance)
+void td_print_status(td_t *instance);
+/*----------------------------------------------------------------------------*/
+/** Helper function for parsing actual size out of TD.
+ *
+ * @param[in] instance TD structure to use.
+ * @return Parsed actual size.
+ */
+static inline size_t td_act_size(td_t *instance)
+{
         assert(instance);
+        const uint32_t s = instance->status;
+        return ((s >> TD_STATUS_ACTLEN_POS) + 1) & TD_STATUS_ACTLEN_MASK;
+}
+/*----------------------------------------------------------------------------*/
+/** Check whether less than max data were recieved and packet is marked as SPD.
+ *
+ * @param[in] instance TD structure to use.
+ * @return True if packet is short (less than max bytes and SPD set), false
+ *     otherwise.
+ */
+static inline bool td_is_short(td_t *instance)
+{
+        const size_t act_size = td_act_size(instance);
+        const size_t max_size =
+            ((instance->device >> TD_DEVICE_MAXLEN_POS) + 1)
+            & TD_DEVICE_MAXLEN_MASK;
         return
             ((instance->status >> TD_STATUS_ACTLEN_POS) + 1) & TD_STATUS_ACTLEN_MASK;
+            (instance->status | TD_STATUS_SPD_FLAG) && act_size < max_size;
+}
+static inline bool transfer_descriptor_is_active(
+    transfer_descriptor_t *instance)
+/*----------------------------------------------------------------------------*/
+/** Helper function for parsing value of toggle bit.
+ *
+ * @param[in] instance TD structure to use.
+ * @return Toggle bit value.
+ */
+static inline int td_toggle(td_t *instance)
+{
+        assert(instance);
+        return (instance->device & TD_DEVICE_DATA_TOGGLE_ONE_FLAG) ? 1 : 0;
+}
+/*----------------------------------------------------------------------------*/
+/** Helper function for parsing value of active bit
+ *
+ * @param[in] instance TD structure to use.
+ * @return Active bit value.
+ */
+static inline bool td_is_active(td_t *instance)
+{
         assert(instance);
         return (instance->status & TD_STATUS_ERROR_ACTIVE) != 0;
+}
+/*----------------------------------------------------------------------------*/
+/** Helper function for setting IOC bit.
+ *
+ * @param[in] instance TD structure to use.
+ */
+static inline void td_set_ioc(td_t *instance)
+{
+        assert(instance);
+        instance->status |= TD_STATUS_IOC_FLAG;
+}
+/*----------------------------------------------------------------------------*/
 #endif
 /**

uspace/drv/uhci-hcd/utils/device_keeper.c

-              r3e7b7cd
+              r72af8da
  */
 /** @addtogroup drvusbuhci
+/** @addtogroup drvusbuhcihc
  * @{
  */
 …
 #include <assert.h>
 #include <errno.h>
+#include <usb/debug.h>
 #include "device_keeper.h"
 /*----------------------------------------------------------------------------*/
+/** Initialize device keeper structure.
+ *
+ * @param[in] instance Memory place to initialize.
+ *
+ * Set all values to false/0.
+ */
 void device_keeper_init(device_keeper_t *instance)
+{
 …
                 instance->devices[i].occupied = false;
                 instance->devices[i].handle = 0;
+        }
+}
+/*----------------------------------------------------------------------------*/
+void device_keeper_reserve_default(
+    device_keeper_t *instance, usb_speed_t speed)
+                instance->devices[i].toggle_status = 0;
+        }
+}
+/*----------------------------------------------------------------------------*/
+/** Attempt to obtain address 0, blocks.
+ *
+ * @param[in] instance Device keeper structure to use.
+ * @param[in] speed Speed of the device requesting default address.
+ */
+void device_keeper_reserve_default(device_keeper_t *instance, usb_speed_t speed)
+{
         assert(instance);
 …
+}
 /*----------------------------------------------------------------------------*/
+/** Attempt to obtain address 0, blocks.
+ *
+ * @param[in] instance Device keeper structure to use.
+ * @param[in] speed Speed of the device requesting default address.
+ */
 void device_keeper_release_default(device_keeper_t *instance)
+{
 …
+}
 /*----------------------------------------------------------------------------*/
+/** Check setup packet data for signs of toggle reset.
+ *
+ * @param[in] instance Device keeper structure to use.
+ * @param[in] target Device to receive setup packet.
+ * @param[in] data Setup packet data.
+ *
+ * Really ugly one.
+ */
+void device_keeper_reset_if_need(
+    device_keeper_t *instance, usb_target_t target, const unsigned char *data)
+{
+        assert(instance);
+        fibril_mutex_lock(&instance->guard);
+        if (target.endpoint > 15 || target.endpoint < 0
+            || target.address >= USB_ADDRESS_COUNT || target.address < 0
+            || !instance->devices[target.address].occupied) {
+                fibril_mutex_unlock(&instance->guard);
+                usb_log_error("Invalid data when checking for toggle reset.\n");
+                return;
+        }
+        switch (data[1])
+        {
+        case 0x01: /*clear feature*/
+                /* recipient is endpoint, value is zero (ENDPOINT_STALL) */
+                if (((data[0] & 0xf) == 1) && ((data[2] | data[3]) == 0)) {
+                        /* endpoint number is < 16, thus first byte is enough */
+                        instance->devices[target.address].toggle_status &=
+                            ~(1 << data[4]);
+                }
+        break;
+        case 0x9: /* set configuration */
+        case 0x11: /* set interface */
+                /* target must be device */
+                if ((data[0] & 0xf) == 0) {
+                        instance->devices[target.address].toggle_status = 0;
+                }
+        break;
+        }
+        fibril_mutex_unlock(&instance->guard);
+}
+/*----------------------------------------------------------------------------*/
+/** Get current value of endpoint toggle.
+ *
+ * @param[in] instance Device keeper structure to use.
+ * @param[in] target Device and endpoint used.
+ * @return Error code
+ */
+int device_keeper_get_toggle(device_keeper_t *instance, usb_target_t target)
+{
+        assert(instance);
+        int ret;
+        fibril_mutex_lock(&instance->guard);
+        if (target.endpoint > 15 || target.endpoint < 0
+            || target.address >= USB_ADDRESS_COUNT || target.address < 0
+            || !instance->devices[target.address].occupied) {
+                usb_log_error("Invalid data when asking for toggle value.\n");
+                ret = EINVAL;
+        } else {
+                ret = (instance->devices[target.address].toggle_status
+                        >> target.endpoint) & 1;
+        }
+        fibril_mutex_unlock(&instance->guard);
+        return ret;
+}
+/*----------------------------------------------------------------------------*/
+/** Set current value of endpoint toggle.
+ *
+ * @param[in] instance Device keeper structure to use.
+ * @param[in] target Device and endpoint used.
+ * @param[in] toggle Toggle value.
+ * @return Error code.
+ */
+int device_keeper_set_toggle(
+    device_keeper_t *instance, usb_target_t target, bool toggle)
+{
+        assert(instance);
+        int ret;
+        fibril_mutex_lock(&instance->guard);
+        if (target.endpoint > 15 || target.endpoint < 0
+            || target.address >= USB_ADDRESS_COUNT || target.address < 0
+            || !instance->devices[target.address].occupied) {
+                usb_log_error("Invalid data when setting toggle value.\n");
+                ret = EINVAL;
+        } else {
+                if (toggle) {
+                        instance->devices[target.address].toggle_status |= (1 << target.endpoint);
+                } else {
+                        instance->devices[target.address].toggle_status &= ~(1 << target.endpoint);
+                }
+                ret = EOK;
+        }
+        fibril_mutex_unlock(&instance->guard);
+        return ret;
+}
+/*----------------------------------------------------------------------------*/
+/** Get a free USB address
+ *
+ * @param[in] instance Device keeper structure to use.
+ * @param[in] speed Speed of the device requiring address.
+ * @return Free address, or error code.
+ */
 usb_address_t device_keeper_request(
     device_keeper_t *instance, usb_speed_t speed)
 …
         instance->devices[new_address].occupied = true;
         instance->devices[new_address].speed = speed;
+        instance->devices[new_address].toggle_status = 0;
         instance->last_address = new_address;
         fibril_mutex_unlock(&instance->guard);
 …
+}
 /*----------------------------------------------------------------------------*/
+/** Bind USB address to devman handle.
+ *
+ * @param[in] instance Device keeper structure to use.
+ * @param[in] address Device address
+ * @param[in] handle Devman handle of the device.
+ */
 void device_keeper_bind(
     device_keeper_t *instance, usb_address_t address, devman_handle_t handle)
 …
+}
 /*----------------------------------------------------------------------------*/
+/** Release used USB address.
+ *
+ * @param[in] instance Device keeper structure to use.
+ * @param[in] address Device address
+ */
 void device_keeper_release(device_keeper_t *instance, usb_address_t address)
+{
 …
+}
 /*----------------------------------------------------------------------------*/
+/** Find USB address associated with the device
+ *
+ * @param[in] instance Device keeper structure to use.
+ * @param[in] handle Devman handle of the device seeking its address.
+ * @return USB Address, or error code.
+ */
 usb_address_t device_keeper_find(
     device_keeper_t *instance, devman_handle_t handle)
 …
+}
 /*----------------------------------------------------------------------------*/
+/** Get speed associated with the address
+ *
+ * @param[in] instance Device keeper structure to use.
+ * @param[in] address Address of the device.
+ * @return USB speed.
+ */
 usb_speed_t device_keeper_speed(
     device_keeper_t *instance, usb_address_t address)

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

-              r3e7b7cd
+              r72af8da
  */
 /** @addtogroup drvusbuhci
+/** @addtogroup drvusbuhcihc
  * @{
  */
 …
         usb_speed_t speed;
         bool occupied;
+        uint16_t toggle_status;
         devman_handle_t handle;
 };
 …
 void device_keeper_init(device_keeper_t *instance);
 void device_keeper_reserve_default(
     device_keeper_t *instance, usb_speed_t speed);
 void device_keeper_release_default(device_keeper_t *instance);
+void device_keeper_reset_if_need(
+    device_keeper_t *instance, usb_target_t target, const unsigned char *setup_data);
+int device_keeper_get_toggle(device_keeper_t *instance, usb_target_t target);
+int device_keeper_set_toggle(
+    device_keeper_t *instance, usb_target_t target, bool toggle);
 usb_address_t device_keeper_request(
     device_keeper_t *instance, usb_speed_t speed);
 void device_keeper_bind(
     device_keeper_t *instance, usb_address_t address, devman_handle_t handle);
 void device_keeper_release(device_keeper_t *instance, usb_address_t address);
 usb_address_t device_keeper_find(
     device_keeper_t *instance, devman_handle_t handle);

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

-              r3e7b7cd
+              r72af8da
 #define DRV_UHCI_TRANSLATOR_H
-#include <usb/usbmem.h>
 #include <assert.h>
 #include <malloc.h>
 …
 #define UHCI_REQUIRED_PAGE_SIZE 4096
+/** Get physical address translation
+ *
+ * @param[in] addr Virtual address to translate
+ * @return Physical address if exists, NULL otherwise.
+ */
 static inline uintptr_t addr_to_phys(void *addr)
+{
 …
         int ret = as_get_physical_mapping(addr, &result);
+        assert(ret == 0);
+        if (ret != EOK)
+                return 0;
         return (result | ((uintptr_t)addr & 0xfff));
+}
+/*----------------------------------------------------------------------------*/
+/** Physical mallocator simulator
+ *
+ * @param[in] size Size of the required memory space
+ * @return Address of the alligned and big enough memory place, NULL on failure.
+ */
 static inline void * malloc32(size_t size)
         { return memalign(UHCI_STRCUTURES_ALIGNMENT, size); }
+static inline void * get_page()
+/*----------------------------------------------------------------------------*/
+/** Physical mallocator simulator
+ *
+ * @param[in] addr Address of the place allocated by malloc32
+ */
+static inline void free32(void *addr)
+        { if (addr) free(addr); }
+/*----------------------------------------------------------------------------*/
+/** Create 4KB page mapping
+ *
+ * @return Address of the mapped page, NULL on failure.
+ */
+static inline void * get_page(void)
+{
         void * free_address = as_get_mappable_page(UHCI_REQUIRED_PAGE_SIZE);
         assert(free_address);
         if (free_address == 0)
                 return 0;
+                return NULL;
         void* ret =
           as_area_create(free_address, UHCI_REQUIRED_PAGE_SIZE,
                   AS_AREA_READ | AS_AREA_WRITE);
         if (ret != free_address)
                 return 0;
+                return NULL;
         return ret;
+}
-static inline void free32(void *addr)
-        { if (addr) free(addr); }
 #endif

Context Navigation

Changeset 72af8da in mainline for uspace/drv/uhci-hcd

Legend:

uspace/drv/uhci-hcd/Makefile

uspace/drv/uhci-hcd/batch.c

uspace/drv/uhci-hcd/batch.h

uspace/drv/uhci-hcd/iface.c

uspace/drv/uhci-hcd/iface.h

uspace/drv/uhci-hcd/main.c

uspace/drv/uhci-hcd/pci.c

uspace/drv/uhci-hcd/pci.h

uspace/drv/uhci-hcd/transfer_list.c

uspace/drv/uhci-hcd/transfer_list.h

uspace/drv/uhci-hcd/uhci.c

uspace/drv/uhci-hcd/uhci.h

uspace/drv/uhci-hcd/uhci_rh.c

uspace/drv/uhci-hcd/uhci_rh.h

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

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

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

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

uspace/drv/uhci-hcd/utils/device_keeper.c

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

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

Download in other formats: